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