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
13fn has_foreign_key_relations(table: &&Table) -> bool {
14 table
15 .relations()
16 .iter()
17 .any(Relation::creates_foreign_key_constraint)
18}
19
20pub struct DefaultRelationGenerator {
21 context: GeneratorContext,
22}
23
24impl DefaultRelationGenerator {
25 pub fn new(context: GeneratorContext) -> Self {
26 Self { context }
27 }
28
29 pub fn context(&self) -> &GeneratorContext {
30 &self.context
31 }
32
33 fn output_relation_for_table(&self, writer: &mut SqlWriter, table: &Table) {
34 let database_model = self.context.settings().database_model();
35
36 for (relation_index, relation) in table.relations().iter().enumerate() {
37 if !relation.creates_foreign_key_constraint() {
38 continue;
39 }
40 let relation_name = self.relation_constraint_name(table, relation_index);
41 self.output_relation(writer, &relation_name, database_model, table, relation);
42 }
43 }
44
45 pub fn relation_constraint_name(&self, table: &Table, relation_index: usize) -> String {
48 let database_type = self.context.settings().database_type();
49 foreign_key_name(database_type, table.name(), relation_index + 1)
50 }
51
52 fn output_relation(
53 &self,
54 writer: &mut SqlWriter,
55 relation_name: &str,
56 database_model: &DatabaseModel,
57 table: &Table,
58 relation: &Relation,
59 ) {
60 let operation = self.relation_operation_type(relation.relation_type());
61 let database_type = self.context.settings().database_type();
62 let to_table = database_model.find_table_by_qualified_name(relation.to_table_name());
63
64 let from_columns = relation
65 .column_pairs()
66 .iter()
67 .map(|(from, _)| from.as_str())
68 .collect::<Vec<_>>()
69 .join(", ");
70 let to_columns = relation
71 .column_pairs()
72 .iter()
73 .map(|(_, to)| to.as_str())
74 .collect::<Vec<_>>()
75 .join(", ");
76
77 writer.print(
78 format!(
79 "alter table {}",
80 table.fully_qualified_table_name(database_type)
81 )
82 .as_str(),
83 );
84 writer.print(" add constraint ");
85 writer.print(relation_name);
86 writer.print(" foreign key (");
87 writer.print(from_columns.as_str());
88 writer.print(") references ");
89 writer.print(to_table.fully_qualified_table_name(database_type).as_str());
90 writer.print("(");
91 writer.print(to_columns.as_str());
92 writer.print(") on delete ");
93 writer.print(operation);
94 writer.println(self.context().settings().statement_separator());
95 }
96
97 pub fn relation_operation_type(&self, relation_type: RelationType) -> &str {
98 match relation_type {
99 RelationType::Cascade => "cascade",
100 RelationType::Enforce => "no action",
101 RelationType::SetNull => "set null",
102 RelationType::DoNothing => "no action",
103 }
104 }
105}
106
107impl RelationGenerator for DefaultRelationGenerator {
108 fn output_relations(&self) {
109 let database_model = self.context.settings().database_model();
110 let has_relations = database_model
111 .all_tables()
112 .iter()
113 .any(has_foreign_key_relations);
114
115 if has_relations {
116 self.context.with_writer(|writer| {
117 writer.println("/* relations */");
118
119 database_model
120 .all_tables()
121 .iter()
122 .filter(|table| has_foreign_key_relations(table))
123 .for_each(|table| {
124 self.output_relation_for_table(writer, table);
125 });
126
127 writer.newline();
128 });
129 }
130 }
131}
132
133#[cfg(test)]
134mod tests {
135 use super::*;
136 use crate::common::test_support::make_context;
137 use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
138 use schema_model::model::column_type::ColumnType;
139 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
140
141 #[test]
142 fn output_relations_truncates_generated_constraint_name_for_long_table_names() {
143 let long_table_name = "a".repeat(70);
147 let parent = TableBuilder::new(None::<&str>, "parent")
148 .add_column(
149 ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
150 .required(true)
151 .build(),
152 )
153 .build();
154 let child = TableBuilder::new(None::<&str>, long_table_name.as_str())
155 .add_column(
156 ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int)
157 .required(true)
158 .build(),
159 )
160 .add_relation(Relation::new(
161 "parent",
162 "id",
163 long_table_name.as_str(),
164 "parent_id",
165 RelationType::Cascade,
166 false,
167 ))
168 .build();
169 let schema = SchemaBuilder::new(None::<&str>)
170 .add_table(parent)
171 .add_table(child)
172 .build();
173 let model =
174 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
175 let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
176
177 let generator = DefaultRelationGenerator::new(ctx);
178 generator.output_relations();
179
180 let output = buffer.contents();
181 assert!(output.contains("add constraint "));
182 let constraint_start = output.find("add constraint ").unwrap() + "add constraint ".len();
183 let constraint_name = &output[constraint_start..]
184 .split_whitespace()
185 .next()
186 .unwrap();
187 assert!(
188 constraint_name.len() <= 63,
189 "constraint name '{}' exceeds postgres's 63 char limit",
190 constraint_name
191 );
192 }
193
194 #[test]
195 fn output_relations_skips_donothing_relations_but_keeps_ordinals_stable() {
196 let parent = TableBuilder::new(None::<&str>, "parent")
197 .add_column(
198 ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
199 .required(true)
200 .build(),
201 )
202 .build();
203 let child = TableBuilder::new(None::<&str>, "child")
204 .add_column(ColumnBuilder::new(None::<&str>, "a_id", ColumnType::Int).build())
205 .add_column(ColumnBuilder::new(None::<&str>, "b_id", ColumnType::Int).build())
206 .add_relation(Relation::new(
207 "parent",
208 "id",
209 "child",
210 "a_id",
211 RelationType::DoNothing,
212 false,
213 ))
214 .add_relation(Relation::new(
215 "parent",
216 "id",
217 "child",
218 "b_id",
219 RelationType::Enforce,
220 false,
221 ))
222 .build();
223 let schema = SchemaBuilder::new(None::<&str>)
224 .add_table(parent)
225 .add_table(child)
226 .build();
227 let model =
228 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
229 let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
230
231 DefaultRelationGenerator::new(ctx).output_relations();
232
233 let output = buffer.contents();
234 assert!(
235 !output.contains("a_id"),
236 "donothing relation must emit no constraint: {output}"
237 );
238 assert!(output.contains("foreign key (b_id)"));
239 assert!(output.contains("fk_child2"), "{output}");
241 }
242
243 #[test]
244 fn output_relations_emits_nothing_when_every_relation_is_donothing() {
245 let parent = TableBuilder::new(None::<&str>, "parent")
246 .add_column(
247 ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
248 .required(true)
249 .build(),
250 )
251 .build();
252 let child = TableBuilder::new(None::<&str>, "child")
253 .add_column(ColumnBuilder::new(None::<&str>, "a_id", ColumnType::Int).build())
254 .add_relation(Relation::new(
255 "parent",
256 "id",
257 "child",
258 "a_id",
259 RelationType::DoNothing,
260 false,
261 ))
262 .build();
263 let schema = SchemaBuilder::new(None::<&str>)
264 .add_table(parent)
265 .add_table(child)
266 .build();
267 let model =
268 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
269 let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
270
271 DefaultRelationGenerator::new(ctx).output_relations();
272
273 assert_eq!(buffer.contents(), "");
274 }
275
276 #[test]
277 fn relation_constraint_name_truncates_multi_byte_table_name_without_panicking() {
278 let long_table_name = "语".repeat(70);
281 let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
282 let schema = SchemaBuilder::new(None::<&str>)
283 .add_table(table.clone())
284 .build();
285 let model =
286 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
287 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
288
289 let generator = DefaultRelationGenerator::new(ctx);
290 let name = generator.relation_constraint_name(&table, 0);
291 assert!(name.starts_with("fk_"));
292 assert!(name.chars().count() <= 32);
296 }
297
298 #[test]
299 fn output_relations_renders_composite_foreign_key_constraint() {
300 let parent = TableBuilder::new(None::<&str>, "parent")
301 .add_column(
302 ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
303 .required(true)
304 .build(),
305 )
306 .add_column(
307 ColumnBuilder::new(None::<&str>, "tenant_id", ColumnType::Int)
308 .required(true)
309 .build(),
310 )
311 .build();
312 let child = TableBuilder::new(None::<&str>, "child")
313 .add_column(
314 ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int)
315 .required(true)
316 .build(),
317 )
318 .add_column(
319 ColumnBuilder::new(None::<&str>, "tenant_id", ColumnType::Int)
320 .required(true)
321 .build(),
322 )
323 .add_relation(
324 Relation::new_composite(
325 "parent",
326 "child",
327 vec![("parent_id", "id"), ("tenant_id", "tenant_id")],
328 RelationType::Cascade,
329 false,
330 )
331 .unwrap(),
332 )
333 .build();
334 let schema = SchemaBuilder::new(None::<&str>)
335 .add_table(parent)
336 .add_table(child)
337 .build();
338 let model =
339 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
340 let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
341
342 let generator = DefaultRelationGenerator::new(ctx);
343 generator.output_relations();
344
345 let output = buffer.contents();
346 assert!(
347 output.contains(
348 "foreign key (parent_id, tenant_id) references public.parent(id, tenant_id)"
349 ),
350 "unexpected output: {output}"
351 );
352 }
353
354 #[test]
355 fn relation_constraint_name_stays_within_limit_for_double_digit_relation_index() {
356 let long_table_name = "a".repeat(40);
360 let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
361 let schema = SchemaBuilder::new(None::<&str>)
362 .add_table(table.clone())
363 .build();
364 let model =
365 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
366 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
367
368 let generator = DefaultRelationGenerator::new(ctx);
369 let name = generator.relation_constraint_name(&table, 9);
371 assert!(name.ends_with("10"));
372 assert!(
373 name.len() <= 32,
374 "constraint name '{}' exceeds SQL Server's 32 char limit",
375 name
376 );
377 }
378}