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 #[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}