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    /// Wires one strategy per output section; the argument count mirrors the struct fields.
78    #[allow(clippy::too_many_arguments)]
79    pub fn new(
80        context: GeneratorContext,
81        table_generator: Box<dyn TableGenerator>,
82        relation_generator: Box<dyn RelationGenerator>,
83        index_generator: Box<dyn IndexGenerator>,
84        function_generator: Box<dyn FunctionGenerator>,
85        view_generator: Box<dyn ViewGenerator>,
86        procedure_generator: Box<dyn ProcedureGenerator>,
87        trigger_generator: Box<dyn TriggerGenerator>,
88        other_sql_generator: Box<dyn OtherSqlGenerator>,
89    ) -> Self {
90        Self {
91            context,
92            table_generator,
93            relation_generator,
94            index_generator,
95            function_generator,
96            view_generator,
97            procedure_generator,
98            trigger_generator,
99            other_sql_generator,
100        }
101    }
102}
103
104impl SqlGenerator for DefaultSqlGenerator {
105    fn context(&self) -> &GeneratorContext {
106        &self.context
107    }
108
109    fn generate(&self) {
110        self.output_sql();
111    }
112
113    fn output_sql(&self) {
114        self.output_header();
115
116        if self.context.settings().output_mode() == OutputMode::IndexesOnly {
117            self.output_indexes();
118        } else if self.context.settings().output_mode() == OutputMode::TriggersOnly {
119            self.output_triggers();
120        } else {
121            self.output_other_sql_top();
122            self.output_tables();
123
124            if self.context.settings().foreign_key_mode() == ForeignKeyMode::Relations {
125                self.output_relations();
126            }
127
128            self.output_triggers();
129            self.output_functions();
130            self.output_views();
131            self.output_procedures();
132            self.output_other_sql_bottom();
133        }
134    }
135
136    fn output_header(&self) {}
137
138    fn output_tables(&self) {
139        self.table_generator.output_tables();
140    }
141
142    fn output_relations(&self) {
143        self.relation_generator.output_relations();
144    }
145
146    fn output_indexes(&self) {
147        self.index_generator.output_indexes();
148    }
149
150    fn output_triggers(&self) {
151        self.trigger_generator.output_triggers();
152    }
153
154    fn output_functions(&self) {
155        self.function_generator.output_functions();
156    }
157
158    fn output_views(&self) {
159        self.view_generator.output_views();
160    }
161
162    fn output_procedures(&self) {
163        self.procedure_generator.output_procedures();
164    }
165
166    fn output_other_sql_top(&self) {
167        self.other_sql_generator.output_other_sql_top();
168    }
169
170    fn output_other_sql_bottom(&self) {
171        self.other_sql_generator.output_other_sql_bottom();
172    }
173}
174
175#[cfg(test)]
176mod tests {
177    use super::*;
178    use crate::common::function_generator::FunctionGenerator;
179    use crate::common::generate_options::GenerateOptions;
180    use crate::common::index_generator::IndexGenerator;
181    use crate::common::other_sql_generator::OtherSqlGenerator;
182    use crate::common::output_mode::OutputMode;
183    use crate::common::print_writer::PrintWriter;
184    use crate::common::procedure_generator::ProcedureGenerator;
185    use crate::common::relation_generator::RelationGenerator;
186    use crate::common::sql_generator_settings::SqlGeneratorSettings;
187    use crate::common::sql_writer::SqlWriter;
188    use crate::common::table_generator::TableGenerator;
189    use crate::common::trigger_generator::TriggerGenerator;
190    use crate::common::view_generator::ViewGenerator;
191    use schema_model::builder::SchemaBuilder;
192    use schema_model::model::database_model::DatabaseModel;
193    use schema_model::model::key::Key;
194    use schema_model::model::table::Table;
195    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
196    use std::cell::RefCell;
197    use std::rc::Rc;
198
199    #[derive(Clone, Default)]
200    struct CallLog(Rc<RefCell<Vec<&'static str>>>);
201
202    impl CallLog {
203        fn record(&self, name: &'static str) {
204            self.0.borrow_mut().push(name);
205        }
206
207        fn calls(&self) -> Vec<&'static str> {
208            self.0.borrow().clone()
209        }
210    }
211
212    struct FakeTableGenerator(CallLog);
213    impl TableGenerator for FakeTableGenerator {
214        fn output_tables(&self) {
215            self.0.record("tables");
216        }
217        fn output_table(&self, _table: &Table) {}
218        fn output_table_drop(&self, _table: &Table) {}
219        fn output_table_header(&self, _table: &Table) {}
220        fn output_table_definition(&self, _table: &Table) {}
221        fn output_table_footer(&self, _table: &Table) {}
222        fn output_indexes(&self, _table: &Table) {}
223        fn output_initial_data(&self, _table: &Table) {}
224    }
225
226    struct FakeRelationGenerator(CallLog);
227    impl RelationGenerator for FakeRelationGenerator {
228        fn output_relations(&self) {
229            self.0.record("relations");
230        }
231    }
232
233    struct FakeIndexGenerator(CallLog);
234    impl IndexGenerator for FakeIndexGenerator {
235        fn output_indexes(&self) {
236            self.0.record("indexes");
237        }
238        fn output_indexes_for_table(&self, _writer: &mut SqlWriter, _table: &Table) {}
239        fn output_index(
240            &self,
241            _writer: &mut SqlWriter,
242            _statement_separator: &str,
243            _table: &Table,
244            _key_name: &str,
245            _key: &Key,
246        ) {
247        }
248        fn index_options(&self, _key: &Key) -> Option<String> {
249            None
250        }
251    }
252
253    struct FakeFunctionGenerator(CallLog);
254    impl FunctionGenerator for FakeFunctionGenerator {
255        fn output_functions(&self) {
256            self.0.record("functions");
257        }
258        fn output_function(
259            &self,
260            _writer: &mut SqlWriter,
261            _statement_separator: &str,
262            _function: &schema_model::model::function::Function,
263        ) {
264        }
265    }
266
267    struct FakeViewGenerator(CallLog);
268    impl ViewGenerator for FakeViewGenerator {
269        fn output_views(&self) {
270            self.0.record("views");
271        }
272    }
273
274    struct FakeProcedureGenerator(CallLog);
275    impl ProcedureGenerator for FakeProcedureGenerator {
276        fn output_procedures(&self) {
277            self.0.record("procedures");
278        }
279        fn output_procedure(
280            &self,
281            _writer: &mut SqlWriter,
282            _statement_separator: &str,
283            _procedure: &schema_model::model::procedure::Procedure,
284        ) {
285        }
286    }
287
288    struct FakeTriggerGenerator(CallLog);
289    impl TriggerGenerator for FakeTriggerGenerator {
290        fn output_triggers(&self) {
291            self.0.record("triggers");
292        }
293        fn output_triggers_for_table(&self, _table: &schema_model::model::table::Table) {}
294    }
295
296    struct FakeOtherSqlGenerator(CallLog);
297    impl OtherSqlGenerator for FakeOtherSqlGenerator {
298        fn output_other_sql_top(&self) {
299            self.0.record("other_sql_top");
300        }
301        fn output_other_sql_bottom(&self) {
302            self.0.record("other_sql_bottom");
303        }
304        fn output_other_sql(
305            &self,
306            _writer: &mut SqlWriter,
307            _statement_separator: &str,
308            _sql: &str,
309        ) {
310        }
311    }
312
313    fn make_generator(
314        foreign_key_mode: ForeignKeyMode,
315        output_mode: OutputMode,
316    ) -> (DefaultSqlGenerator, CallLog) {
317        let log = CallLog::default();
318        let schema = SchemaBuilder::new(None::<&str>).build();
319        let model =
320            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
321        let mut options = GenerateOptions::new(
322            Rc::new(model),
323            Rc::new(RefCell::new(PrintWriter::new(Box::new(Vec::<u8>::new())))),
324        );
325        options.foreign_key_mode = foreign_key_mode;
326        options.output_mode = output_mode;
327        let settings = SqlGeneratorSettings::new(DatabaseType::Postgresql, &options);
328        let writer = SqlWriter::new(options.writer.clone());
329        let context = GeneratorContext::new(settings, writer);
330
331        let generator = DefaultSqlGenerator::new(
332            context,
333            Box::new(FakeTableGenerator(log.clone())),
334            Box::new(FakeRelationGenerator(log.clone())),
335            Box::new(FakeIndexGenerator(log.clone())),
336            Box::new(FakeFunctionGenerator(log.clone())),
337            Box::new(FakeViewGenerator(log.clone())),
338            Box::new(FakeProcedureGenerator(log.clone())),
339            Box::new(FakeTriggerGenerator(log.clone())),
340            Box::new(FakeOtherSqlGenerator(log.clone())),
341        );
342        (generator, log)
343    }
344
345    #[test]
346    fn output_sql_runs_full_pipeline_in_order_when_foreign_key_mode_is_relations() {
347        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::All);
348        generator.output_sql();
349
350        assert_eq!(
351            log.calls(),
352            vec![
353                "other_sql_top",
354                "tables",
355                "relations",
356                "triggers",
357                "functions",
358                "views",
359                "procedures",
360                "other_sql_bottom"
361            ]
362        );
363    }
364
365    #[test]
366    fn output_sql_skips_relations_when_foreign_key_mode_is_not_relations() {
367        let (generator, log) = make_generator(ForeignKeyMode::Triggers, OutputMode::All);
368        generator.output_sql();
369
370        assert_eq!(
371            log.calls(),
372            vec![
373                "other_sql_top",
374                "tables",
375                "triggers",
376                "functions",
377                "views",
378                "procedures",
379                "other_sql_bottom"
380            ]
381        );
382        assert!(!log.calls().contains(&"relations"));
383    }
384
385    #[test]
386    fn output_sql_only_runs_indexes_when_output_mode_is_indexes_only() {
387        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::IndexesOnly);
388        generator.output_sql();
389
390        assert_eq!(log.calls(), vec!["indexes"]);
391    }
392
393    #[test]
394    fn output_sql_only_runs_triggers_when_output_mode_is_triggers_only() {
395        let (generator, log) = make_generator(ForeignKeyMode::Relations, OutputMode::TriggersOnly);
396        generator.output_sql();
397
398        assert_eq!(log.calls(), vec!["triggers"]);
399    }
400}