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_type = self.context.settings().database_type();
31        let database_model = self.context.settings().database_model();
32        let max_key_name_length = database_type.max_key_name_length();
33        let table_name = table.name();
34        let relations = table.relations();
35
36        for (relation_index, relation) in relations.iter().enumerate() {
37            let mut relation_name = format!("{}{}{}", FK_PREFIX, table_name, relation_index + 1);
38
39            if relation_name.len() > max_key_name_length {
40                let truncated_table_name_len = max_key_name_length - FK_PREFIX.len() - 1; // leave space for the index
41                let truncated_table_name = &table_name[..truncated_table_name_len.min(table_name.len())];
42                relation_name = format!("{}{}{}", FK_PREFIX, truncated_table_name, relation_index + 1);
43            }
44
45            self.output_relation(writer, &relation_name.to_lowercase(), database_model, table, relation);
46        }
47    }
48
49    fn output_relation(&self,
50                       writer: &mut SqlWriter,
51                       relation_name: &str,
52                       database_model: &DatabaseModel,
53                       table: &Table,
54                       relation: &Relation) {
55        let operation = self.relation_operation_type(relation.relation_type());
56        let database_type = self.context.settings().database_type();
57        let to_table = database_model.find_table_by_qualified_name(relation.to_table_name());
58
59        writer.print(format!("alter table {}", table.fully_qualified_table_name(database_type)).as_str());
60        writer.print(" add constraint ");
61        writer.print(relation_name);
62        writer.print(" foreign key (");
63        writer.print(relation.from_column_name());
64        writer.print(") references ");
65        writer.print(to_table.fully_qualified_table_name(database_type).as_str());
66        writer.print("(");
67        writer.print(relation.to_column_name());
68        writer.print(") on delete ");
69        writer.print(operation);
70        writer.println(self.context().settings().statement_separator());
71    }
72
73    fn relation_operation_type(&self, relation_type: RelationType) -> &str {
74        match relation_type {
75            RelationType::Cascade => {"cascade"}
76            RelationType::Enforce => {"no action"}
77            RelationType::SetNull => {"set null"}
78            RelationType::DoNothing => {"no action"}
79        }
80    }
81
82}
83
84impl RelationGenerator for DefaultRelationGenerator {
85    fn output_relations(&self) {
86        let database_model = self.context.settings().database_model();
87        let has_relations = database_model.all_tables().iter().any(|table| {!table.relations().is_empty()});
88
89        if has_relations {
90            self.context.with_writer(|writer| {
91                writer.println("/* relations */");
92
93                database_model.all_tables().iter().filter(|table| {
94                    !table.relations().is_empty()
95                }).for_each(|table| {
96                    self.output_relation_for_table(writer, table);
97                });
98
99                writer.newline();
100            });
101        }
102    }
103}
104
105#[cfg(test)]
106mod tests {
107    use super::*;
108    use crate::common::test_support::make_context;
109    use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
110    use schema_model::model::column_type::ColumnType;
111    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
112
113    #[test]
114    fn output_relations_truncates_generated_constraint_name_for_long_table_names() {
115        // Postgres caps key names at 63 chars; a long table name plus the "fk_" prefix and
116        // trailing index would overflow that, so the generator must truncate the table name
117        // portion rather than emit an invalid identifier.
118        let long_table_name = "a".repeat(70);
119        let parent = TableBuilder::new(None::<&str>, "parent")
120            .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
121            .build();
122        let child = TableBuilder::new(None::<&str>, long_table_name.as_str())
123            .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).required(true).build())
124            .add_relation(Relation::new("parent", "id", long_table_name.as_str(), "parent_id", RelationType::Cascade, false))
125            .build();
126        let schema = SchemaBuilder::new(None::<&str>)
127            .add_table(parent)
128            .add_table(child)
129            .build();
130        let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
131        let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
132
133        let generator = DefaultRelationGenerator::new(ctx);
134        generator.output_relations();
135
136        let output = buffer.contents();
137        assert!(output.contains("add constraint "));
138        let constraint_start = output.find("add constraint ").unwrap() + "add constraint ".len();
139        let constraint_name = &output[constraint_start..].split_whitespace().next().unwrap();
140        assert!(constraint_name.len() <= 63, "constraint name '{}' exceeds postgres's 63 char limit", constraint_name);
141    }
142}