schema_sql_generator/common/
sql_generator.rs1use 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_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(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}