Skip to main content

schema_sql_generator/common/
relation_generator.rs

1use 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    /// Builds the constraint name for the given relation, truncating the table-name
46    /// portion so the identifier stays within the target database's max key name length.
47    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        // Postgres caps key names at 63 chars; a long table name plus the "fk_" prefix and
144        // trailing index would overflow that, so the generator must truncate the table name
145        // portion rather than emit an invalid identifier.
146        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        // Still the second relation, so its name keeps ordinal 2.
240        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        // Regression test: byte-index slicing panics ("not a char boundary") on
279        // multi-byte UTF-8 once truncation kicks in; truncating by char must not.
280        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        // max_key_name_length is a character budget (SQL Server identifiers are
293        // nvarchar), not a byte budget, so compare char count, not `str::len()` (bytes)
294        // - which would always be inflated for multi-byte UTF-8 like "语".
295        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        // Regression test: reserving only 1 char for the suffix (instead of measuring
357        // its actual length) produced a 33-char identifier here, one over SQL Server's
358        // 32-char limit, once the relation index reaches double digits.
359        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        // relation_index 9 -> suffix "10" (double digit)
370        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}