schema_sql_generator/common/
key_generator.rs1use crate::common::generator_context::GeneratorContext;
2use schema_model::model::table::Table;
3
4const PK_PREFIX: &str = "pk_";
5const AK_PREFIX: &str = "ak_";
6
7pub trait KeyGenerator {
8 fn key_constraints(&self, table: &Table) -> Vec<String>;
9}
10
11pub struct DefaultKeyGenerator {
12 context: GeneratorContext,
13 nonclustered_primary_key: bool,
14}
15
16impl DefaultKeyGenerator {
17 pub fn new(context: GeneratorContext) -> Self {
18 Self {
19 context,
20 nonclustered_primary_key: false,
21 }
22 }
23
24 pub fn with_nonclustered_primary_key(mut self, value: bool) -> Self {
27 self.nonclustered_primary_key = value;
28 self
29 }
30
31 pub fn context(&self) -> &GeneratorContext {
32 &self.context
33 }
34
35 fn constraint_name(&self, prefix: &str, table_name: &str, suffix: Option<usize>) -> String {
36 let database_type = self.context.settings().database_type();
37 let max_key_name_length = database_type.max_key_name_length();
38
39 let suffix_str = suffix.map(|n| n.to_string()).unwrap_or_default();
40 let full_name = if suffix.is_some() {
41 format!("{}{}{}", prefix, table_name, suffix_str)
42 } else {
43 format!("{}{}", prefix, table_name)
44 };
45
46 if full_name.len() <= max_key_name_length {
47 return full_name.to_lowercase();
48 }
49
50 let suffix_len = suffix_str.len();
52 let prefix_len = prefix.len();
53 let available = max_key_name_length.saturating_sub(prefix_len + suffix_len);
54 let truncated_table_name = &table_name[..available.min(table_name.len())];
55
56 format!("{}{}{}", prefix, truncated_table_name, suffix_str).to_lowercase()
57 }
58}
59
60impl KeyGenerator for DefaultKeyGenerator {
61 fn key_constraints(&self, table: &Table) -> Vec<String> {
62 let mut constraints = Vec::new();
63 let mut unique_key_counter = 0;
64
65 for key in table.keys() {
66 if key.is_index() {
67 continue;
68 }
69
70 match key.key_type() {
71 schema_model::model::types::KeyType::Primary => {
72 let constraint_name = self.constraint_name(PK_PREFIX, table.name(), None);
73 let primary_key_clause = if self.nonclustered_primary_key {
74 "primary key nonclustered"
75 } else {
76 "primary key"
77 };
78 constraints.push(format!(
79 " constraint {} {} ({})",
80 constraint_name,
81 primary_key_clause,
82 key.columns_as_string()
83 ));
84 }
85 schema_model::model::types::KeyType::Unique => {
86 unique_key_counter += 1;
87 let constraint_name = self.constraint_name(AK_PREFIX, table.name(), Some(unique_key_counter));
88 constraints.push(format!(
89 " constraint {} unique ({})",
90 constraint_name,
91 key.columns_as_string()
92 ));
93 }
94 schema_model::model::types::KeyType::Index => unreachable!(),
95 }
96 }
97
98 constraints
99 }
100}
101
102#[cfg(test)]
103mod tests {
104 use super::*;
105 use crate::common::test_support::make_context;
106 use schema_model::builder::TableBuilder;
107 use schema_model::model::database_model::DatabaseModel;
108 use schema_model::model::key::Key;
109 use schema_model::model::key::KeyColumn;
110 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode, KeyType};
111
112 #[test]
113 fn empty_keys_returns_empty_vec() {
114 let table = TableBuilder::new(None::<&str>, "users").build();
115 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
116 .add_table(table.clone())
117 .build();
118 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
119 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
120
121 let generator = DefaultKeyGenerator::new(ctx);
122 assert_eq!(generator.key_constraints(&table), vec![] as Vec<String>);
123 }
124
125 #[test]
126 fn primary_key_single_column() {
127 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
128 let table = TableBuilder::new(None::<&str>, "users")
129 .add_key(pk)
130 .build();
131 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
132 .add_table(table.clone())
133 .build();
134 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
135 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
136
137 let generator = DefaultKeyGenerator::new(ctx);
138 let constraints = generator.key_constraints(&table);
139 assert_eq!(constraints.len(), 1);
140 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
141 }
142
143 #[test]
144 fn primary_key_multiple_columns() {
145 let pk = Key::new(KeyType::Primary, vec![
146 KeyColumn::new("org_id"),
147 KeyColumn::new("user_id"),
148 ]);
149 let table = TableBuilder::new(None::<&str>, "users")
150 .add_key(pk)
151 .build();
152 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
153 .add_table(table.clone())
154 .build();
155 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
156 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
157
158 let generator = DefaultKeyGenerator::new(ctx);
159 let constraints = generator.key_constraints(&table);
160 assert_eq!(constraints.len(), 1);
161 assert_eq!(constraints[0], " constraint pk_users primary key (org_id,user_id)");
162 }
163
164 #[test]
165 fn unique_key_single_column() {
166 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
167 let table = TableBuilder::new(None::<&str>, "users")
168 .add_key(uq)
169 .build();
170 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
171 .add_table(table.clone())
172 .build();
173 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
174 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
175
176 let generator = DefaultKeyGenerator::new(ctx);
177 let constraints = generator.key_constraints(&table);
178 assert_eq!(constraints.len(), 1);
179 assert_eq!(constraints[0], " constraint ak_users1 unique (email)");
180 }
181
182 #[test]
183 fn unique_key_multiple_columns() {
184 let uq = Key::new(KeyType::Unique, vec![
185 KeyColumn::new("tenant_id"),
186 KeyColumn::new("code"),
187 ]);
188 let table = TableBuilder::new(None::<&str>, "products")
189 .add_key(uq)
190 .build();
191 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
192 .add_table(table.clone())
193 .build();
194 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
195 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
196
197 let generator = DefaultKeyGenerator::new(ctx);
198 let constraints = generator.key_constraints(&table);
199 assert_eq!(constraints.len(), 1);
200 assert_eq!(constraints[0], " constraint ak_products1 unique (tenant_id,code)");
201 }
202
203 #[test]
204 fn multiple_keys_primary_and_unique() {
205 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
206 let uq1 = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
207 let uq2 = Key::new(KeyType::Unique, vec![KeyColumn::new("username")]);
208 let table = TableBuilder::new(None::<&str>, "users")
209 .add_key(pk)
210 .add_key(uq1)
211 .add_key(uq2)
212 .build();
213 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
214 .add_table(table.clone())
215 .build();
216 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
217 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
218
219 let generator = DefaultKeyGenerator::new(ctx);
220 let constraints = generator.key_constraints(&table);
221 assert_eq!(constraints.len(), 3);
222 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
223 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
224 assert_eq!(constraints[2], " constraint ak_users2 unique (username)");
225 }
226
227 #[test]
228 fn filters_out_index_keys() {
229 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
230 let idx = Key::new(KeyType::Index, vec![KeyColumn::new("name")]);
231 let table = TableBuilder::new(None::<&str>, "users")
232 .add_key(pk)
233 .add_index(idx)
234 .build();
235 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
236 .add_table(table.clone())
237 .build();
238 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
239 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
240
241 let generator = DefaultKeyGenerator::new(ctx);
242 let constraints = generator.key_constraints(&table);
243 assert_eq!(constraints.len(), 1);
245 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
246 }
247
248 #[test]
249 fn unique_key_numbering_independent_of_primary_key() {
250 let uq1 = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
251 let uq2 = Key::new(KeyType::Unique, vec![KeyColumn::new("username")]);
252 let table = TableBuilder::new(None::<&str>, "products")
253 .add_key(uq1)
254 .add_key(uq2)
255 .build();
256 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
257 .add_table(table.clone())
258 .build();
259 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
260 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
261
262 let generator = DefaultKeyGenerator::new(ctx);
263 let constraints = generator.key_constraints(&table);
264 assert_eq!(constraints.len(), 2);
265 assert_eq!(constraints[0], " constraint ak_products1 unique (email)");
266 assert_eq!(constraints[1], " constraint ak_products2 unique (username)");
267 }
268
269 #[test]
270 fn constraint_name_truncates_for_long_table_names() {
271 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
272 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("code")]);
273 let long_table_name = "a".repeat(70); let table = TableBuilder::new(None::<&str>, &long_table_name)
275 .add_key(pk)
276 .add_key(uq)
277 .build();
278 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
279 .add_table(table.clone())
280 .build();
281 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
282 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
283
284 let generator = DefaultKeyGenerator::new(ctx);
285 let constraints = generator.key_constraints(&table);
286 assert_eq!(constraints.len(), 2);
287
288 let pk_constraint = &constraints[0];
290 assert!(pk_constraint.contains("constraint pk_"));
291 assert!(pk_constraint.contains("primary key (id)"));
292 if let Some(start) = pk_constraint.find("constraint ")
294 && let Some(end) = pk_constraint.find(" primary") {
295 let constraint_name = &pk_constraint[start + 11..end];
296 assert!(constraint_name.len() <= 63, "Constraint name {} exceeds 63 chars", constraint_name);
297 }
298
299 let ak_constraint = &constraints[1];
301 assert!(ak_constraint.contains("constraint ak_"));
302 assert!(ak_constraint.contains("unique (code)"));
303 if let Some(start) = ak_constraint.find("constraint ")
305 && let Some(end) = ak_constraint.find(" unique") {
306 let constraint_name = &ak_constraint[start + 11..end];
307 assert!(constraint_name.len() <= 63, "Constraint name {} exceeds 63 chars", constraint_name);
308 }
309 }
310
311 #[test]
312 fn with_nonclustered_primary_key_adds_nonclustered_keyword() {
313 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
314 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
315 let table = TableBuilder::new(None::<&str>, "users")
316 .add_key(pk)
317 .add_key(uq)
318 .build();
319 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
320 .add_table(table.clone())
321 .build();
322 let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
323 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
324
325 let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
326 let constraints = generator.key_constraints(&table);
327 assert_eq!(constraints.len(), 2);
328 assert_eq!(constraints[0], " constraint pk_users primary key nonclustered (id)");
329 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
331 }
332}