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