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;
7use schema_model::naming::foreign_key_name;
8
9pub trait RelationGenerator {
10 fn output_relations(&self);
11}
12
13pub struct DefaultRelationGenerator {
14 context: GeneratorContext,
15}
16
17impl DefaultRelationGenerator {
18 pub fn new(context: GeneratorContext) -> Self {
19 Self {
20 context,
21 }
22 }
23
24 pub fn context(&self) -> &GeneratorContext {
25 &self.context
26 }
27
28 fn output_relation_for_table(&self, writer: &mut SqlWriter, table: &Table) {
29 let database_model = self.context.settings().database_model();
30
31 for (relation_index, relation) in table.relations().iter().enumerate() {
32 let relation_name = self.relation_constraint_name(table, relation_index);
33 self.output_relation(writer, &relation_name, database_model, table, relation);
34 }
35 }
36
37 pub fn relation_constraint_name(&self, table: &Table, relation_index: usize) -> String {
40 let database_type = self.context.settings().database_type();
41 foreign_key_name(database_type, table.name(), relation_index + 1)
42 }
43
44 fn output_relation(&self,
45 writer: &mut SqlWriter,
46 relation_name: &str,
47 database_model: &DatabaseModel,
48 table: &Table,
49 relation: &Relation) {
50 let operation = self.relation_operation_type(relation.relation_type());
51 let database_type = self.context.settings().database_type();
52 let to_table = database_model.find_table_by_qualified_name(relation.to_table_name());
53
54 let from_columns = relation
55 .column_pairs()
56 .iter()
57 .map(|(from, _)| from.as_str())
58 .collect::<Vec<_>>()
59 .join(", ");
60 let to_columns = relation
61 .column_pairs()
62 .iter()
63 .map(|(_, to)| to.as_str())
64 .collect::<Vec<_>>()
65 .join(", ");
66
67 writer.print(format!("alter table {}", table.fully_qualified_table_name(database_type)).as_str());
68 writer.print(" add constraint ");
69 writer.print(relation_name);
70 writer.print(" foreign key (");
71 writer.print(from_columns.as_str());
72 writer.print(") references ");
73 writer.print(to_table.fully_qualified_table_name(database_type).as_str());
74 writer.print("(");
75 writer.print(to_columns.as_str());
76 writer.print(") on delete ");
77 writer.print(operation);
78 writer.println(self.context().settings().statement_separator());
79 }
80
81 pub fn relation_operation_type(&self, relation_type: RelationType) -> &str {
82 match relation_type {
83 RelationType::Cascade => {"cascade"}
84 RelationType::Enforce => {"no action"}
85 RelationType::SetNull => {"set null"}
86 RelationType::DoNothing => {"no action"}
87 }
88 }
89
90}
91
92impl RelationGenerator for DefaultRelationGenerator {
93 fn output_relations(&self) {
94 let database_model = self.context.settings().database_model();
95 let has_relations = database_model.all_tables().iter().any(|table| {!table.relations().is_empty()});
96
97 if has_relations {
98 self.context.with_writer(|writer| {
99 writer.println("/* relations */");
100
101 database_model.all_tables().iter().filter(|table| {
102 !table.relations().is_empty()
103 }).for_each(|table| {
104 self.output_relation_for_table(writer, table);
105 });
106
107 writer.newline();
108 });
109 }
110 }
111}
112
113#[cfg(test)]
114mod tests {
115 use super::*;
116 use crate::common::test_support::make_context;
117 use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
118 use schema_model::model::column_type::ColumnType;
119 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
120
121 #[test]
122 fn output_relations_truncates_generated_constraint_name_for_long_table_names() {
123 let long_table_name = "a".repeat(70);
127 let parent = TableBuilder::new(None::<&str>, "parent")
128 .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
129 .build();
130 let child = TableBuilder::new(None::<&str>, long_table_name.as_str())
131 .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).required(true).build())
132 .add_relation(Relation::new("parent", "id", long_table_name.as_str(), "parent_id", RelationType::Cascade, false))
133 .build();
134 let schema = SchemaBuilder::new(None::<&str>)
135 .add_table(parent)
136 .add_table(child)
137 .build();
138 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
139 let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
140
141 let generator = DefaultRelationGenerator::new(ctx);
142 generator.output_relations();
143
144 let output = buffer.contents();
145 assert!(output.contains("add constraint "));
146 let constraint_start = output.find("add constraint ").unwrap() + "add constraint ".len();
147 let constraint_name = &output[constraint_start..].split_whitespace().next().unwrap();
148 assert!(constraint_name.len() <= 63, "constraint name '{}' exceeds postgres's 63 char limit", constraint_name);
149 }
150
151 #[test]
152 fn relation_constraint_name_truncates_multi_byte_table_name_without_panicking() {
153 let long_table_name = "语".repeat(70);
156 let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
157 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
158 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
159 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
160
161 let generator = DefaultRelationGenerator::new(ctx);
162 let name = generator.relation_constraint_name(&table, 0);
163 assert!(name.starts_with("fk_"));
164 assert!(name.chars().count() <= 32);
168 }
169
170 #[test]
171 fn output_relations_renders_composite_foreign_key_constraint() {
172 let parent = TableBuilder::new(None::<&str>, "parent")
173 .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
174 .add_column(ColumnBuilder::new(None::<&str>, "tenant_id", ColumnType::Int).required(true).build())
175 .build();
176 let child = TableBuilder::new(None::<&str>, "child")
177 .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).required(true).build())
178 .add_column(ColumnBuilder::new(None::<&str>, "tenant_id", ColumnType::Int).required(true).build())
179 .add_relation(
180 Relation::new_composite(
181 "parent",
182 "child",
183 vec![("parent_id", "id"), ("tenant_id", "tenant_id")],
184 RelationType::Cascade,
185 false,
186 )
187 .unwrap(),
188 )
189 .build();
190 let schema = SchemaBuilder::new(None::<&str>)
191 .add_table(parent)
192 .add_table(child)
193 .build();
194 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
195 let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
196
197 let generator = DefaultRelationGenerator::new(ctx);
198 generator.output_relations();
199
200 let output = buffer.contents();
201 assert!(
202 output.contains("foreign key (parent_id, tenant_id) references public.parent(id, tenant_id)"),
203 "unexpected output: {output}"
204 );
205 }
206
207 #[test]
208 fn relation_constraint_name_stays_within_limit_for_double_digit_relation_index() {
209 let long_table_name = "a".repeat(40);
213 let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
214 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
215 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
216 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
217
218 let generator = DefaultRelationGenerator::new(ctx);
219 let name = generator.relation_constraint_name(&table, 9);
221 assert!(name.ends_with("10"));
222 assert!(name.len() <= 32, "constraint name '{}' exceeds SQL Server's 32 char limit", name);
223 }
224}