Skip to main content

schema_sql_generator/common/
sql_generator.rs

1use crate::common::function_generator::FunctionGenerator;
2use crate::common::generator_context::GeneratorContext;
3use crate::common::index_generator::IndexGenerator;
4use crate::common::other_sql_generator::OtherSqlGenerator;
5use crate::common::output_mode::OutputMode;
6use crate::common::procedure_generator::ProcedureGenerator;
7use crate::common::relation_generator::RelationGenerator;
8use crate::common::table_generator::TableGenerator;
9use crate::common::trigger_generator::TriggerGenerator;
10use crate::common::view_generator::ViewGenerator;
11use schema_model::model::types::ForeignKeyMode;
12
13pub trait SqlGenerator {
14    fn context(&self) -> &GeneratorContext;
15
16    fn generate(&self)  {
17        self.output_sql();
18    }
19
20    fn output_sql(&self) {
21        self.output_header();
22
23        if self.context().settings().output_mode() == OutputMode::IndexesOnly {
24            self.output_indexes();
25        } else if self.context().settings().output_mode() == OutputMode::TriggersOnly {
26            self.output_triggers();
27        } else {
28            self.output_other_sql_top();
29            self.output_tables();
30
31            if self.context().settings().foreign_key_mode() == ForeignKeyMode::Relations {
32                self.output_relations();
33            }
34
35            self.output_triggers();
36            self.output_functions();
37            self.output_views();
38            self.output_procedures();
39            self.output_other_sql_bottom();
40        }
41    }
42
43    fn output_header(&self);
44
45    fn output_tables(&self);
46
47    fn output_relations(&self);
48
49    fn output_indexes(&self);
50
51    fn output_triggers(&self);
52
53    fn output_functions(&self);
54
55    fn output_views(&self);
56
57    fn output_procedures(&self);
58
59    fn output_other_sql_top(&self);
60
61    fn output_other_sql_bottom(&self);
62}
63
64pub struct DefaultSqlGenerator {
65    context: GeneratorContext,
66    table_generator: Box<dyn TableGenerator>,
67    relation_generator: Box<dyn RelationGenerator>,
68    index_generator: Box<dyn IndexGenerator>,
69    function_generator: Box<dyn FunctionGenerator>,
70    view_generator: Box<dyn ViewGenerator>,
71    procedure_generator: Box<dyn ProcedureGenerator>,
72    trigger_generator: Box<dyn TriggerGenerator>,
73    other_sql_generator: Box<dyn OtherSqlGenerator>,
74}
75
76impl DefaultSqlGenerator {
77    pub fn new(
78        context: GeneratorContext,
79        table_generator: Box<dyn TableGenerator>,
80        relation_generator: Box<dyn RelationGenerator>,
81        index_generator: Box<dyn IndexGenerator>,
82        function_generator: Box<dyn FunctionGenerator>,
83        view_generator: Box<dyn ViewGenerator>,
84        procedure_generator: Box<dyn ProcedureGenerator>,
85        trigger_generator: Box<dyn TriggerGenerator>,
86        other_sql_generator: Box<dyn OtherSqlGenerator>,
87    ) -> Self {
88        Self {
89            context,
90            table_generator,
91            relation_generator,
92            index_generator,
93            function_generator,
94            view_generator,
95            procedure_generator,
96            trigger_generator,
97            other_sql_generator,
98        }
99    }
100}
101
102impl SqlGenerator for DefaultSqlGenerator {
103    fn context(&self) -> &GeneratorContext {
104        &self.context
105    }
106
107    fn generate(&self) {
108        self.output_sql();
109    }
110
111    fn output_sql(&self) {
112        self.output_header();
113
114        if self.context.settings().output_mode() == OutputMode::IndexesOnly {
115            self.output_indexes();
116        } else if self.context.settings().output_mode() == OutputMode::TriggersOnly {
117            self.output_triggers();
118        } else {
119            self.output_other_sql_top();
120            self.output_tables();
121
122            if self.context.settings().foreign_key_mode() == ForeignKeyMode::Relations {
123                self.output_relations();
124            }
125
126            self.output_triggers();
127            self.output_functions();
128            self.output_views();
129            self.output_procedures();
130            self.output_other_sql_bottom();
131        }
132    }
133
134    fn output_header(&self) {
135    }
136
137    fn output_tables(&self) {
138        self.table_generator.output_tables();
139    }
140
141    fn output_relations(&self) {
142        self.relation_generator.output_relations();
143    }
144
145    fn output_indexes(&self) {
146        self.index_generator.output_indexes();
147    }
148
149    fn output_triggers(&self) {
150        self.trigger_generator.output_triggers();
151    }
152
153    fn output_functions(&self) {
154        self.function_generator.output_functions();
155    }
156
157    fn output_views(&self) {
158        self.view_generator.output_views();
159    }
160
161    fn output_procedures(&self) {
162        self.procedure_generator.output_procedures();
163    }
164
165    fn output_other_sql_top(&self) {
166        self.other_sql_generator.output_other_sql_top();
167    }
168
169    fn output_other_sql_bottom(&self) {
170        self.other_sql_generator.output_other_sql_bottom();
171    }
172}
173
174#[cfg(test)]
175mod tests {
176    use super::*;
177    use crate::common::function_generator::FunctionGenerator;
178    use crate::common::generate_options::GenerateOptions;
179    use crate::common::index_generator::IndexGenerator;
180    use crate::common::other_sql_generator::OtherSqlGenerator;
181    use crate::common::output_mode::OutputMode;
182    use crate::common::print_writer::PrintWriter;
183    use crate::common::procedure_generator::ProcedureGenerator;
184    use crate::common::relation_generator::RelationGenerator;
185    use crate::common::sql_generator_settings::SqlGeneratorSettings;
186    use crate::common::sql_writer::SqlWriter;
187    use crate::common::table_generator::TableGenerator;
188    use crate::common::trigger_generator::TriggerGenerator;
189    use crate::common::view_generator::ViewGenerator;
190    use schema_model::builder::SchemaBuilder;
191    use schema_model::model::database_model::DatabaseModel;
192    use schema_model::model::key::Key;
193    use schema_model::model::table::Table;
194    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
195    use std::cell::RefCell;
196    use std::rc::Rc;
197
198    #[derive(Clone, Default)]
199    struct CallLog(Rc<RefCell<Vec<&'static str>>>);
200
201    impl CallLog {
202        fn record(&self, name: &'static str) {
203            self.0.borrow_mut().push(name);
204        }
205
206        fn calls(&self) -> Vec<&'static str> {
207            self.0.borrow().clone()
208        }
209    }
210
211    struct FakeTableGenerator(CallLog);
212    impl TableGenerator for FakeTableGenerator {
213        fn output_tables(&self) { self.0.record("tables"); }
214        fn output_table(&self, _table: &Table) {}
215        fn output_table_drop(&self, _table: &Table) {}
216        fn output_table_header(&self, _table: &Table) {}
217        fn output_table_definition(&self, _table: &Table) {}
218        fn output_table_footer(&self, _table: &Table) {}
219        fn output_indexes(&self, _table: &Table) {}
220        fn output_initial_data(&self, _table: &Table) {}
221    }
222
223    struct FakeRelationGenerator(CallLog);
224    impl RelationGenerator for FakeRelationGenerator {
225        fn output_relations(&self) { self.0.record("relations"); }
226    }
227
228    struct FakeIndexGenerator(CallLog);
229    impl IndexGenerator for FakeIndexGenerator {
230        fn output_indexes(&self) { self.0.record("indexes"); }
231        fn output_indexes_for_table(&self, _writer: &mut SqlWriter, _table: &Table) {}
232        fn output_index(&self, _writer: &mut SqlWriter, _statement_separator: &str, _table: &Table, _key_name: &str, _key: &Key) {}
233        fn index_options(&self, _key: &Key) -> Option<String> { None }
234    }
235
236    struct FakeFunctionGenerator(CallLog);
237    impl FunctionGenerator for FakeFunctionGenerator {
238        fn output_functions(&self) { self.0.record("functions"); }
239        fn output_function(&self, _writer: &mut SqlWriter, _statement_separator: &str, _function: &schema_model::model::function::Function) {}
240    }
241
242    struct FakeViewGenerator(CallLog);
243    impl ViewGenerator for FakeViewGenerator {
244        fn output_views(&self) { self.0.record("views"); }
245    }
246
247    struct FakeProcedureGenerator(CallLog);
248    impl ProcedureGenerator for FakeProcedureGenerator {
249        fn output_procedures(&self) { self.0.record("procedures"); }
250        fn output_procedure(&self, _writer: &mut SqlWriter, _statement_separator: &str, _procedure: &schema_model::model::procedure::Procedure) {}
251    }
252
253    struct FakeTriggerGenerator(CallLog);
254    impl TriggerGenerator for FakeTriggerGenerator {
255        fn output_triggers(&self) { self.0.record("triggers"); }
256        fn output_triggers_for_table(&self, _table: &schema_model::model::table::Table) {}
257    }
258
259    struct FakeOtherSqlGenerator(CallLog);
260    impl OtherSqlGenerator for FakeOtherSqlGenerator {
261        fn output_other_sql_top(&self) { self.0.record("other_sql_top"); }
262        fn output_other_sql_bottom(&self) { self.0.record("other_sql_bottom"); }
263        fn output_other_sql(&self, _writer: &mut SqlWriter, _statement_separator: &str, _sql: &str) {}
264    }
265
266    fn make_generator(
267        foreign_key_mode: ForeignKeyMode,
268        output_mode: OutputMode,
269    ) -> (DefaultSqlGenerator, CallLog) {
270        let log = CallLog::default();
271        let schema = SchemaBuilder::new(None::<&str>).build();
272        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
273        let mut options = GenerateOptions::new(
274            Rc::new(model),
275            Rc::new(RefCell::new(PrintWriter::new(Box::new(Vec::<u8>::new())))),
276        );
277        options.foreign_key_mode = foreign_key_mode;
278        options.output_mode = output_mode;
279        let settings = SqlGeneratorSettings::new(DatabaseType::Postgresql, &options);
280        let writer = SqlWriter::new(options.writer.clone());
281        let context = GeneratorContext::new(settings, writer);
282
283        let generator = DefaultSqlGenerator::new(
284            context,
285            Box::new(FakeTableGenerator(log.clone())),
286            Box::new(FakeRelationGenerator(log.clone())),
287            Box::new(FakeIndexGenerator(log.clone())),
288            Box::new(FakeFunctionGenerator(log.clone())),
289            Box::new(FakeViewGenerator(log.clone())),
290            Box::new(FakeProcedureGenerator(log.clone())),
291            Box::new(FakeTriggerGenerator(log.clone())),
292            Box::new(FakeOtherSqlGenerator(log.clone())),
293        );
294        (generator, log)
295    }
296
297    #[test]
298    fn output_sql_runs_full_pipeline_in_order_when_foreign_key_mode_is_relations() {
299        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::All);
300        generator.output_sql();
301
302        assert_eq!(
303            log.calls(),
304            vec!["other_sql_top", "tables", "relations", "triggers", "functions", "views", "procedures", "other_sql_bottom"]
305        );
306    }
307
308    #[test]
309    fn output_sql_skips_relations_when_foreign_key_mode_is_not_relations() {
310        let (generator, log) = make_generator(ForeignKeyMode::Triggers, OutputMode::All);
311        generator.output_sql();
312
313        assert_eq!(
314            log.calls(),
315            vec!["other_sql_top", "tables", "triggers", "functions", "views", "procedures", "other_sql_bottom"]
316        );
317        assert!(!log.calls().contains(&"relations"));
318    }
319
320    #[test]
321    fn output_sql_only_runs_indexes_when_output_mode_is_indexes_only() {
322        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::IndexesOnly);
323        generator.output_sql();
324
325        assert_eq!(log.calls(), vec!["indexes"]);
326    }
327
328    #[test]
329    fn output_sql_only_runs_triggers_when_output_mode_is_triggers_only() {
330        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::TriggersOnly);
331        generator.output_sql();
332
333        assert_eq!(log.calls(), vec!["triggers"]);
334    }
335}