Skip to main content

schema_sql_generator/common/
key_generator.rs

1use 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    /// 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    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        // Truncate table name to fit within max_key_name_length. Truncate by char, not
51        // byte index - a byte-index slice can land mid-character for any multi-byte
52        // UTF-8 table name (CJK, Cyrillic, emoji, ...) once it's long enough to need
53        // truncating, which panics ("byte index N is not a char boundary").
54        let suffix_len = suffix_str.len();
55        let prefix_len = prefix.len();
56        let available = max_key_name_length.saturating_sub(prefix_len + suffix_len);
57        let truncated_table_name: String = table_name.chars().take(available).collect();
58
59        format!("{}{}{}", prefix, truncated_table_name, suffix_str).to_lowercase()
60    }
61}
62
63impl KeyGenerator for DefaultKeyGenerator {
64    fn key_constraints(&self, table: &Table) -> Vec<String> {
65        let mut constraints = Vec::new();
66        let mut unique_key_counter = 0;
67
68        for key in table.keys() {
69            if key.is_index() {
70                continue;
71            }
72
73            match key.key_type() {
74                schema_model::model::types::KeyType::Primary => {
75                    let constraint_name = self.constraint_name(PK_PREFIX, table.name(), None);
76                    let primary_key_clause = if self.nonclustered_primary_key {
77                        "primary key nonclustered"
78                    } else {
79                        "primary key"
80                    };
81                    constraints.push(format!(
82                        "   constraint {} {} ({})",
83                        constraint_name,
84                        primary_key_clause,
85                        key.columns_as_string()
86                    ));
87                }
88                schema_model::model::types::KeyType::Unique => {
89                    unique_key_counter += 1;
90                    let constraint_name = self.constraint_name(AK_PREFIX, table.name(), Some(unique_key_counter));
91                    constraints.push(format!(
92                        "   constraint {} unique ({})",
93                        constraint_name,
94                        key.columns_as_string()
95                    ));
96                }
97                schema_model::model::types::KeyType::Index => unreachable!(),
98            }
99        }
100
101        constraints
102    }
103}
104
105#[cfg(test)]
106mod tests {
107    use super::*;
108    use crate::common::test_support::make_context;
109    use schema_model::builder::TableBuilder;
110    use schema_model::model::database_model::DatabaseModel;
111    use schema_model::model::key::Key;
112    use schema_model::model::key::KeyColumn;
113    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode, KeyType};
114
115    #[test]
116    fn empty_keys_returns_empty_vec() {
117        let table = TableBuilder::new(None::<&str>, "users").build();
118        let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
119            .add_table(table.clone())
120            .build();
121        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
122        let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
123
124        let generator = DefaultKeyGenerator::new(ctx);
125        assert_eq!(generator.key_constraints(&table), vec![] as Vec<String>);
126    }
127
128    #[test]
129    fn primary_key_single_column() {
130        let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
131        let table = TableBuilder::new(None::<&str>, "users")
132            .add_key(pk)
133            .build();
134        let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
135            .add_table(table.clone())
136            .build();
137        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
138        let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
139
140        let generator = DefaultKeyGenerator::new(ctx);
141        let constraints = generator.key_constraints(&table);
142        assert_eq!(constraints.len(), 1);
143        assert_eq!(constraints[0], "   constraint pk_users primary key (id)");
144    }
145
146    #[test]
147    fn primary_key_multiple_columns() {
148        let pk = Key::new(KeyType::Primary, vec![
149            KeyColumn::new("org_id"),
150            KeyColumn::new("user_id"),
151        ]);
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 (org_id,user_id)");
165    }
166
167    #[test]
168    fn unique_key_single_column() {
169        let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
170        let table = TableBuilder::new(None::<&str>, "users")
171            .add_key(uq)
172            .build();
173        let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
174            .add_table(table.clone())
175            .build();
176        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
177        let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
178
179        let generator = DefaultKeyGenerator::new(ctx);
180        let constraints = generator.key_constraints(&table);
181        assert_eq!(constraints.len(), 1);
182        assert_eq!(constraints[0], "   constraint ak_users1 unique (email)");
183    }
184
185    #[test]
186    fn unique_key_multiple_columns() {
187        let uq = Key::new(KeyType::Unique, vec![
188            KeyColumn::new("tenant_id"),
189            KeyColumn::new("code"),
190        ]);
191        let table = TableBuilder::new(None::<&str>, "products")
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_products1 unique (tenant_id,code)");
204    }
205
206    #[test]
207    fn multiple_keys_primary_and_unique() {
208        let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
209        let uq1 = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
210        let uq2 = Key::new(KeyType::Unique, vec![KeyColumn::new("username")]);
211        let table = TableBuilder::new(None::<&str>, "users")
212            .add_key(pk)
213            .add_key(uq1)
214            .add_key(uq2)
215            .build();
216        let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
217            .add_table(table.clone())
218            .build();
219        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
220        let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
221
222        let generator = DefaultKeyGenerator::new(ctx);
223        let constraints = generator.key_constraints(&table);
224        assert_eq!(constraints.len(), 3);
225        assert_eq!(constraints[0], "   constraint pk_users primary key (id)");
226        assert_eq!(constraints[1], "   constraint ak_users1 unique (email)");
227        assert_eq!(constraints[2], "   constraint ak_users2 unique (username)");
228    }
229
230    #[test]
231    fn filters_out_index_keys() {
232        let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
233        let idx = Key::new(KeyType::Index, vec![KeyColumn::new("name")]);
234        let table = TableBuilder::new(None::<&str>, "users")
235            .add_key(pk)
236            .add_index(idx)
237            .build();
238        let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
239            .add_table(table.clone())
240            .build();
241        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
242        let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
243
244        let generator = DefaultKeyGenerator::new(ctx);
245        let constraints = generator.key_constraints(&table);
246        // Only primary key should be emitted, index should be filtered
247        assert_eq!(constraints.len(), 1);
248        assert_eq!(constraints[0], "   constraint pk_users primary key (id)");
249    }
250
251    #[test]
252    fn unique_key_numbering_independent_of_primary_key() {
253        let uq1 = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
254        let uq2 = Key::new(KeyType::Unique, vec![KeyColumn::new("username")]);
255        let table = TableBuilder::new(None::<&str>, "products")
256            .add_key(uq1)
257            .add_key(uq2)
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(), 2);
268        assert_eq!(constraints[0], "   constraint ak_products1 unique (email)");
269        assert_eq!(constraints[1], "   constraint ak_products2 unique (username)");
270    }
271
272    #[test]
273    fn constraint_name_truncates_for_long_table_names() {
274        let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
275        let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("code")]);
276        let long_table_name = "a".repeat(70); // Exceeds postgres max of 63
277        let table = TableBuilder::new(None::<&str>, &long_table_name)
278            .add_key(pk)
279            .add_key(uq)
280            .build();
281        let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
282            .add_table(table.clone())
283            .build();
284        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
285        let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
286
287        let generator = DefaultKeyGenerator::new(ctx);
288        let constraints = generator.key_constraints(&table);
289        assert_eq!(constraints.len(), 2);
290
291        // pk_* constraint name should be <= 63 chars
292        let pk_constraint = &constraints[0];
293        assert!(pk_constraint.contains("constraint pk_"));
294        assert!(pk_constraint.contains("primary key (id)"));
295        // Extract the constraint name part (between "constraint " and " primary")
296        if let Some(start) = pk_constraint.find("constraint ")
297            && let Some(end) = pk_constraint.find(" primary") {
298                let constraint_name = &pk_constraint[start + 11..end];
299                assert!(constraint_name.len() <= 63, "Constraint name {} exceeds 63 chars", constraint_name);
300            }
301
302        // ak_*1 constraint name should be <= 63 chars
303        let ak_constraint = &constraints[1];
304        assert!(ak_constraint.contains("constraint ak_"));
305        assert!(ak_constraint.contains("unique (code)"));
306        // Extract the constraint name part
307        if let Some(start) = ak_constraint.find("constraint ")
308            && let Some(end) = ak_constraint.find(" unique") {
309                let constraint_name = &ak_constraint[start + 11..end];
310                assert!(constraint_name.len() <= 63, "Constraint name {} exceeds 63 chars", constraint_name);
311            }
312    }
313
314    #[test]
315    fn constraint_name_truncates_multi_byte_table_name_without_panicking() {
316        // Regression test: byte-index slicing panics ("not a char boundary") on
317        // multi-byte UTF-8 once truncation kicks in; truncating by char must not.
318        let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
319        let long_table_name = "语".repeat(70);
320        let table = TableBuilder::new(None::<&str>, &long_table_name)
321            .add_key(pk)
322            .build();
323        let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
324            .add_table(table.clone())
325            .build();
326        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
327        let (ctx, _buffer) = make_context(model, DatabaseType::Postgresql);
328
329        let generator = DefaultKeyGenerator::new(ctx);
330        let constraints = generator.key_constraints(&table);
331        assert_eq!(constraints.len(), 1);
332        assert!(constraints[0].contains("constraint pk_"));
333    }
334
335    #[test]
336    fn with_nonclustered_primary_key_adds_nonclustered_keyword() {
337        let pk = Key::new(KeyType::Primary, vec![KeyColumn::new("id")]);
338        let uq = Key::new(KeyType::Unique, vec![KeyColumn::new("email")]);
339        let table = TableBuilder::new(None::<&str>, "users")
340            .add_key(pk)
341            .add_key(uq)
342            .build();
343        let schema = schema_model::builder::SchemaBuilder::new(None::<&str>)
344            .add_table(table.clone())
345            .build();
346        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
347        let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
348
349        let generator = DefaultKeyGenerator::new(ctx).with_nonclustered_primary_key(true);
350        let constraints = generator.key_constraints(&table);
351        assert_eq!(constraints.len(), 2);
352        assert_eq!(constraints[0], "   constraint pk_users primary key nonclustered (id)");
353        // Unique keys are unaffected.
354        assert_eq!(constraints[1], "   constraint ak_users1 unique (email)");
355    }
356}