schema_sql_generator/sqlite/
sqlite_table_generator.rs1use crate::common::generator_context::GeneratorContext;
2use crate::common::table_generator::{DefaultTableGenerator, TableGenerator};
3use crate::sqlite::sqlite_column_constraint_generator::SqliteColumnConstraintGenerator;
4use crate::sqlite::sqlite_column_generator::SqliteColumnGenerator;
5use crate::sqlite::sqlite_index_generator::SqliteIndexGenerator;
6use crate::sqlite::sqlite_key_generator::SqliteKeyGenerator;
7use crate::sqlite::sqlite_relation_generator::SqliteRelationGenerator;
8use crate::sqlite::sqlite_table_constraint_generator::SqliteTableConstraintGenerator;
9use schema_model::model::table::Table;
10
11pub struct SqliteTableGenerator {
12 context: GeneratorContext,
13 table_generator: DefaultTableGenerator,
14 relation_generator: SqliteRelationGenerator,
15}
16
17impl SqliteTableGenerator {
18 pub fn new(context: GeneratorContext) -> Self {
19 Self {
20 table_generator: DefaultTableGenerator::new(
21 context.clone(),
22 Box::new(SqliteColumnGenerator::new(context.clone())),
23 Box::new(SqliteKeyGenerator::new(context.clone())),
24 Box::new(SqliteColumnConstraintGenerator::new(context.clone())),
25 Box::new(SqliteTableConstraintGenerator::new(context.clone())),
26 Box::new(SqliteIndexGenerator::new(context.clone())),
27 ),
28 relation_generator: SqliteRelationGenerator::new(context.clone()),
29 context,
30 }
31 }
32}
33
34impl TableGenerator for SqliteTableGenerator {
35 fn output_tables(&self) {
36 let database_model = self.context.settings().database_model();
48
49 for table in crate::common::table_generator::tables_in_drop_order(database_model) {
50 self.output_table_drop(table);
51 }
52
53 for schema in database_model.schemas() {
54 for table in schema.tables() {
55 self.output_table_header(table);
56 self.output_table_definition(table);
57 self.output_table_footer(table);
58 self.output_indexes(table);
59 self.output_initial_data(table);
60 }
61 }
62 }
63
64 fn output_table(&self, table: &Table) {
65 self.output_table_drop(table);
66 self.output_table_header(table);
67 self.output_table_definition(table);
68 self.output_table_footer(table);
69 self.output_indexes(table);
70 self.output_initial_data(table);
71 }
72
73 fn output_table_drop(&self, table: &Table) {
74 self.table_generator.output_table_drop(table);
75 }
76
77 fn output_table_header(&self, table: &Table) {
78 self.table_generator.output_table_header(table);
79 }
80
81 fn output_table_definition(&self, table: &Table) {
82 let inline_foreign_keys = self
86 .relation_generator
87 .inline_foreign_key_constraints(table);
88 self.table_generator
89 .output_table_definition_with_extra(table, inline_foreign_keys);
90 }
91
92 fn output_table_footer(&self, table: &Table) {
93 self.table_generator.output_table_footer(table);
94 }
95
96 fn output_indexes(&self, table: &Table) {
97 self.table_generator.output_indexes(table);
98 }
99
100 fn output_initial_data(&self, table: &Table) {
101 self.table_generator.output_initial_data(table);
102 }
103}
104
105#[cfg(test)]
106mod tests {
107 use super::*;
108 use crate::common::test_support::make_context;
109 use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
110 use schema_model::model::column_type::ColumnType;
111 use schema_model::model::database_model::DatabaseModel;
112 use schema_model::model::key::{Key, KeyColumn};
113 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode, KeyType};
114
115 #[test]
116 fn output_table_renders_header_and_columns() {
117 let table = TableBuilder::new(None::<&str>, "users")
118 .add_column(
119 ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
120 .required(true)
121 .build(),
122 )
123 .add_column(
124 ColumnBuilder::new(None::<&str>, "name", ColumnType::Varchar)
125 .length(50)
126 .required(true)
127 .build(),
128 )
129 .add_key(Key::new(KeyType::Primary, vec![KeyColumn::new("id")]))
130 .build();
131 let schema = SchemaBuilder::new(None::<&str>)
132 .add_table(table.clone())
133 .build();
134 let model =
135 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
136 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
137
138 let generator = SqliteTableGenerator::new(ctx);
139 generator.output_table_header(&table);
140 generator.output_table_definition(&table);
141 generator.output_table_footer(&table);
142
143 let output = buffer.contents();
144 assert!(output.contains("create table users"));
145 assert!(output.contains("id integer primary key autoincrement"));
146 assert!(!output.contains("primary key (id)"));
149 assert!(output.contains("name varchar(50)"));
150 assert!(output.contains(");"));
151 }
152
153 #[test]
154 fn output_tables_reaches_inline_foreign_keys_via_self_dispatch() {
155 let parent = TableBuilder::new(None::<&str>, "parent")
159 .add_column(
160 ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
161 .required(true)
162 .build(),
163 )
164 .add_key(Key::new(KeyType::Primary, vec![KeyColumn::new("id")]))
165 .build();
166 let child = TableBuilder::new(None::<&str>, "child")
167 .add_column(
168 ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int)
169 .required(true)
170 .build(),
171 )
172 .add_relation(schema_model::model::relation::Relation::new(
173 "parent",
174 "id",
175 "child",
176 "parent_id",
177 schema_model::model::types::RelationType::Cascade,
178 false,
179 ))
180 .build();
181 let schema = SchemaBuilder::new(None::<&str>)
182 .add_table(parent)
183 .add_table(child)
184 .build();
185 let model =
186 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
187 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
188
189 let generator = SqliteTableGenerator::new(ctx);
190 generator.output_tables();
191
192 let output = buffer.contents();
193 assert!(output.contains("foreign key (parent_id) references parent(id)"));
194 }
195
196 #[test]
197 fn output_tables_drops_child_before_parent_and_before_any_create() {
198 let parent = TableBuilder::new(None::<&str>, "parent")
204 .add_column(
205 ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
206 .required(true)
207 .build(),
208 )
209 .add_key(Key::new(KeyType::Primary, vec![KeyColumn::new("id")]))
210 .build();
211 let child = TableBuilder::new(None::<&str>, "child")
212 .add_column(
213 ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int)
214 .required(true)
215 .build(),
216 )
217 .add_relation(schema_model::model::relation::Relation::new(
218 "parent",
219 "id",
220 "child",
221 "parent_id",
222 schema_model::model::types::RelationType::Cascade,
223 false,
224 ))
225 .build();
226 let schema = SchemaBuilder::new(None::<&str>)
227 .add_table(parent)
228 .add_table(child)
229 .build();
230 let model =
231 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
232 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
233
234 let generator = SqliteTableGenerator::new(ctx);
235 generator.output_tables();
236
237 let output = buffer.contents();
238 let drop_child = output.find("drop table if exists child").unwrap();
239 let drop_parent = output.find("drop table if exists parent").unwrap();
240 let create_child = output.find("create table child").unwrap();
241 let create_parent = output.find("create table parent").unwrap();
242
243 assert!(
244 drop_child < drop_parent,
245 "child must be dropped before the parent it references"
246 );
247 assert!(
248 drop_parent < create_child,
249 "every drop must precede every create"
250 );
251 assert!(
252 drop_parent < create_parent,
253 "every drop must precede every create"
254 );
255 }
256}