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;
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 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 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 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 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 assert!(name.chars().count() <= 32);
172 }
173
174 #[test]
175 fn relation_constraint_name_stays_within_limit_for_double_digit_relation_index() {
176 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 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}