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.relation_generator.inline_foreign_key_constraints(table);
86 self.table_generator.output_table_definition_with_extra(table, inline_foreign_keys);
87 }
88
89 fn output_table_footer(&self, table: &Table) {
90 self.table_generator.output_table_footer(table);
91 }
92
93 fn output_indexes(&self, table: &Table) {
94 self.table_generator.output_indexes(table);
95 }
96
97 fn output_initial_data(&self, table: &Table) {
98 self.table_generator.output_initial_data(table);
99 }
100}
101
102#[cfg(test)]
103mod tests {
104 use super::*;
105 use crate::common::test_support::make_context;
106 use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
107 use schema_model::model::column_type::ColumnType;
108 use schema_model::model::database_model::DatabaseModel;
109 use schema_model::model::key::{Key, KeyColumn};
110 use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode, KeyType};
111
112 #[test]
113 fn output_table_renders_header_and_columns() {
114 let table = TableBuilder::new(None::<&str>, "users")
115 .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
116 .add_column(ColumnBuilder::new(None::<&str>, "name", ColumnType::Varchar).length(50).required(true).build())
117 .add_key(Key::new(KeyType::Primary, vec![KeyColumn::new("id")]))
118 .build();
119 let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
120 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
121 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
122
123 let generator = SqliteTableGenerator::new(ctx);
124 generator.output_table_header(&table);
125 generator.output_table_definition(&table);
126 generator.output_table_footer(&table);
127
128 let output = buffer.contents();
129 assert!(output.contains("create table users"));
130 assert!(output.contains("id integer primary key autoincrement"));
131 assert!(!output.contains("primary key (id)"));
134 assert!(output.contains("name varchar(50)"));
135 assert!(output.contains(");"));
136 }
137
138 #[test]
139 fn output_tables_reaches_inline_foreign_keys_via_self_dispatch() {
140 let parent = TableBuilder::new(None::<&str>, "parent")
144 .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
145 .add_key(Key::new(KeyType::Primary, vec![KeyColumn::new("id")]))
146 .build();
147 let child = TableBuilder::new(None::<&str>, "child")
148 .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).required(true).build())
149 .add_relation(schema_model::model::relation::Relation::new(
150 "parent", "id", "child", "parent_id", schema_model::model::types::RelationType::Cascade, false,
151 ))
152 .build();
153 let schema = SchemaBuilder::new(None::<&str>)
154 .add_table(parent)
155 .add_table(child)
156 .build();
157 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
158 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
159
160 let generator = SqliteTableGenerator::new(ctx);
161 generator.output_tables();
162
163 let output = buffer.contents();
164 assert!(output.contains("foreign key (parent_id) references parent(id)"));
165 }
166
167 #[test]
168 fn output_tables_drops_child_before_parent_and_before_any_create() {
169 let parent = TableBuilder::new(None::<&str>, "parent")
175 .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
176 .add_key(Key::new(KeyType::Primary, vec![KeyColumn::new("id")]))
177 .build();
178 let child = TableBuilder::new(None::<&str>, "child")
179 .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).required(true).build())
180 .add_relation(schema_model::model::relation::Relation::new(
181 "parent", "id", "child", "parent_id", schema_model::model::types::RelationType::Cascade, false,
182 ))
183 .build();
184 let schema = SchemaBuilder::new(None::<&str>)
185 .add_table(parent)
186 .add_table(child)
187 .build();
188 let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
189 let (ctx, buffer) = make_context(model, DatabaseType::Sqlite);
190
191 let generator = SqliteTableGenerator::new(ctx);
192 generator.output_tables();
193
194 let output = buffer.contents();
195 let drop_child = output.find("drop table if exists child").unwrap();
196 let drop_parent = output.find("drop table if exists parent").unwrap();
197 let create_child = output.find("create table child").unwrap();
198 let create_parent = output.find("create table parent").unwrap();
199
200 assert!(drop_child < drop_parent, "child must be dropped before the parent it references");
201 assert!(drop_parent < create_child, "every drop must precede every create");
202 assert!(drop_parent < create_parent, "every drop must precede every create");
203 }
204}