schema_sql_generator/common/
relation_generator.rs1use crate::common::generator_context::GeneratorContext;
2use crate::common::sql_writer::SqlWriter;
3use schema_model::model::database_model::DatabaseModel;
4use schema_model::model::relation::Relation;
5use schema_model::model::table::Table;
6use schema_model::model::types::RelationType;
7
8const FK_PREFIX: &str = "fk_";
9
10pub trait RelationGenerator {
11 fn output_relations(&self);
12}
13
14pub struct DefaultRelationGenerator {
15 context: GeneratorContext,
16}
17
18impl DefaultRelationGenerator {
19 pub fn new(context: GeneratorContext) -> Self {
20 Self {
21 context,
22 }
23 }
24
25 pub fn context(&self) -> &GeneratorContext {
26 &self.context
27 }
28
29 fn output_relation_for_table(&self, writer: &mut SqlWriter, table: &Table) {
30 let database_type = self.context.settings().database_type();
31 let database_model = self.context.settings().database_model();
32 let max_key_name_length = database_type.max_key_name_length();
33 let table_name = table.name();
34 let relations = table.relations();
35
36 for (relation_index, relation) in relations.iter().enumerate() {
37 let mut relation_name = format!("{}{}{}", FK_PREFIX, table_name, relation_index + 1);
38
39 if relation_name.len() > max_key_name_length {
40 let truncated_table_name_len = max_key_name_length - FK_PREFIX.len() - 1; let truncated_table_name = &table_name[..truncated_table_name_len.min(table_name.len())];
42 relation_name = format!("{}{}{}", FK_PREFIX, truncated_table_name, relation_index + 1);
43 }
44
45 self.output_relation(writer, &relation_name.to_lowercase(), database_model, table, relation);
46 }
47 }
48
49 fn output_relation(&self,
50 writer: &mut SqlWriter,
51 relation_name: &str,
52 database_model: &DatabaseModel,
53 table: &Table,
54 relation: &Relation) {
55 let operation = self.relation_operation_type(relation.relation_type());
56 let database_type = self.context.settings().database_type();
57 let to_table = database_model.find_table_by_qualified_name(relation.to_table_name());
58
59 writer.print(format!("alter table {}", table.fully_qualified_table_name(database_type)).as_str());
60 writer.print(" add constraint ");
61 writer.print(relation_name);
62 writer.print(" foreign key (");
63 writer.print(relation.from_column_name());
64 writer.print(") references ");
65 writer.print(to_table.fully_qualified_table_name(database_type).as_str());
66 writer.print("(");
67 writer.print(relation.to_column_name());
68 writer.print(") on delete ");
69 writer.print(operation);
70 writer.println(self.context().settings().statement_separator());
71 }
72
73 fn relation_operation_type(&self, relation_type: RelationType) -> &str {
74 match relation_type {
75 RelationType::Cascade => {"cascade"}
76 RelationType::Enforce => {"no action"}
77 RelationType::SetNull => {"set null"}
78 RelationType::DoNothing => {"no action"}
79 }
80 }
81
82}
83
84impl RelationGenerator for DefaultRelationGenerator {
85 fn output_relations(&self) {
86 let database_model = self.context.settings().database_model();
87 let has_relations = database_model.all_tables().iter().any(|table| {!table.relations().is_empty()});
88
89 if has_relations {
90 self.context.with_writer(|writer| {
91 writer.println("/* relations */");
92
93 database_model.all_tables().iter().filter(|table| {
94 !table.relations().is_empty()
95 }).for_each(|table| {
96 self.output_relation_for_table(writer, table);
97 });
98
99 writer.newline();
100 });
101 }
102 }
103}
104
105#[cfg(test)]
106mod tests {
107 use super::*;
108 use crate::common::test_support::make_context;
109 use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
110 use schema_model::model::column_type::ColumnType;
111 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
112
113 #[test]
114 fn output_relations_truncates_generated_constraint_name_for_long_table_names() {
115 let long_table_name = "a".repeat(70);
119 let parent = TableBuilder::new(None::<&str>, "parent")
120 .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
121 .build();
122 let child = TableBuilder::new(None::<&str>, long_table_name.as_str())
123 .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).required(true).build())
124 .add_relation(Relation::new("parent", "id", long_table_name.as_str(), "parent_id", RelationType::Cascade, false))
125 .build();
126 let schema = SchemaBuilder::new(None::<&str>)
127 .add_table(parent)
128 .add_table(child)
129 .build();
130 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
131 let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
132
133 let generator = DefaultRelationGenerator::new(ctx);
134 generator.output_relations();
135
136 let output = buffer.contents();
137 assert!(output.contains("add constraint "));
138 let constraint_start = output.find("add constraint ").unwrap() + "add constraint ".len();
139 let constraint_name = &output[constraint_start..].split_whitespace().next().unwrap();
140 assert!(constraint_name.len() <= 63, "constraint name '{}' exceeds postgres's 63 char limit", constraint_name);
141 }
142}