schema_sql_generator/common/
key_generator.rs1use 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 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 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 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); 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 let pk_constraint = &constraints[0];
293 assert!(pk_constraint.contains("constraint pk_"));
294 assert!(pk_constraint.contains("primary key (id)"));
295 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 let ak_constraint = &constraints[1];
304 assert!(ak_constraint.contains("constraint ak_"));
305 assert!(ak_constraint.contains("unique (code)"));
306 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 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 assert_eq!(constraints[1], " constraint ak_users1 unique (email)");
355 }
356}