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;
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                    // Reserve space for the *actual* suffix length, not a hard-coded
71                    // budget - a table with >=10 indexes needs a 2-digit suffix, and a
72                    // fixed 4-char reservation (3-char prefix + 1-digit suffix) would
73                    // produce an identifier over the length limit.
74                    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        // Regression test: `.chars().take(n)` was already char-safe here, but the budget
158        // it was given (`max_key_name_length - 4`) could still be wrong; this guards the
159        // overall path stays panic-free for multi-byte UTF-8 table names.
160        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        // Regression test: the old hard-coded `saturating_sub(4)` budget reserved only 1
179        // char for the numeric suffix; once a table has >=10 indexes, the suffix needs 2
180        // digits and the old logic produced an identifier one char over the limit.
181        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}