schema_sql_generator/common/
relation_generator.rs1use 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 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 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 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 assert!(name.chars().count() <= 32);
155 }
156
157 #[test]
158 fn relation_constraint_name_stays_within_limit_for_double_digit_relation_index() {
159 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 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}