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::print_writer::PrintWriter;
182    use crate::common::procedure_generator::ProcedureGenerator;
183    use crate::common::relation_generator::RelationGenerator;
184    use crate::common::sql_generator_settings::SqlGeneratorSettings;
185    use crate::common::sql_writer::SqlWriter;
186    use crate::common::table_generator::TableGenerator;
187    use crate::common::trigger_generator::TriggerGenerator;
188    use crate::common::view_generator::ViewGenerator;
189    use schema_model::builder::SchemaBuilder;
190    use schema_model::model::database_model::DatabaseModel;
191    use schema_model::model::key::Key;
192    use schema_model::model::table::Table;
193    use crate::common::output_mode::OutputMode;
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_header(&self, _table: &Table) {}
216        fn output_table_definition(&self, _table: &Table) {}
217        fn output_table_footer(&self, _table: &Table) {}
218        fn output_indexes(&self, _table: &Table) {}
219        fn output_initial_data(&self, _table: &Table) {}
220    }
221
222    struct FakeRelationGenerator(CallLog);
223    impl RelationGenerator for FakeRelationGenerator {
224        fn output_relations(&self) { self.0.record("relations"); }
225    }
226
227    struct FakeIndexGenerator(CallLog);
228    impl IndexGenerator for FakeIndexGenerator {
229        fn output_indexes(&self) { self.0.record("indexes"); }
230        fn output_indexes_for_table(&self, _writer: &mut SqlWriter, _table: &Table) {}
231        fn output_index(&self, _writer: &mut SqlWriter, _statement_separator: &str, _table: &Table, _key_name: &str, _key: &Key) {}
232        fn index_options(&self, _key: &Key) -> Option<String> { None }
233    }
234
235    struct FakeFunctionGenerator(CallLog);
236    impl FunctionGenerator for FakeFunctionGenerator {
237        fn output_functions(&self) { self.0.record("functions"); }
238        fn output_function(&self, _writer: &mut SqlWriter, _statement_separator: &str, _function: &schema_model::model::function::Function) {}
239    }
240
241    struct FakeViewGenerator(CallLog);
242    impl ViewGenerator for FakeViewGenerator {
243        fn output_views(&self) { self.0.record("views"); }
244    }
245
246    struct FakeProcedureGenerator(CallLog);
247    impl ProcedureGenerator for FakeProcedureGenerator {
248        fn output_procedures(&self) { self.0.record("procedures"); }
249        fn output_procedure(&self, _writer: &mut SqlWriter, _statement_separator: &str, _procedure: &schema_model::model::procedure::Procedure) {}
250    }
251
252    struct FakeTriggerGenerator(CallLog);
253    impl TriggerGenerator for FakeTriggerGenerator {
254        fn output_triggers(&self) { self.0.record("triggers"); }
255    }
256
257    struct FakeOtherSqlGenerator(CallLog);
258    impl OtherSqlGenerator for FakeOtherSqlGenerator {
259        fn output_other_sql_top(&self) { self.0.record("other_sql_top"); }
260        fn output_other_sql_bottom(&self) { self.0.record("other_sql_bottom"); }
261        fn output_other_sql(&self, _writer: &mut SqlWriter, _statement_separator: &str, _sql: &str) {}
262    }
263
264    fn make_generator(
265        foreign_key_mode: ForeignKeyMode,
266        output_mode: OutputMode,
267    ) -> (DefaultSqlGenerator, CallLog) {
268        let log = CallLog::default();
269        let schema = SchemaBuilder::new(None::<&str>).build();
270        let model = DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
271        let mut options = GenerateOptions::new(
272            Rc::new(model),
273            Rc::new(RefCell::new(PrintWriter::new(Box::new(Vec::<u8>::new())))),
274        );
275        options.foreign_key_mode = foreign_key_mode;
276        options.output_mode = output_mode;
277        let settings = SqlGeneratorSettings::new(DatabaseType::Postgresql, &options);
278        let writer = SqlWriter::new(options.writer.clone());
279        let context = GeneratorContext::new(settings, writer);
280
281        let generator = DefaultSqlGenerator::new(
282            context,
283            Box::new(FakeTableGenerator(log.clone())),
284            Box::new(FakeRelationGenerator(log.clone())),
285            Box::new(FakeIndexGenerator(log.clone())),
286            Box::new(FakeFunctionGenerator(log.clone())),
287            Box::new(FakeViewGenerator(log.clone())),
288            Box::new(FakeProcedureGenerator(log.clone())),
289            Box::new(FakeTriggerGenerator(log.clone())),
290            Box::new(FakeOtherSqlGenerator(log.clone())),
291        );
292        (generator, log)
293    }
294
295    #[test]
296    fn output_sql_runs_full_pipeline_in_order_when_foreign_key_mode_is_relations() {
297        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::All);
298        generator.output_sql();
299
300        assert_eq!(
301            log.calls(),
302            vec!["other_sql_top", "tables", "relations", "triggers", "functions", "views", "procedures", "other_sql_bottom"]
303        );
304    }
305
306    #[test]
307    fn output_sql_skips_relations_when_foreign_key_mode_is_not_relations() {
308        let (generator, log) = make_generator(ForeignKeyMode::Triggers, OutputMode::All);
309        generator.output_sql();
310
311        assert_eq!(
312            log.calls(),
313            vec!["other_sql_top", "tables", "triggers", "functions", "views", "procedures", "other_sql_bottom"]
314        );
315        assert!(!log.calls().contains(&"relations"));
316    }
317
318    #[test]
319    fn output_sql_only_runs_indexes_when_output_mode_is_indexes_only() {
320        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::IndexesOnly);
321        generator.output_sql();
322
323        assert_eq!(log.calls(), vec!["indexes"]);
324    }
325
326    #[test]
327    fn output_sql_only_runs_triggers_when_output_mode_is_triggers_only() {
328        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::TriggersOnly);
329        generator.output_sql();
330
331        assert_eq!(log.calls(), vec!["triggers"]);
332    }
333}