schema_sql_generator/common/
table_generator.rs1use crate::common::column_constraint_generator::ColumnConstraintGenerator;
2use crate::common::column_generator::ColumnGenerator;
3use crate::common::generator_context::GeneratorContext;
4use crate::common::index_generator::IndexGenerator;
5use crate::common::key_generator::KeyGenerator;
6use crate::common::table_constraint_generator::TableConstraintGenerator;
7use crate::{sql_newline, sql_print, sql_println};
8use schema_model::model::table::Table;
9use schema_model::model::types::DatabaseType;
10
11pub trait TableGenerator {
12 fn output_tables(&self);
13 fn output_table(&self, table: &Table);
14 fn output_table_header(&self, table: &Table);
15 fn output_table_definition(&self, table: &Table);
16 fn output_table_footer(&self, table: &Table);
17 fn output_indexes(&self, table: &Table);
18 fn output_initial_data(&self, table: &Table);
19}
20
21pub struct DefaultTableGenerator {
22 context: GeneratorContext,
23 column_generator: Box<dyn ColumnGenerator>,
24 key_generator: Box<dyn KeyGenerator>,
25 column_constraint_generator: Box<dyn ColumnConstraintGenerator>,
26 table_constraint_generator: Box<dyn TableConstraintGenerator>,
27 index_generator: Box<dyn IndexGenerator>,
28}
29
30impl DefaultTableGenerator {
31 pub fn new(
32 context: GeneratorContext,
33 column_generator: Box<dyn ColumnGenerator>,
34 key_generator: Box<dyn KeyGenerator>,
35 column_constraint_generator: Box<dyn ColumnConstraintGenerator>,
36 table_constraint_generator: Box<dyn TableConstraintGenerator>,
37 index_generator: Box<dyn IndexGenerator>,
38 ) -> Self {
39 Self {
40 column_generator,
41 key_generator,
42 column_constraint_generator,
43 table_constraint_generator,
44 index_generator,
45 context,
46 }
47 }
48
49 pub fn output_table_definition_with_extra(&self, table: &Table, extra: Vec<String>) {
53 let table_definitions: Vec<String> = self.column_generator.column_definitions(table)
54 .into_iter()
55 .chain(self.key_generator.key_constraints(table))
56 .chain(self.column_constraint_generator.column_check_constraints(table))
57 .chain(self.table_constraint_generator.table_check_constraints(table))
58 .chain(extra)
59 .collect();
60
61 self.context.with_writer(|writer| {
62 for (i, sql) in table_definitions.iter().enumerate() {
63 sql_print!(writer, "{}", sql);
64
65 if i < table_definitions.len() - 1 {
66 sql_print!(writer, ",");
67 }
68
69 sql_newline!(writer);
70 }
71 });
72 }
73}
74
75impl TableGenerator for DefaultTableGenerator {
76 fn output_tables(&self) {
77 for schema in self.context.settings().database_model().schemas() {
78 for table in schema.tables() {
79 self.output_table(table);
80 };
81 }
82 }
83
84
85 fn output_table(&self, table: &Table) {
86 self.output_table_header(table);
87 self.output_table_definition(table);
88 self.output_table_footer(table);
89 self.output_indexes(table);
90 self.output_initial_data(table);
91 }
92
93 fn output_table_header(&self, table: &Table) {
94 let is_postgres = self.context.settings().database_type() == DatabaseType::Postgresql;
95 let cascade_suffix = if is_postgres { " cascade" } else { "" };
96 let separator = self.context.settings().statement_separator().to_string();
97 let fully_qualified_table_name = table.fully_qualified_table_name(self.context.settings().database_type());
98
99 self.context.with_writer(|writer| {
100 if is_postgres {
101 sql_println!(writer, "/* {} */", fully_qualified_table_name);
102 sql_println!(writer, "drop table if exists {}{}{}", fully_qualified_table_name, cascade_suffix, separator);
103 sql_println!(writer, "");
104 sql_println!(writer, "create table {}", fully_qualified_table_name);
105 sql_println!(writer, "(");
106 } else {
107 sql_println!(writer, "drop table if exists {}{}{}", fully_qualified_table_name, cascade_suffix, separator);
108 sql_println!(writer, "/* {} */", fully_qualified_table_name);
109 sql_println!(writer, "create table {}", fully_qualified_table_name);
110 sql_println!(writer, "(");
111 }
112 });
113 }
114
115 fn output_table_definition(&self, table: &Table) {
116 self.output_table_definition_with_extra(table, Vec::new());
117 }
118
119 fn output_table_footer(&self, _table: &Table) {
120 self.context.with_writer(|writer| {
121 sql_println!(writer, "){}", self.context.settings().statement_separator());
122 sql_newline!(writer);
123 });
124 }
125
126 fn output_indexes(&self, table: &Table) {
127 self.context.with_writer(|writer| {
128 self.index_generator.output_indexes_for_table(writer, table);
129 });
130 }
131
132 fn output_initial_data(&self, table: &Table) {
133 let initial_data = table.initial_data()
134 .iter()
135 .filter(|it| { it.database_type().is_none() || it.database_type().unwrap() == self.context.settings().database_type() })
136 .collect::<Vec<_>>();
137
138 if !initial_data.is_empty() {
139 self.context.with_writer(|writer| {
140 initial_data.iter().for_each(|it| {
141 sql_println!(writer, "{}{}", it.sql(), self.context.settings().statement_separator());
142 });
143
144 writer.newline();
145 });
146 }
147 }
148}
149
150#[cfg(test)]
151mod tests {
152 use super::*;
153 use crate::common::column_generator::ColumnGenerator;
154 use crate::common::index_generator::IndexGenerator;
155 use crate::common::key_generator::KeyGenerator;
156 use crate::common::table_constraint_generator::TableConstraintGenerator;
157 use crate::common::test_support::make_context;
158 use schema_model::builder::{SchemaBuilder, TableBuilder};
159 use schema_model::model::column::Column;
160 use schema_model::model::database_model::DatabaseModel;
161 use schema_model::model::initial_data::InitialData;
162 use schema_model::model::key::Key;
163 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
164
165 struct NoopColumnGenerator;
166 impl ColumnGenerator for NoopColumnGenerator {
167 fn column_definitions(&self, _table: &Table) -> Vec<String> { Vec::new() }
168 fn column_sql(&self, _table: &Table, _column: &Column) -> String { String::new() }
169 fn column_options(&self, _table: &Table, _column: &Column) -> String { String::new() }
170 fn default_value(&self, _table: &Table, _column: &Column) -> Option<String> { None }
171 }
172
173 struct NoopKeyGenerator;
174 impl KeyGenerator for NoopKeyGenerator {
175 fn key_constraints(&self, _table: &Table) -> Vec<String> { Vec::new() }
176 }
177
178 struct NoopColumnConstraintGenerator;
179 impl ColumnConstraintGenerator for NoopColumnConstraintGenerator {
180 fn column_check_constraints(&self, _table: &Table) -> Vec<String> { Vec::new() }
181 }
182
183 struct NoopTableConstraintGenerator;
184 impl TableConstraintGenerator for NoopTableConstraintGenerator {
185 fn table_check_constraints(&self, _table: &Table) -> Vec<String> { Vec::new() }
186 }
187
188 struct NoopIndexGenerator;
189 impl IndexGenerator for NoopIndexGenerator {
190 fn output_indexes(&self) {}
191 fn output_indexes_for_table(&self, _writer: &mut crate::common::sql_writer::SqlWriter, _table: &Table) {}
192 fn output_index(&self, _writer: &mut crate::common::sql_writer::SqlWriter, _statement_separator: &str, _table: &Table, _key_name: &str, _key: &Key) {}
193 fn index_options(&self, _key: &Key) -> Option<String> { None }
194 }
195
196 fn make_generator(context: GeneratorContext) -> DefaultTableGenerator {
197 DefaultTableGenerator::new(
198 context,
199 Box::new(NoopColumnGenerator),
200 Box::new(NoopKeyGenerator),
201 Box::new(NoopColumnConstraintGenerator),
202 Box::new(NoopTableConstraintGenerator),
203 Box::new(NoopIndexGenerator),
204 )
205 }
206
207 #[test]
208 fn output_initial_data_includes_rows_for_current_database_type_or_unspecified() {
209 let table = TableBuilder::new(None::<&str>, "users")
210 .add_initial_data(InitialData::new("insert into users values (1)", None))
211 .add_initial_data(InitialData::new("insert into users values (2)", Some(DatabaseType::Sqlite)))
212 .add_initial_data(InitialData::new("insert into users values (3)", Some(DatabaseType::Postgresql)))
213 .build();
214 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
215 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
216 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
217
218 let generator = make_generator(ctx);
219 generator.output_initial_data(&table);
220
221 let output = buffer.contents();
222 assert!(output.contains("insert into users values (1)"));
223 assert!(output.contains("insert into users values (2)"));
224 assert!(!output.contains("insert into users values (3)"));
225 }
226
227 #[test]
228 fn output_initial_data_writes_nothing_when_table_has_no_rows() {
229 let table = TableBuilder::new(None::<&str>, "users").build();
230 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
231 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
232 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
233
234 let generator = make_generator(ctx);
235 generator.output_initial_data(&table);
236
237 assert_eq!(buffer.contents(), "");
238 }
239
240 #[test]
241 fn output_table_runs_all_steps_in_order() {
242 let table = TableBuilder::new(None::<&str>, "users")
243 .add_initial_data(InitialData::new("insert into users values (1)", None))
244 .build();
245 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
246 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
247 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
248
249 let generator = make_generator(ctx);
250 generator.output_table(&table);
251
252 let output = buffer.contents();
253 let header_pos = output.find("create table users").unwrap();
254 let footer_pos = output.find(")").unwrap();
255 let data_pos = output.find("insert into users values (1)").unwrap();
256 assert!(header_pos < footer_pos);
257 assert!(footer_pos < data_pos);
258 }
259}