Skip to main content

schema_sql_generator/common/
table_generator.rs

1use crate::common::column_constraint_generator::ColumnConstraintGenerator;
2use crate::common::column_generator::ColumnGenerator;
3use crate::common::generator_context::GeneratorContext;
4use crate::common::index_generator::IndexGenerator;
5use crate::common::key_generator::KeyGenerator;
6use crate::common::table_constraint_generator::TableConstraintGenerator;
7use crate::{sql_newline, sql_print, sql_println};
8use schema_model::model::table::Table;
9use schema_model::model::types::DatabaseType;
10
11pub trait TableGenerator {
12    fn output_tables(&self);
13    fn output_table(&self, table: &Table);
14    fn output_table_header(&self, table: &Table);
15    fn output_table_definition(&self, table: &Table);
16    fn output_table_footer(&self, table: &Table);
17    fn output_indexes(&self, table: &Table);
18    fn output_initial_data(&self, table: &Table);
19}
20
21pub struct DefaultTableGenerator {
22    context: GeneratorContext,
23    column_generator: Box<dyn ColumnGenerator>,
24    key_generator: Box<dyn KeyGenerator>,
25    column_constraint_generator: Box<dyn ColumnConstraintGenerator>,
26    table_constraint_generator: Box<dyn TableConstraintGenerator>,
27    index_generator: Box<dyn IndexGenerator>,
28}
29
30impl DefaultTableGenerator {
31    pub fn new(
32        context: GeneratorContext,
33        column_generator: Box<dyn ColumnGenerator>,
34        key_generator: Box<dyn KeyGenerator>,
35        column_constraint_generator: Box<dyn ColumnConstraintGenerator>,
36        table_constraint_generator: Box<dyn TableConstraintGenerator>,
37        index_generator: Box<dyn IndexGenerator>,
38    ) -> Self {
39        Self {
40            column_generator,
41            key_generator,
42            column_constraint_generator,
43            table_constraint_generator,
44            index_generator,
45            context,
46        }
47    }
48
49    /// Same as `output_table_definition`, but appends `extra` definition clauses
50    /// (e.g. dialect-specific inline foreign key constraints) to the comma-separated
51    /// list before printing.
52    pub fn output_table_definition_with_extra(&self, table: &Table, extra: Vec<String>) {
53        let table_definitions: Vec<String> = self.column_generator.column_definitions(table)
54            .into_iter()
55            .chain(self.key_generator.key_constraints(table))
56            .chain(self.column_constraint_generator.column_check_constraints(table))
57            .chain(self.table_constraint_generator.table_check_constraints(table))
58            .chain(extra)
59            .collect();
60
61        self.context.with_writer(|writer| {
62            for (i, sql) in table_definitions.iter().enumerate() {
63                sql_print!(writer, "{}", sql);
64
65                if i < table_definitions.len() - 1 {
66                    sql_print!(writer, ",");
67                }
68
69                sql_newline!(writer);
70            }
71        });
72    }
73}
74
75impl TableGenerator for DefaultTableGenerator {
76    fn output_tables(&self) {
77        for schema in self.context.settings().database_model().schemas() {
78            for table in schema.tables() {
79                self.output_table(table);
80            };
81        }
82    }
83
84
85    fn output_table(&self, table: &Table) {
86        self.output_table_header(table);
87        self.output_table_definition(table);
88        self.output_table_footer(table);
89        self.output_indexes(table);
90        self.output_initial_data(table);
91    }
92
93    fn output_table_header(&self, table: &Table) {
94        let is_postgres = self.context.settings().database_type() == DatabaseType::Postgresql;
95        let cascade_suffix = if is_postgres { " cascade" } else { "" };
96        let separator = self.context.settings().statement_separator().to_string();
97        let fully_qualified_table_name = table.fully_qualified_table_name(self.context.settings().database_type());
98
99        self.context.with_writer(|writer| {
100            if is_postgres {
101                sql_println!(writer, "/* {} */", fully_qualified_table_name);
102                sql_println!(writer, "drop table if exists {}{}{}", fully_qualified_table_name, cascade_suffix, separator);
103                sql_println!(writer, "");
104                sql_println!(writer, "create table {}", fully_qualified_table_name);
105                sql_println!(writer, "(");
106            } else {
107                sql_println!(writer, "drop table if exists {}{}{}", fully_qualified_table_name, cascade_suffix, separator);
108                sql_println!(writer, "/* {} */", fully_qualified_table_name);
109                sql_println!(writer, "create table {}", fully_qualified_table_name);
110                sql_println!(writer, "(");
111            }
112        });
113    }
114
115    fn output_table_definition(&self, table: &Table) {
116        self.output_table_definition_with_extra(table, Vec::new());
117    }
118
119    fn output_table_footer(&self, _table: &Table) {
120        self.context.with_writer(|writer| {
121            sql_println!(writer, "){}", self.context.settings().statement_separator());
122            sql_newline!(writer);
123        });
124    }
125
126    fn output_indexes(&self, table: &Table) {
127        self.context.with_writer(|writer| {
128            self.index_generator.output_indexes_for_table(writer, table);
129        });
130    }
131
132    fn output_initial_data(&self, table: &Table) {
133        let initial_data = table.initial_data()
134            .iter()
135            .filter(|it| { it.database_type().is_none() || it.database_type().unwrap() == self.context.settings().database_type() })
136            .collect::<Vec<_>>();
137
138        if !initial_data.is_empty() {
139            self.context.with_writer(|writer| {
140                initial_data.iter().for_each(|it| {
141                    sql_println!(writer, "{}{}", it.sql(), self.context.settings().statement_separator());
142                });
143
144                writer.newline();
145            });
146        }
147    }
148}
149
150#[cfg(test)]
151mod tests {
152    use super::*;
153    use crate::common::column_generator::ColumnGenerator;
154    use crate::common::index_generator::IndexGenerator;
155    use crate::common::key_generator::KeyGenerator;
156    use crate::common::table_constraint_generator::TableConstraintGenerator;
157    use crate::common::test_support::make_context;
158    use schema_model::builder::{SchemaBuilder, TableBuilder};
159    use schema_model::model::column::Column;
160    use schema_model::model::database_model::DatabaseModel;
161    use schema_model::model::initial_data::InitialData;
162    use schema_model::model::key::Key;
163    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
164
165    struct NoopColumnGenerator;
166    impl ColumnGenerator for NoopColumnGenerator {
167        fn column_definitions(&self, _table: &Table) -> Vec<String> { Vec::new() }
168        fn column_sql(&self, _table: &Table, _column: &Column) -> String { String::new() }
169        fn column_options(&self, _table: &Table, _column: &Column) -> String { String::new() }
170        fn default_value(&self, _table: &Table, _column: &Column) -> Option<String> { None }
171    }
172
173    struct NoopKeyGenerator;
174    impl KeyGenerator for NoopKeyGenerator {
175        fn key_constraints(&self, _table: &Table) -> Vec<String> { Vec::new() }
176    }
177
178    struct NoopColumnConstraintGenerator;
179    impl ColumnConstraintGenerator for NoopColumnConstraintGenerator {
180        fn column_check_constraints(&self, _table: &Table) -> Vec<String> { Vec::new() }
181    }
182
183    struct NoopTableConstraintGenerator;
184    impl TableConstraintGenerator for NoopTableConstraintGenerator {
185        fn table_check_constraints(&self, _table: &Table) -> Vec<String> { Vec::new() }
186    }
187
188    struct NoopIndexGenerator;
189    impl IndexGenerator for NoopIndexGenerator {
190        fn output_indexes(&self) {}
191        fn output_indexes_for_table(&self, _writer: &mut crate::common::sql_writer::SqlWriter, _table: &Table) {}
192        fn output_index(&self, _writer: &mut crate::common::sql_writer::SqlWriter, _statement_separator: &str, _table: &Table, _key_name: &str, _key: &Key) {}
193        fn index_options(&self, _key: &Key) -> Option<String> { None }
194    }
195
196    fn make_generator(context: GeneratorContext) -> DefaultTableGenerator {
197        DefaultTableGenerator::new(
198            context,
199            Box::new(NoopColumnGenerator),
200            Box::new(NoopKeyGenerator),
201            Box::new(NoopColumnConstraintGenerator),
202            Box::new(NoopTableConstraintGenerator),
203            Box::new(NoopIndexGenerator),
204        )
205    }
206
207    #[test]
208    fn output_initial_data_includes_rows_for_current_database_type_or_unspecified() {
209        let table = TableBuilder::new(None::<&str>, "users")
210            .add_initial_data(InitialData::new("insert into users values (1)", None))
211            .add_initial_data(InitialData::new("insert into users values (2)", Some(DatabaseType::Sqlite)))
212            .add_initial_data(InitialData::new("insert into users values (3)", Some(DatabaseType::Postgresql)))
213            .build();
214        let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
215        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
216        let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
217
218        let generator = make_generator(ctx);
219        generator.output_initial_data(&table);
220
221        let output = buffer.contents();
222        assert!(output.contains("insert into users values (1)"));
223        assert!(output.contains("insert into users values (2)"));
224        assert!(!output.contains("insert into users values (3)"));
225    }
226
227    #[test]
228    fn output_initial_data_writes_nothing_when_table_has_no_rows() {
229        let table = TableBuilder::new(None::<&str>, "users").build();
230        let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
231        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
232        let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
233
234        let generator = make_generator(ctx);
235        generator.output_initial_data(&table);
236
237        assert_eq!(buffer.contents(), "");
238    }
239
240    #[test]
241    fn output_table_runs_all_steps_in_order() {
242        let table = TableBuilder::new(None::<&str>, "users")
243            .add_initial_data(InitialData::new("insert into users values (1)", None))
244            .build();
245        let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
246        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
247        let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
248
249        let generator = make_generator(ctx);
250        generator.output_table(&table);
251
252        let output = buffer.contents();
253        let header_pos = output.find("create table users").unwrap();
254        let footer_pos = output.find(")").unwrap();
255        let data_pos = output.find("insert into users values (1)").unwrap();
256        assert!(header_pos < footer_pos);
257        assert!(footer_pos < data_pos);
258    }
259}