Skip to main content

schema_sql_generator/common/
key_generator.rs

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    /// When set, primary key constraints render `primary key nonclustered (...)` instead of
25    /// `primary key (...)` - matches SQL Server's legacy codegen convention.
26    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    /// `cluster="true"` only has a rendering on SQL Server (`clustered`/`nonclustered` is a
36    /// SQL Server-only constraint keyword - PostgreSQL and SQLite have nothing equivalent).
37    /// On those dialects the attribute is ignored rather than hard-erroring, since one
38    /// schema.xml is meant to target all three databases and a SQL-Server-only tuning hint
39    /// shouldn't stop the other two from generating (M1).
40    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    /// Same as `key_constraints`, but when `skip_primary_key` is true the primary key
60    /// constraint is left out entirely - for dialects (SQLite) that declare the primary key
61    /// inline on the column instead of as a separate table constraint.
62    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                    // `cluster="true"` always wins over the dialect's own nonclustered-by-
80                    // default convention below - otherwise a SQL Server primary key
81                    // explicitly asking to be clustered would render the opposite (M1).
82                    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        // Only primary key should be emitted, index should be filtered
268        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); // Exceeds postgres max of 63
298        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        // pk_* constraint name should be <= 63 chars
313        let pk_constraint = &constraints[0];
314        assert!(pk_constraint.contains("constraint pk_"));
315        assert!(pk_constraint.contains("primary key (id)"));
316        // Extract the constraint name part (between "constraint " and " primary")
317        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        // ak_*1 constraint name should be <= 63 chars
324        let ak_constraint = &constraints[1];
325        assert!(ak_constraint.contains("constraint ak_"));
326        assert!(ak_constraint.contains("unique (code)"));
327        // Extract the constraint name part
328        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        // Regression test: byte-index slicing panics ("not a char boundary") on
338        // multi-byte UTF-8 once truncation kicks in; truncating by char must not.
339        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        // Unique keys are unaffected.
375        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        // Regression test for M1: `sqlserver_key_generator.rs` hard-codes
381        // `with_nonclustered_primary_key(true)`, so `<primary cluster="true">` used to
382        // render `primary key nonclustered` - the exact opposite of what was asked.
383        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        // PostgreSQL/SQLite have no clustered/nonclustered constraint syntax - `cluster`
410        // is ignored (with a warning) rather than rendering invalid SQL (M1).
411        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}