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
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    /// Builds the constraint name for the given relation, truncating the table-name
38    /// portion so the identifier stays within the target database's max key name length.
39    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        // Postgres caps key names at 63 chars; a long table name plus the "fk_" prefix and
124        // trailing index would overflow that, so the generator must truncate the table name
125        // portion rather than emit an invalid identifier.
126        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        // Regression test: byte-index slicing panics ("not a char boundary") on
154        // multi-byte UTF-8 once truncation kicks in; truncating by char must not.
155        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        // max_key_name_length is a character budget (SQL Server identifiers are
165        // nvarchar), not a byte budget, so compare char count, not `str::len()` (bytes)
166        // - which would always be inflated for multi-byte UTF-8 like "语".
167        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        // Regression test: reserving only 1 char for the suffix (instead of measuring
210        // its actual length) produced a 33-char identifier here, one over SQL Server's
211        // 32-char limit, once the relation index reaches double digits.
212        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        // relation_index 9 -> suffix "10" (double digit)
220        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}