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