Skip to main content

schema_sql_generator/common/
index_generator.rs

1use 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    /// Same iteration logic as `output_indexes`, but dispatches each table (and,
40    /// transitively, each index) through `generator` rather than `self` - see
41    /// `DefaultFunctionGenerator::output_functions_via` for why: a dialect wrapper (e.g.
42    /// `SqlServerIndexGenerator`) that overrides `index_options` but delegates
43    /// `output_indexes` straight to this struct would otherwise never see its own override
44    /// invoked, because Rust has no virtual dispatch on concrete types. Callers that need
45    /// their override honored should pass `self` (as a `&dyn IndexGenerator`) here instead
46    /// of calling `output_indexes` directly.
47    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    /// Same as `output_indexes_via`, one table at a time - see that method for why
60    /// dispatching through `generator` (rather than calling `self.output_index` directly)
61    /// matters.
62    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    /// Renders one `create index` statement given an already-computed `index_options` -
88    /// shared by `DefaultIndexGenerator::output_index` and every dialect override, so each
89    /// only has to supply its own `index_options` before calling back into this.
90    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
162/// Formats a comma-separated column list from XML (e.g. `"name,code"`) as SQL wants it
163/// (e.g. `"name, code"`), trimming any incidental whitespace around each name.
164pub(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        // Regression test: `.chars().take(n)` was already char-safe here, but the budget
180        // it was given (`max_key_name_length - 4`) could still be wrong; this guards the
181        // overall path stays panic-free for multi-byte UTF-8 table names.
182        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        // Regression test: the old hard-coded `saturating_sub(4)` budget reserved only 1
201        // char for the numeric suffix; once a table has >=10 indexes, the suffix needs 2
202        // digits and the old logic produced an identifier one char over the limit.
203        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}