schema_sql_generator/common/
index_generator.rs1use crate::common::generator_context::GeneratorContext;
2use crate::common::sql_writer::SqlWriter;
3use schema_model::model::key::Key;
4use schema_model::model::table::Table;
5
6const IX_PREFIX: &str = "ix_";
7
8pub trait IndexGenerator {
9 fn output_indexes(&self);
10
11 fn output_indexes_for_table(&self, writer: &mut SqlWriter, table: &Table);
12
13 fn output_index(
14 &self,
15 writer: &mut SqlWriter,
16 statement_separator: &str,
17 table: &Table,
18 key_name: &str,
19 key: &Key,
20 );
21
22 fn index_options(&self, key: &Key) -> Option<String>;
23}
24
25pub struct DefaultIndexGenerator {
26 context: GeneratorContext,
27}
28
29impl DefaultIndexGenerator {
30 pub fn new(context: GeneratorContext) -> Self {
31 Self { context }
32 }
33
34 pub fn context(&self) -> &GeneratorContext {
35 &self.context
36 }
37}
38
39impl IndexGenerator for DefaultIndexGenerator {
40 fn output_indexes(&self) {
41 let database_model = self.context.settings().database_model();
42
43 self.context.with_writer(|writer| {
44 database_model.schemas().iter().for_each(|schema| {
45 schema.tables().iter().for_each(|table| {
46 self.output_indexes_for_table(writer, table);
47 });
48 });
49 });
50 }
51
52 fn output_indexes_for_table(&self, writer: &mut SqlWriter, table: &Table) {
53 if !table.indexes().is_empty() {
54 let max_key_name_length = self
55 .context()
56 .settings()
57 .database_type()
58 .max_key_name_length();
59
60 for (key_index, key) in table
61 .indexes()
62 .iter()
63 .filter(|key| key.is_index())
64 .enumerate()
65 {
66 let suffix_str = (key_index + 1).to_string();
67 let mut key_name = format!("{}{}{}", IX_PREFIX, table.name(), suffix_str).to_lowercase();
68
69 if key_name.len() > max_key_name_length {
70 let max_name_len = max_key_name_length.saturating_sub(IX_PREFIX.len() + suffix_str.len());
75 let truncated = table
76 .name()
77 .chars()
78 .take(max_name_len)
79 .collect::<String>();
80 key_name = format!("{}{}{}", IX_PREFIX, truncated, suffix_str).to_lowercase();
81 }
82
83 self.output_index(
84 writer,
85 self.context().settings().statement_separator(),
86 table,
87 key_name.as_str(),
88 key,
89 );
90 }
91
92 writer.newline();
93 }
94 }
95
96 fn output_index(
97 &self,
98 writer: &mut SqlWriter,
99 statement_separator: &str,
100 table: &Table,
101 key_name: &str,
102 key: &Key,
103 ) {
104 let index_options = self.index_options(key);
105 let fully_qualified_table_name = table.fully_qualified_table_name(self.context().settings().database_type());
106 let index_columns = key
107 .columns()
108 .iter()
109 .map(|column| column.name())
110 .collect::<Vec<_>>()
111 .join(", ");
112
113 if let Some(index_options) = index_options {
114 writer.println(
115 format!(
116 "create {}index {} on {} ({}) {}{}",
117 if key.is_unique() { "unique " } else { "" },
118 key_name,
119 fully_qualified_table_name,
120 index_columns,
121 index_options,
122 statement_separator
123 )
124 .as_str(),
125 );
126 } else {
127 writer.println(
128 format!(
129 "create {}index {} on {} ({}){}",
130 if key.is_unique() { "unique " } else { "" },
131 key_name,
132 fully_qualified_table_name,
133 index_columns,
134 statement_separator
135 )
136 .as_str(),
137 );
138 }
139 }
140
141 fn index_options(&self, _key: &Key) -> Option<String> {
142 None
143 }
144}
145
146#[cfg(test)]
147mod tests {
148 use super::*;
149 use crate::common::test_support::make_context;
150 use schema_model::builder::{SchemaBuilder, TableBuilder};
151 use schema_model::model::database_model::DatabaseModel;
152 use schema_model::model::key::KeyColumn;
153 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode, KeyType};
154
155 #[test]
156 fn output_indexes_for_table_truncates_multi_byte_table_name_without_panicking() {
157 let long_table_name = "语".repeat(70);
161 let idx = Key::new(KeyType::Index, vec![KeyColumn::new("name")]);
162 let table = TableBuilder::new(None::<&str>, long_table_name.as_str())
163 .add_index(idx)
164 .build();
165 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
166 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
167 let (ctx, buffer) = make_context(model, DatabaseType::SqlServer);
168
169 let generator = DefaultIndexGenerator::new(ctx);
170 generator.output_indexes();
171
172 let output = buffer.contents();
173 assert!(output.contains("create index"));
174 }
175
176 #[test]
177 fn index_name_stays_within_limit_for_double_digit_index() {
178 let long_table_name = "a".repeat(40);
182 let mut table_builder = TableBuilder::new(None::<&str>, long_table_name.as_str());
183 for i in 0..10 {
184 table_builder = table_builder.add_index(Key::new(KeyType::Index, vec![KeyColumn::new(format!("col{i}"))]));
185 }
186 let table = table_builder.build();
187 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
188 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
189 let (ctx, buffer) = make_context(model, DatabaseType::SqlServer);
190
191 let generator = DefaultIndexGenerator::new(ctx);
192 generator.output_indexes();
193
194 let output = buffer.contents();
195 for line in output.lines().filter(|l| l.starts_with("create index")) {
196 let name = line.split_whitespace().nth(2).unwrap();
197 assert!(name.len() <= 32, "index name '{}' exceeds SQL Server's 32 char limit", name);
198 }
199 assert!(output.contains("ix_"));
200 }
201}