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;
7
8const FK_PREFIX: &str = "fk_";
9
10pub trait RelationGenerator {
11    fn output_relations(&self);
12}
13
14pub struct DefaultRelationGenerator {
15    context: GeneratorContext,
16}
17
18impl DefaultRelationGenerator {
19    pub fn new(context: GeneratorContext) -> Self {
20        Self {
21            context,
22        }
23    }
24
25    pub fn context(&self) -> &GeneratorContext {
26        &self.context
27    }
28
29    fn output_relation_for_table(&self, writer: &mut SqlWriter, table: &Table) {
30        let database_model = self.context.settings().database_model();
31
32        for (relation_index, relation) in table.relations().iter().enumerate() {
33            let relation_name = self.relation_constraint_name(table, relation_index);
34            self.output_relation(writer, &relation_name, database_model, table, relation);
35        }
36    }
37
38    /// Builds the constraint name for the given relation, truncating the table-name
39    /// portion so the identifier stays within the target database's max key name length.
40    pub fn relation_constraint_name(&self, table: &Table, relation_index: usize) -> String {
41        let database_type = self.context.settings().database_type();
42        let max_key_name_length = database_type.max_key_name_length();
43        let table_name = table.name();
44        let suffix_str = (relation_index + 1).to_string();
45        let mut relation_name = format!("{}{}{}", FK_PREFIX, table_name, suffix_str);
46
47        if relation_name.len() > max_key_name_length {
48            // Reserve space for the *actual* suffix length, not a hard-coded single
49            // digit - a table with >=10 relations needs a 2-digit suffix, and reserving
50            // only 1 char for it would produce an identifier over the length limit.
51            // Truncate by char, not byte index, so multi-byte UTF-8 table names don't
52            // panic ("byte index N is not a char boundary").
53            let available = max_key_name_length.saturating_sub(FK_PREFIX.len() + suffix_str.len());
54            let truncated_table_name: String = table_name.chars().take(available).collect();
55            relation_name = format!("{}{}{}", FK_PREFIX, truncated_table_name, suffix_str);
56        }
57
58        relation_name.to_lowercase()
59    }
60
61    fn output_relation(&self,
62                       writer: &mut SqlWriter,
63                       relation_name: &str,
64                       database_model: &DatabaseModel,
65                       table: &Table,
66                       relation: &Relation) {
67        let operation = self.relation_operation_type(relation.relation_type());
68        let database_type = self.context.settings().database_type();
69        let to_table = database_model.find_table_by_qualified_name(relation.to_table_name());
70
71        writer.print(format!("alter table {}", table.fully_qualified_table_name(database_type)).as_str());
72        writer.print(" add constraint ");
73        writer.print(relation_name);
74        writer.print(" foreign key (");
75        writer.print(relation.from_column_name());
76        writer.print(") references ");
77        writer.print(to_table.fully_qualified_table_name(database_type).as_str());
78        writer.print("(");
79        writer.print(relation.to_column_name());
80        writer.print(") on delete ");
81        writer.print(operation);
82        writer.println(self.context().settings().statement_separator());
83    }
84
85    pub fn relation_operation_type(&self, relation_type: RelationType) -> &str {
86        match relation_type {
87            RelationType::Cascade => {"cascade"}
88            RelationType::Enforce => {"no action"}
89            RelationType::SetNull => {"set null"}
90            RelationType::DoNothing => {"no action"}
91        }
92    }
93
94}
95
96impl RelationGenerator for DefaultRelationGenerator {
97    fn output_relations(&self) {
98        let database_model = self.context.settings().database_model();
99        let has_relations = database_model.all_tables().iter().any(|table| {!table.relations().is_empty()});
100
101        if has_relations {
102            self.context.with_writer(|writer| {
103                writer.println("/* relations */");
104
105                database_model.all_tables().iter().filter(|table| {
106                    !table.relations().is_empty()
107                }).for_each(|table| {
108                    self.output_relation_for_table(writer, table);
109                });
110
111                writer.newline();
112            });
113        }
114    }
115}
116
117#[cfg(test)]
118mod tests {
119    use super::*;
120    use crate::common::test_support::make_context;
121    use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
122    use schema_model::model::column_type::ColumnType;
123    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
124
125    #[test]
126    fn output_relations_truncates_generated_constraint_name_for_long_table_names() {
127        // Postgres caps key names at 63 chars; a long table name plus the "fk_" prefix and
128        // trailing index would overflow that, so the generator must truncate the table name
129        // portion rather than emit an invalid identifier.
130        let long_table_name = "a".repeat(70);
131        let parent = TableBuilder::new(None::<&str>, "parent")
132            .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
133            .build();
134        let child = TableBuilder::new(None::<&str>, long_table_name.as_str())
135            .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).required(true).build())
136            .add_relation(Relation::new("parent", "id", long_table_name.as_str(), "parent_id", RelationType::Cascade, false))
137            .build();
138        let schema = SchemaBuilder::new(None::<&str>)
139            .add_table(parent)
140            .add_table(child)
141            .build();
142        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
143        let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
144
145        let generator = DefaultRelationGenerator::new(ctx);
146        generator.output_relations();
147
148        let output = buffer.contents();
149        assert!(output.contains("add constraint "));
150        let constraint_start = output.find("add constraint ").unwrap() + "add constraint ".len();
151        let constraint_name = &output[constraint_start..].split_whitespace().next().unwrap();
152        assert!(constraint_name.len() <= 63, "constraint name '{}' exceeds postgres's 63 char limit", constraint_name);
153    }
154
155    #[test]
156    fn relation_constraint_name_truncates_multi_byte_table_name_without_panicking() {
157        // Regression test: byte-index slicing panics ("not a char boundary") on
158        // multi-byte UTF-8 once truncation kicks in; truncating by char must not.
159        let long_table_name = "语".repeat(70);
160        let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
161        let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
162        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
163        let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
164
165        let generator = DefaultRelationGenerator::new(ctx);
166        let name = generator.relation_constraint_name(&table, 0);
167        assert!(name.starts_with("fk_"));
168        // max_key_name_length is a character budget (SQL Server identifiers are
169        // nvarchar), not a byte budget, so compare char count, not `str::len()` (bytes)
170        // - which would always be inflated for multi-byte UTF-8 like "语".
171        assert!(name.chars().count() <= 32);
172    }
173
174    #[test]
175    fn relation_constraint_name_stays_within_limit_for_double_digit_relation_index() {
176        // Regression test: reserving only 1 char for the suffix (instead of measuring
177        // its actual length) produced a 33-char identifier here, one over SQL Server's
178        // 32-char limit, once the relation index reaches double digits.
179        let long_table_name = "a".repeat(40);
180        let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
181        let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
182        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
183        let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
184
185        let generator = DefaultRelationGenerator::new(ctx);
186        // relation_index 9 -> suffix "10" (double digit)
187        let name = generator.relation_constraint_name(&table, 9);
188        assert!(name.ends_with("10"));
189        assert!(name.len() <= 32, "constraint name '{}' exceeds SQL Server's 32 char limit", name);
190    }
191}