1use crate::common::generator_context::GeneratorContext;
2use schema_model::model::key::Key;
3use schema_model::model::table::Table;
4use schema_model::model::types::DatabaseType;
5use schema_model::naming::{primary_key_name, unique_key_name};
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 {
30 self.nonclustered_primary_key = value;
31 self
32 }
33
34 pub fn context(&self) -> &GeneratorContext {
35 &self.context
36 }
37
38 fn effective_cluster(&self, table_name: &str, key_kind: &str, key: &Key) -> bool {
44 if !key.is_cluster() {
45 return false;
46 }
47
48 let database_type = self.context.settings().database_type();
49 if database_type == DatabaseType::SqlServer {
50 true
51 } else {
52 eprintln!(
53 "warning: table '{}' has a clustered {} constraint, but {:?} does not support clustered/nonclustered constraints -- ignoring",
54 table_name, key_kind, database_type
55 );
56 false
57 }
58 }
59
60 fn effective_compress(&self, table_name: &str, key_kind: &str, key: &Key) -> bool {
65 if !key.is_compress() {
66 return false;
67 }
68
69 let database_type = self.context.settings().database_type();
70 if database_type == DatabaseType::SqlServer {
71 true
72 } else {
73 eprintln!(
74 "warning: table '{}' has a compressed {} constraint, but {:?} does not support key compression -- ignoring",
75 table_name, key_kind, database_type
76 );
77 false
78 }
79 }
80}
81
82impl DefaultKeyGenerator {
83 pub fn key_constraints_filtered(&self, table: &Table, skip_primary_key: bool) -> Vec<String> {
87 let mut constraints = Vec::new();
88 let mut unique_key_counter = 0;
89
90 for key in table.keys() {
91 if key.is_index() {
92 continue;
93 }
94
95 match key.key_type() {
96 schema_model::model::types::KeyType::Primary => {
97 if skip_primary_key {
98 continue;
99 }
100
101 let database_type = self.context.settings().database_type();
102 let constraint_name = primary_key_name(database_type, table.name());
103 let other_key_is_clustered = self.nonclustered_primary_key
116 && table
117 .keys()
118 .iter()
119 .any(|k| !k.is_index() && k.key_type() != schema_model::model::types::KeyType::Primary && k.is_cluster());
120 let primary_key_clause = if self.effective_cluster(table.name(), "primary key", key) {
121 "primary key clustered"
122 } else if other_key_is_clustered {
123 "primary key nonclustered"
124 } else {
125 "primary key"
126 };
127 let compress_clause = if self.effective_compress(table.name(), "primary key", key) {
128 " with (data_compression = page)"
129 } else {
130 ""
131 };
132 constraints.push(format!(
133 " constraint {} {} ({}){}",
134 constraint_name,
135 primary_key_clause,
136 key.columns_as_string(),
137 compress_clause
138 ));
139 }
140 schema_model::model::types::KeyType::Unique => {
141 unique_key_counter += 1;
142 let database_type = self.context.settings().database_type();
143 let constraint_name = unique_key_name(database_type, table.name(), unique_key_counter);
144 let unique_clause = if self.effective_cluster(table.name(), "unique", key) {
145 "unique clustered"
146 } else {
147 "unique"
148 };
149 let compress_clause = if self.effective_compress(table.name(), "unique", key) {
150 " with (data_compression = page)"
151 } else {
152 ""
153 };
154 constraints.push(format!(
155 " constraint {} {} ({}){}",
156 constraint_name,
157 unique_clause,
158 key.columns_as_string(),
159 compress_clause
160 ));
161 }
162 schema_model::model::types::KeyType::Index => unreachable!(),
163 }
164 }
165
166 constraints
167 }
168}
169
170impl KeyGenerator for DefaultKeyGenerator {
171 fn key_constraints(&self, table: &Table) -> Vec<String> {
172 self.key_constraints_filtered(table, false)
173 }
174}
175
176#[cfg(test)]
177mod tests {
178 use super::*;
179 use crate::common::test_support::make_context;
180 use schema_model::builder::TableBuilder;
181 use schema_model::model::database_model::DatabaseModel;
182 use schema_model::model::key::Key;
183 use schema_model::model::key::KeyColumn;
184 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode, KeyType};
185
186 #[test]
187 fn empty_keys_returns_empty_vec() {
188 let table = TableBuilder::new(None::<&str>, "users").build();
189 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
190 .add_table(table.clone())
191 .build();
192 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
193 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
194
195 let generator = DefaultKeyGenerator::new(ctx);
196 assert_eq!(generator.key_constraints(&table), vec![] as Vec<String>);
197 }
198
199 #[test]
200 fn primary_key_single_column() {
201 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
202 let table = TableBuilder::new(None::<&str>, "users")
203 .add_key(pk)
204 .build();
205 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
206 .add_table(table.clone())
207 .build();
208 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
209 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
210
211 let generator = DefaultKeyGenerator::new(ctx);
212 let constraints = generator.key_constraints(&table);
213 assert_eq!(constraints.len(), 1);
214 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
215 }
216
217 #[test]
218 fn primary_key_multiple_columns() {
219 let pk = Key::new(KeyType::Primary, vec![
220 KeyColumn::new("org_id"),
221 KeyColumn::new("user_id"),
222 ]);
223 let table = TableBuilder::new(None::<&str>, "users")
224 .add_key(pk)
225 .build();
226 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
227 .add_table(table.clone())
228 .build();
229 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
230 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
231
232 let generator = DefaultKeyGenerator::new(ctx);
233 let constraints = generator.key_constraints(&table);
234 assert_eq!(constraints.len(), 1);
235 assert_eq!(constraints[0], " constraint pk_users primary key (org_id,user_id)");
236 }
237
238 #[test]
239 fn unique_key_single_column() {
240 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
241 let table = TableBuilder::new(None::<&str>, "users")
242 .add_key(uq)
243 .build();
244 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
245 .add_table(table.clone())
246 .build();
247 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
248 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
249
250 let generator = DefaultKeyGenerator::new(ctx);
251 let constraints = generator.key_constraints(&table);
252 assert_eq!(constraints.len(), 1);
253 assert_eq!(constraints[0], " constraint ak_users1 unique (email)");
254 }
255
256 #[test]
257 fn unique_key_multiple_columns() {
258 let uq = Key::new(KeyType::Unique, vec![
259 KeyColumn::new("tenant_id"),
260 KeyColumn::new("code"),
261 ]);
262 let table = TableBuilder::new(None::<&str>, "products")
263 .add_key(uq)
264 .build();
265 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
266 .add_table(table.clone())
267 .build();
268 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
269 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
270
271 let generator = DefaultKeyGenerator::new(ctx);
272 let constraints = generator.key_constraints(&table);
273 assert_eq!(constraints.len(), 1);
274 assert_eq!(constraints[0], " constraint ak_products1 unique (tenant_id,code)");
275 }
276
277 #[test]
278 fn multiple_keys_primary_and_unique() {
279 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
280 let uq1 = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
281 let uq2 = Key::new(KeyType::Unique, vec![KeyColumn::new("username")]);
282 let table = TableBuilder::new(None::<&str>, "users")
283 .add_key(pk)
284 .add_key(uq1)
285 .add_key(uq2)
286 .build();
287 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
288 .add_table(table.clone())
289 .build();
290 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
291 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
292
293 let generator = DefaultKeyGenerator::new(ctx);
294 let constraints = generator.key_constraints(&table);
295 assert_eq!(constraints.len(), 3);
296 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
297 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
298 assert_eq!(constraints[2], " constraint ak_users2 unique (username)");
299 }
300
301 #[test]
302 fn filters_out_index_keys() {
303 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
304 let idx = Key::new(KeyType::Index, vec![KeyColumn::new("name")]);
305 let table = TableBuilder::new(None::<&str>, "users")
306 .add_key(pk)
307 .add_index(idx)
308 .build();
309 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
310 .add_table(table.clone())
311 .build();
312 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
313 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
314
315 let generator = DefaultKeyGenerator::new(ctx);
316 let constraints = generator.key_constraints(&table);
317 assert_eq!(constraints.len(), 1);
319 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
320 }
321
322 #[test]
323 fn unique_key_numbering_independent_of_primary_key() {
324 let uq1 = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
325 let uq2 = Key::new(KeyType::Unique, vec![KeyColumn::new("username")]);
326 let table = TableBuilder::new(None::<&str>, "products")
327 .add_key(uq1)
328 .add_key(uq2)
329 .build();
330 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
331 .add_table(table.clone())
332 .build();
333 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
334 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
335
336 let generator = DefaultKeyGenerator::new(ctx);
337 let constraints = generator.key_constraints(&table);
338 assert_eq!(constraints.len(), 2);
339 assert_eq!(constraints[0], " constraint ak_products1 unique (email)");
340 assert_eq!(constraints[1], " constraint ak_products2 unique (username)");
341 }
342
343 #[test]
344 fn constraint_name_truncates_for_long_table_names() {
345 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
346 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("code")]);
347 let long_table_name = "a".repeat(70); let table = TableBuilder::new(None::<&str>, &long_table_name)
349 .add_key(pk)
350 .add_key(uq)
351 .build();
352 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
353 .add_table(table.clone())
354 .build();
355 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
356 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
357
358 let generator = DefaultKeyGenerator::new(ctx);
359 let constraints = generator.key_constraints(&table);
360 assert_eq!(constraints.len(), 2);
361
362 let pk_constraint = &constraints[0];
364 assert!(pk_constraint.contains("constraint pk_"));
365 assert!(pk_constraint.contains("primary key (id)"));
366 if let Some(start) = pk_constraint.find("constraint ")
368 && let Some(end) = pk_constraint.find(" primary") {
369 let constraint_name = &pk_constraint[start + 11..end];
370 assert!(constraint_name.len() <= 63, "Constraint name {} exceeds 63 chars", constraint_name);
371 }
372
373 let ak_constraint = &constraints[1];
375 assert!(ak_constraint.contains("constraint ak_"));
376 assert!(ak_constraint.contains("unique (code)"));
377 if let Some(start) = ak_constraint.find("constraint ")
379 && let Some(end) = ak_constraint.find(" unique") {
380 let constraint_name = &ak_constraint[start + 11..end];
381 assert!(constraint_name.len() <= 63, "Constraint name {} exceeds 63 chars", constraint_name);
382 }
383 }
384
385 #[test]
386 fn constraint_name_truncates_multi_byte_table_name_without_panicking() {
387 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
390 let long_table_name = "语".repeat(70);
391 let table = TableBuilder::new(None::<&str>, &long_table_name)
392 .add_key(pk)
393 .build();
394 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
395 .add_table(table.clone())
396 .build();
397 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
398 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
399
400 let generator = DefaultKeyGenerator::new(ctx);
401 let constraints = generator.key_constraints(&table);
402 assert_eq!(constraints.len(), 1);
403 assert!(constraints[0].contains("constraint pk_"));
404 }
405
406 #[test]
407 fn with_nonclustered_primary_key_leaves_pk_bare_when_nothing_else_is_clustered() {
408 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
414 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
415 let table = TableBuilder::new(None::<&str>, "users")
416 .add_key(pk)
417 .add_key(uq)
418 .build();
419 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
420 .add_table(table.clone())
421 .build();
422 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
423 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
424
425 let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
426 let constraints = generator.key_constraints(&table);
427 assert_eq!(constraints.len(), 2);
428 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
429 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
430 }
431
432 #[test]
433 fn with_nonclustered_primary_key_adds_nonclustered_keyword_when_another_key_is_clustered() {
434 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
437 let uq = Key::new_full(KeyType::Unique, vec![KeyColumn::new("location_id")], true, false, false, None::<String>);
438 let table = TableBuilder::new(None::<&str>, "users")
439 .add_key(pk)
440 .add_key(uq)
441 .build();
442 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
443 .add_table(table.clone())
444 .build();
445 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
446 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
447
448 let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
449 let constraints = generator.key_constraints(&table);
450 assert_eq!(constraints.len(), 2);
451 assert_eq!(constraints[0], " constraint pk_users primary key nonclustered (id)");
452 assert_eq!(constraints[1], " constraint ak_users1 unique clustered (location_id)");
453 }
454
455 #[test]
456 fn cluster_true_on_sql_server_overrides_nonclustered_primary_key_default() {
457 let pk = Key::new_full(KeyType::Primary, vec![KeyColumn::new("id")], true, false, false, None::<String>);
461 let table = TableBuilder::new(None::<&str>, "users").add_key(pk).build();
462 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
463 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
464 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
465
466 let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
467 let constraints = generator.key_constraints(&table);
468 assert_eq!(constraints, vec![" constraint pk_users primary key clustered (id)"]);
469 }
470
471 #[test]
472 fn cluster_true_on_sql_server_unique_key_adds_clustered_keyword() {
473 let uq = Key::new_full(KeyType::Unique, vec![KeyColumn::new("email")], true, false, false, None::<String>);
474 let table = TableBuilder::new(None::<&str>, "users").add_key(uq).build();
475 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
476 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
477 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
478
479 let generator = DefaultKeyGenerator::new(ctx);
480 let constraints = generator.key_constraints(&table);
481 assert_eq!(constraints, vec![" constraint ak_users1 unique clustered (email)"]);
482 }
483
484 #[test]
485 fn cluster_true_is_ignored_on_dialects_without_clustered_constraints() {
486 let pk = Key::new_full(KeyType::Primary, vec![KeyColumn::new("id")], true, false, false, None::<String>);
489 let uq = Key::new_full(KeyType::Unique, vec![KeyColumn::new("email")], true, false, false, None::<String>);
490 let table = TableBuilder::new(None::<&str>, "users").add_key(pk).add_key(uq).build();
491 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
492 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
493 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
494
495 let generator = DefaultKeyGenerator::new(ctx);
496 let constraints = generator.key_constraints(&table);
497 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
498 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
499 }
500
501 #[test]
502 fn compress_true_on_sql_server_adds_data_compression_clause() {
503 let pk = Key::new_full(KeyType::Primary, vec![KeyColumn::new("id")], false, true, false, None::<String>);
504 let uq = Key::new_full(KeyType::Unique, vec![KeyColumn::new("email")], false, true, false, None::<String>);
505 let table = TableBuilder::new(None::<&str>, "users").add_key(pk).add_key(uq).build();
506 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
507 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
508 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
509
510 let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
511 let constraints = generator.key_constraints(&table);
512 assert_eq!(
513 constraints[0],
514 " constraint pk_users primary key (id) with (data_compression = page)"
515 );
516 assert_eq!(
517 constraints[1],
518 " constraint ak_users1 unique (email) with (data_compression = page)"
519 );
520 }
521
522 #[test]
523 fn compress_true_combines_with_clustered_keyword() {
524 let pk = Key::new_full(KeyType::Primary, vec![KeyColumn::new("id")], true, true, false, None::<String>);
525 let table = TableBuilder::new(None::<&str>, "users").add_key(pk).build();
526 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
527 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
528 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
529
530 let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
531 let constraints = generator.key_constraints(&table);
532 assert_eq!(
533 constraints,
534 vec![" constraint pk_users primary key clustered (id) with (data_compression = page)"]
535 );
536 }
537
538 #[test]
539 fn compress_true_is_ignored_on_dialects_without_key_compression() {
540 let pk = Key::new_full(KeyType::Primary, vec![KeyColumn::new("id")], false, true, false, None::<String>);
543 let uq = Key::new_full(KeyType::Unique, vec![KeyColumn::new("email")], false, true, false, None::<String>);
544 let table = TableBuilder::new(None::<&str>, "users").add_key(pk).add_key(uq).build();
545 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
546 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
547 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
548
549 let generator = DefaultKeyGenerator::new(ctx);
550 let constraints = generator.key_constraints(&table);
551 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
552 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
553 }
554}