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;
5use schema_model::naming::index_name;
6
7pub trait IndexGenerator {
8 fn output_indexes(&self);
9
10 fn output_indexes_for_table(&self, writer: &mut SqlWriter, table: &Table);
11
12 fn output_index(
13 &self,
14 writer: &mut SqlWriter,
15 statement_separator: &str,
16 table: &Table,
17 key_name: &str,
18 key: &Key,
19 );
20
21 fn index_options(&self, key: &Key) -> Option<String>;
22}
23
24pub struct DefaultIndexGenerator {
25 context: GeneratorContext,
26}
27
28impl DefaultIndexGenerator {
29 pub fn new(context: GeneratorContext) -> Self {
30 Self { context }
31 }
32
33 pub fn context(&self) -> &GeneratorContext {
34 &self.context
35 }
36}
37
38impl DefaultIndexGenerator {
39 pub fn output_indexes_via(&self, generator: &dyn IndexGenerator) {
48 let database_model = self.context.settings().database_model();
49
50 self.context.with_writer(|writer| {
51 database_model.schemas().iter().for_each(|schema| {
52 schema.tables().iter().for_each(|table| {
53 generator.output_indexes_for_table(writer, table);
54 });
55 });
56 });
57 }
58
59 pub fn output_indexes_for_table_via(&self, generator: &dyn IndexGenerator, writer: &mut SqlWriter, table: &Table) {
63 if !table.indexes().is_empty() {
64 let database_type = self.context().settings().database_type();
65
66 for (key_index, key) in table
67 .indexes()
68 .iter()
69 .filter(|key| key.is_index())
70 .enumerate()
71 {
72 let key_name = index_name(database_type, table.name(), key_index + 1);
73
74 generator.output_index(
75 writer,
76 self.context().settings().statement_separator(),
77 table,
78 key_name.as_str(),
79 key,
80 );
81 }
82
83 writer.newline();
84 }
85 }
86
87 pub fn render_index(
91 &self,
92 writer: &mut SqlWriter,
93 statement_separator: &str,
94 table: &Table,
95 key_name: &str,
96 key: &Key,
97 index_options: Option<String>,
98 ) {
99 let fully_qualified_table_name = table.fully_qualified_table_name(self.context().settings().database_type());
100 let index_columns = key
101 .columns()
102 .iter()
103 .map(|column| column.name())
104 .collect::<Vec<_>>()
105 .join(", ");
106
107 if let Some(index_options) = index_options {
108 writer.println(
109 format!(
110 "create {}index {} on {} ({}) {}{}",
111 if key.is_unique() { "unique " } else { "" },
112 key_name,
113 fully_qualified_table_name,
114 index_columns,
115 index_options,
116 statement_separator
117 )
118 .as_str(),
119 );
120 } else {
121 writer.println(
122 format!(
123 "create {}index {} on {} ({}){}",
124 if key.is_unique() { "unique " } else { "" },
125 key_name,
126 fully_qualified_table_name,
127 index_columns,
128 statement_separator
129 )
130 .as_str(),
131 );
132 }
133 }
134}
135
136impl IndexGenerator for DefaultIndexGenerator {
137 fn output_indexes(&self) {
138 self.output_indexes_via(self);
139 }
140
141 fn output_indexes_for_table(&self, writer: &mut SqlWriter, table: &Table) {
142 self.output_indexes_for_table_via(self, writer, table);
143 }
144
145 fn output_index(
146 &self,
147 writer: &mut SqlWriter,
148 statement_separator: &str,
149 table: &Table,
150 key_name: &str,
151 key: &Key,
152 ) {
153 let index_options = self.index_options(key);
154 self.render_index(writer, statement_separator, table, key_name, key, index_options);
155 }
156
157 fn index_options(&self, _key: &Key) -> Option<String> {
158 None
159 }
160}
161
162pub(crate) fn format_column_list(columns: &str) -> String {
165 columns.split(',').map(|c| c.trim()).collect::<Vec<_>>().join(", ")
166}
167
168#[cfg(test)]
169mod tests {
170 use super::*;
171 use crate::common::test_support::make_context;
172 use schema_model::builder::{SchemaBuilder, TableBuilder};
173 use schema_model::model::database_model::DatabaseModel;
174 use schema_model::model::key::KeyColumn;
175 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode, KeyType};
176
177 #[test]
178 fn output_indexes_for_table_truncates_multi_byte_table_name_without_panicking() {
179 let long_table_name = "语".repeat(70);
183 let idx = Key::new(KeyType::Index, vec![KeyColumn::new("name")]);
184 let table = TableBuilder::new(None::<&str>, long_table_name.as_str())
185 .add_index(idx)
186 .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 assert!(output.contains("create index"));
196 }
197
198 #[test]
199 fn index_name_stays_within_limit_for_double_digit_index() {
200 let long_table_name = "a".repeat(40);
204 let mut table_builder = TableBuilder::new(None::<&str>, long_table_name.as_str());
205 for i in 0..10 {
206 table_builder = table_builder.add_index(Key::new(KeyType::Index, vec![KeyColumn::new(format!("col{i}"))]));
207 }
208 let table = table_builder.build();
209 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
210 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
211 let (ctx, buffer) = make_context(model, DatabaseType::SqlServer);
212
213 let generator = DefaultIndexGenerator::new(ctx);
214 generator.output_indexes();
215
216 let output = buffer.contents();
217 for line in output.lines().filter(|l| l.starts_with("create index")) {
218 let name = line.split_whitespace().nth(2).unwrap();
219 assert!(name.len() <= 32, "index name '{}' exceeds SQL Server's 32 char limit", name);
220 }
221 assert!(output.contains("ix_"));
222 }
223}