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 {
27 self.nonclustered_primary_key = value;
28 self
29 }
30
31 pub fn context(&self) -> &GeneratorContext {
32 &self.context
33 }
34
35 fn effective_cluster(&self, table_name: &str, key_kind: &str, key: &Key) -> bool {
41 if !key.is_cluster() {
42 return false;
43 }
44
45 let database_type = self.context.settings().database_type();
46 if database_type == DatabaseType::SqlServer {
47 true
48 } else {
49 eprintln!(
50 "warning: table '{}' has a clustered {} constraint, but {:?} does not support clustered/nonclustered constraints -- ignoring",
51 table_name, key_kind, database_type
52 );
53 false
54 }
55 }
56}
57
58impl DefaultKeyGenerator {
59 pub fn key_constraints_filtered(&self, table: &Table, skip_primary_key: bool) -> Vec<String> {
63 let mut constraints = Vec::new();
64 let mut unique_key_counter = 0;
65
66 for key in table.keys() {
67 if key.is_index() {
68 continue;
69 }
70
71 match key.key_type() {
72 schema_model::model::types::KeyType::Primary => {
73 if skip_primary_key {
74 continue;
75 }
76
77 let database_type = self.context.settings().database_type();
78 let constraint_name = primary_key_name(database_type, table.name());
79 let primary_key_clause = if self.effective_cluster(table.name(), "primary key", key) {
83 "primary key clustered"
84 } else if self.nonclustered_primary_key {
85 "primary key nonclustered"
86 } else {
87 "primary key"
88 };
89 constraints.push(format!(
90 " constraint {} {} ({})",
91 constraint_name,
92 primary_key_clause,
93 key.columns_as_string()
94 ));
95 }
96 schema_model::model::types::KeyType::Unique => {
97 unique_key_counter += 1;
98 let database_type = self.context.settings().database_type();
99 let constraint_name = unique_key_name(database_type, table.name(), unique_key_counter);
100 let unique_clause = if self.effective_cluster(table.name(), "unique", key) {
101 "unique clustered"
102 } else {
103 "unique"
104 };
105 constraints.push(format!(
106 " constraint {} {} ({})",
107 constraint_name,
108 unique_clause,
109 key.columns_as_string()
110 ));
111 }
112 schema_model::model::types::KeyType::Index => unreachable!(),
113 }
114 }
115
116 constraints
117 }
118}
119
120impl KeyGenerator for DefaultKeyGenerator {
121 fn key_constraints(&self, table: &Table) -> Vec<String> {
122 self.key_constraints_filtered(table, false)
123 }
124}
125
126#[cfg(test)]
127mod tests {
128 use super::*;
129 use crate::common::test_support::make_context;
130 use schema_model::builder::TableBuilder;
131 use schema_model::model::database_model::DatabaseModel;
132 use schema_model::model::key::Key;
133 use schema_model::model::key::KeyColumn;
134 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode, KeyType};
135
136 #[test]
137 fn empty_keys_returns_empty_vec() {
138 let table = TableBuilder::new(None::<&str>, "users").build();
139 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
140 .add_table(table.clone())
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 = DefaultKeyGenerator::new(ctx);
146 assert_eq!(generator.key_constraints(&table), vec![] as Vec<String>);
147 }
148
149 #[test]
150 fn primary_key_single_column() {
151 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
152 let table = TableBuilder::new(None::<&str>, "users")
153 .add_key(pk)
154 .build();
155 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
156 .add_table(table.clone())
157 .build();
158 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
159 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
160
161 let generator = DefaultKeyGenerator::new(ctx);
162 let constraints = generator.key_constraints(&table);
163 assert_eq!(constraints.len(), 1);
164 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
165 }
166
167 #[test]
168 fn primary_key_multiple_columns() {
169 let pk = Key::new(KeyType::Primary, vec![
170 KeyColumn::new("org_id"),
171 KeyColumn::new("user_id"),
172 ]);
173 let table = TableBuilder::new(None::<&str>, "users")
174 .add_key(pk)
175 .build();
176 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
177 .add_table(table.clone())
178 .build();
179 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
180 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
181
182 let generator = DefaultKeyGenerator::new(ctx);
183 let constraints = generator.key_constraints(&table);
184 assert_eq!(constraints.len(), 1);
185 assert_eq!(constraints[0], " constraint pk_users primary key (org_id,user_id)");
186 }
187
188 #[test]
189 fn unique_key_single_column() {
190 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
191 let table = TableBuilder::new(None::<&str>, "users")
192 .add_key(uq)
193 .build();
194 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
195 .add_table(table.clone())
196 .build();
197 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
198 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
199
200 let generator = DefaultKeyGenerator::new(ctx);
201 let constraints = generator.key_constraints(&table);
202 assert_eq!(constraints.len(), 1);
203 assert_eq!(constraints[0], " constraint ak_users1 unique (email)");
204 }
205
206 #[test]
207 fn unique_key_multiple_columns() {
208 let uq = Key::new(KeyType::Unique, vec![
209 KeyColumn::new("tenant_id"),
210 KeyColumn::new("code"),
211 ]);
212 let table = TableBuilder::new(None::<&str>, "products")
213 .add_key(uq)
214 .build();
215 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
216 .add_table(table.clone())
217 .build();
218 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
219 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
220
221 let generator = DefaultKeyGenerator::new(ctx);
222 let constraints = generator.key_constraints(&table);
223 assert_eq!(constraints.len(), 1);
224 assert_eq!(constraints[0], " constraint ak_products1 unique (tenant_id,code)");
225 }
226
227 #[test]
228 fn multiple_keys_primary_and_unique() {
229 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
230 let uq1 = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
231 let uq2 = Key::new(KeyType::Unique, vec![KeyColumn::new("username")]);
232 let table = TableBuilder::new(None::<&str>, "users")
233 .add_key(pk)
234 .add_key(uq1)
235 .add_key(uq2)
236 .build();
237 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
238 .add_table(table.clone())
239 .build();
240 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
241 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
242
243 let generator = DefaultKeyGenerator::new(ctx);
244 let constraints = generator.key_constraints(&table);
245 assert_eq!(constraints.len(), 3);
246 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
247 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
248 assert_eq!(constraints[2], " constraint ak_users2 unique (username)");
249 }
250
251 #[test]
252 fn filters_out_index_keys() {
253 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
254 let idx = Key::new(KeyType::Index, vec![KeyColumn::new("name")]);
255 let table = TableBuilder::new(None::<&str>, "users")
256 .add_key(pk)
257 .add_index(idx)
258 .build();
259 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
260 .add_table(table.clone())
261 .build();
262 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
263 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
264
265 let generator = DefaultKeyGenerator::new(ctx);
266 let constraints = generator.key_constraints(&table);
267 assert_eq!(constraints.len(), 1);
269 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
270 }
271
272 #[test]
273 fn unique_key_numbering_independent_of_primary_key() {
274 let uq1 = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
275 let uq2 = Key::new(KeyType::Unique, vec![KeyColumn::new("username")]);
276 let table = TableBuilder::new(None::<&str>, "products")
277 .add_key(uq1)
278 .add_key(uq2)
279 .build();
280 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
281 .add_table(table.clone())
282 .build();
283 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
284 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
285
286 let generator = DefaultKeyGenerator::new(ctx);
287 let constraints = generator.key_constraints(&table);
288 assert_eq!(constraints.len(), 2);
289 assert_eq!(constraints[0], " constraint ak_products1 unique (email)");
290 assert_eq!(constraints[1], " constraint ak_products2 unique (username)");
291 }
292
293 #[test]
294 fn constraint_name_truncates_for_long_table_names() {
295 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
296 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("code")]);
297 let long_table_name = "a".repeat(70); let table = TableBuilder::new(None::<&str>, &long_table_name)
299 .add_key(pk)
300 .add_key(uq)
301 .build();
302 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
303 .add_table(table.clone())
304 .build();
305 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
306 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
307
308 let generator = DefaultKeyGenerator::new(ctx);
309 let constraints = generator.key_constraints(&table);
310 assert_eq!(constraints.len(), 2);
311
312 let pk_constraint = &constraints[0];
314 assert!(pk_constraint.contains("constraint pk_"));
315 assert!(pk_constraint.contains("primary key (id)"));
316 if let Some(start) = pk_constraint.find("constraint ")
318 && let Some(end) = pk_constraint.find(" primary") {
319 let constraint_name = &pk_constraint[start + 11..end];
320 assert!(constraint_name.len() <= 63, "Constraint name {} exceeds 63 chars", constraint_name);
321 }
322
323 let ak_constraint = &constraints[1];
325 assert!(ak_constraint.contains("constraint ak_"));
326 assert!(ak_constraint.contains("unique (code)"));
327 if let Some(start) = ak_constraint.find("constraint ")
329 && let Some(end) = ak_constraint.find(" unique") {
330 let constraint_name = &ak_constraint[start + 11..end];
331 assert!(constraint_name.len() <= 63, "Constraint name {} exceeds 63 chars", constraint_name);
332 }
333 }
334
335 #[test]
336 fn constraint_name_truncates_multi_byte_table_name_without_panicking() {
337 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
340 let long_table_name = "语".repeat(70);
341 let table = TableBuilder::new(None::<&str>, &long_table_name)
342 .add_key(pk)
343 .build();
344 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
345 .add_table(table.clone())
346 .build();
347 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
348 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
349
350 let generator = DefaultKeyGenerator::new(ctx);
351 let constraints = generator.key_constraints(&table);
352 assert_eq!(constraints.len(), 1);
353 assert!(constraints[0].contains("constraint pk_"));
354 }
355
356 #[test]
357 fn with_nonclustered_primary_key_adds_nonclustered_keyword() {
358 let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
359 let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
360 let table = TableBuilder::new(None::<&str>, "users")
361 .add_key(pk)
362 .add_key(uq)
363 .build();
364 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
365 .add_table(table.clone())
366 .build();
367 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
368 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
369
370 let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
371 let constraints = generator.key_constraints(&table);
372 assert_eq!(constraints.len(), 2);
373 assert_eq!(constraints[0], " constraint pk_users primary key nonclustered (id)");
374 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
376 }
377
378 #[test]
379 fn cluster_true_on_sql_server_overrides_nonclustered_primary_key_default() {
380 let pk = Key::new_full(KeyType::Primary, vec![KeyColumn::new("id")], true, false, false, None::<String>);
384 let table = TableBuilder::new(None::<&str>, "users").add_key(pk).build();
385 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
386 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
387 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
388
389 let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
390 let constraints = generator.key_constraints(&table);
391 assert_eq!(constraints, vec![" constraint pk_users primary key clustered (id)"]);
392 }
393
394 #[test]
395 fn cluster_true_on_sql_server_unique_key_adds_clustered_keyword() {
396 let uq = Key::new_full(KeyType::Unique, vec![KeyColumn::new("email")], true, false, false, None::<String>);
397 let table = TableBuilder::new(None::<&str>, "users").add_key(uq).build();
398 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
399 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
400 let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
401
402 let generator = DefaultKeyGenerator::new(ctx);
403 let constraints = generator.key_constraints(&table);
404 assert_eq!(constraints, vec![" constraint ak_users1 unique clustered (email)"]);
405 }
406
407 #[test]
408 fn cluster_true_is_ignored_on_dialects_without_clustered_constraints() {
409 let pk = Key::new_full(KeyType::Primary, vec![KeyColumn::new("id")], true, false, false, None::<String>);
412 let uq = Key::new_full(KeyType::Unique, vec![KeyColumn::new("email")], true, false, false, None::<String>);
413 let table = TableBuilder::new(None::<&str>, "users").add_key(pk).add_key(uq).build();
414 let schema = schema_model::builder::SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
415 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
416 let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
417
418 let generator = DefaultKeyGenerator::new(ctx);
419 let constraints = generator.key_constraints(&table);
420 assert_eq!(constraints[0], " constraint pk_users primary key (id)");
421 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
422 }
423}