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 (...)` when another key on the same table has explicitly claimed the
26    /// table's one clustered slot (`cluster="true"`). Has no effect otherwise - dialects
27    /// without a `clustered`/`nonclustered` constraint keyword (Postgres, SQLite) should
28    /// leave this false.
29    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    /// `cluster="true"` only has a rendering on SQL Server (`clustered`/`nonclustered` is a
39    /// SQL Server-only constraint keyword - PostgreSQL and SQLite have nothing equivalent).
40    /// On those dialects the attribute is ignored rather than hard-erroring, since one
41    /// schema.xml is meant to target all three databases and a SQL-Server-only tuning hint
42    /// shouldn't stop the other two from generating (M1).
43    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    /// `compress="true"` on a `<primary>`/`<unique>` key only has a rendering on SQL Server
61    /// (`with (data_compression = page)`) - PostgreSQL and SQLite have no equivalent, so the
62    /// attribute is warned about and ignored there rather than hard-erroring, matching how
63    /// `effective_cluster` and the index generators handle dialect-specific tuning hints (M1).
64    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    /// Same as `key_constraints`, but when `skip_primary_key` is true the primary key
84    /// constraint is left out entirely - for dialects (SQLite) that declare the primary key
85    /// inline on the column instead of as a separate table constraint.
86    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                    // `cluster="true"` always wins over the nonclustered fallback below -
104                    // otherwise a SQL Server primary key explicitly asking to be clustered
105                    // would render the opposite (M1).
106                    //
107                    // `NONCLUSTERED` is only ever emitted here when it's actually needed: a
108                    // table can have at most one clustered index/constraint, so if some other
109                    // key on this table explicitly claims that slot (`cluster="true"`), the PK
110                    // must be pushed off it. Otherwise the PK renders bare and SQL Server's own
111                    // default (`CLUSTERED` for a `PRIMARY KEY` constraint) applies - a plain
112                    // `nonclustered_primary_key` flag once forced this unconditionally, which
113                    // needlessly turned every SQL Server table into a heap even when nothing
114                    // else wanted the clustered slot.
115                    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        // Only primary key should be emitted, index should be filtered
318        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); // Exceeds postgres max of 63
348        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        // pk_* constraint name should be <= 63 chars
363        let pk_constraint = &constraints[0];
364        assert!(pk_constraint.contains("constraint pk_"));
365        assert!(pk_constraint.contains("primary key (id)"));
366        // Extract the constraint name part (between "constraint " and " primary")
367        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        // ak_*1 constraint name should be <= 63 chars
374        let ak_constraint = &constraints[1];
375        assert!(ak_constraint.contains("constraint ak_"));
376        assert!(ak_constraint.contains("unique (code)"));
377        // Extract the constraint name part
378        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        // Regression test: byte-index slicing panics ("not a char boundary") on
388        // multi-byte UTF-8 once truncation kicks in; truncating by char must not.
389        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        // Regression test: `nonclustered_primary_key` used to force `nonclustered`
409        // unconditionally on every SQL Server PK, turning tables into heaps even when
410        // nothing else on the table wanted the clustered slot. Since SQL Server's own
411        // default (`CLUSTERED` for a `PRIMARY KEY` constraint) is fine here, no keyword
412        // should be emitted.
413        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        // The one case NONCLUSTERED is actually needed: a unique key has claimed the
435        // table's single clustered slot, so the PK must be pushed off it.
436        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        // Regression test for M1: `sqlserver_key_generator.rs` hard-codes
458        // `with_nonclustered_primary_key(true)`, so `<primary cluster="true">` used to
459        // render `primary key nonclustered` - the exact opposite of what was asked.
460        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        // PostgreSQL/SQLite have no clustered/nonclustered constraint syntax - `cluster`
487        // is ignored (with a warning) rather than rendering invalid SQL (M1).
488        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        // PostgreSQL/SQLite have no key-level compression syntax - `compress` is ignored
541        // (with a warning) rather than rendering invalid SQL, matching `cluster` handling (M1).
542        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}