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        writer.print(format!("alter table {}", table.fully_qualified_table_name(database_type)).as_str());
55        writer.print(" add constraint ");
56        writer.print(relation_name);
57        writer.print(" foreign key (");
58        writer.print(relation.from_column_name());
59        writer.print(") references ");
60        writer.print(to_table.fully_qualified_table_name(database_type).as_str());
61        writer.print("(");
62        writer.print(relation.to_column_name());
63        writer.print(") on delete ");
64        writer.print(operation);
65        writer.println(self.context().settings().statement_separator());
66    }
67
68    pub fn relation_operation_type(&self, relation_type: RelationType) -> &str {
69        match relation_type {
70            RelationType::Cascade => {"cascade"}
71            RelationType::Enforce => {"no action"}
72            RelationType::SetNull => {"set null"}
73            RelationType::DoNothing => {"no action"}
74        }
75    }
76
77}
78
79impl RelationGenerator for DefaultRelationGenerator {
80    fn output_relations(&self) {
81        let database_model = self.context.settings().database_model();
82        let has_relations = database_model.all_tables().iter().any(|table| {!table.relations().is_empty()});
83
84        if has_relations {
85            self.context.with_writer(|writer| {
86                writer.println("/* relations */");
87
88                database_model.all_tables().iter().filter(|table| {
89                    !table.relations().is_empty()
90                }).for_each(|table| {
91                    self.output_relation_for_table(writer, table);
92                });
93
94                writer.newline();
95            });
96        }
97    }
98}
99
100#[cfg(test)]
101mod tests {
102    use super::*;
103    use crate::common::test_support::make_context;
104    use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
105    use schema_model::model::column_type::ColumnType;
106    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
107
108    #[test]
109    fn output_relations_truncates_generated_constraint_name_for_long_table_names() {
110        // Postgres caps key names at 63 chars; a long table name plus the "fk_" prefix and
111        // trailing index would overflow that, so the generator must truncate the table name
112        // portion rather than emit an invalid identifier.
113        let long_table_name = "a".repeat(70);
114        let parent = TableBuilder::new(None::<&str>, "parent")
115            .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
116            .build();
117        let child = TableBuilder::new(None::<&str>, long_table_name.as_str())
118            .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).required(true).build())
119            .add_relation(Relation::new("parent", "id", long_table_name.as_str(), "parent_id", RelationType::Cascade, false))
120            .build();
121        let schema = SchemaBuilder::new(None::<&str>)
122            .add_table(parent)
123            .add_table(child)
124            .build();
125        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
126        let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
127
128        let generator = DefaultRelationGenerator::new(ctx);
129        generator.output_relations();
130
131        let output = buffer.contents();
132        assert!(output.contains("add constraint "));
133        let constraint_start = output.find("add constraint ").unwrap() + "add constraint ".len();
134        let constraint_name = &output[constraint_start..].split_whitespace().next().unwrap();
135        assert!(constraint_name.len() <= 63, "constraint name '{}' exceeds postgres's 63 char limit", constraint_name);
136    }
137
138    #[test]
139    fn relation_constraint_name_truncates_multi_byte_table_name_without_panicking() {
140        // Regression test: byte-index slicing panics ("not a char boundary") on
141        // multi-byte UTF-8 once truncation kicks in; truncating by char must not.
142        let long_table_name = "语".repeat(70);
143        let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
144        let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
145        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
146        let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
147
148        let generator = DefaultRelationGenerator::new(ctx);
149        let name = generator.relation_constraint_name(&table, 0);
150        assert!(name.starts_with("fk_"));
151        // max_key_name_length is a character budget (SQL Server identifiers are
152        // nvarchar), not a byte budget, so compare char count, not `str::len()` (bytes)
153        // - which would always be inflated for multi-byte UTF-8 like "语".
154        assert!(name.chars().count() <= 32);
155    }
156
157    #[test]
158    fn relation_constraint_name_stays_within_limit_for_double_digit_relation_index() {
159        // Regression test: reserving only 1 char for the suffix (instead of measuring
160        // its actual length) produced a 33-char identifier here, one over SQL Server's
161        // 32-char limit, once the relation index reaches double digits.
162        let long_table_name = "a".repeat(40);
163        let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
164        let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
165        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
166        let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
167
168        let generator = DefaultRelationGenerator::new(ctx);
169        // relation_index 9 -> suffix "10" (double digit)
170        let name = generator.relation_constraint_name(&table, 9);
171        assert!(name.ends_with("10"));
172        assert!(name.len() <= 32, "constraint name '{}' exceeds SQL Server's 32 char limit", name);
173    }
174}