Skip to main content

schema_sql_generator/sqlite/
sqlite_table_generator.rs

1use 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        // Self-dispatching loop (rather than delegating to
37        // `DefaultTableGenerator::output_tables`) so that `self.output_table_definition` below
38        // resolves to *this* impl's override chain instead of statically binding to
39        // `DefaultTableGenerator::output_table_definition` - see the `SqlServerTableGenerator`
40        // comment for the same pattern. Without this, `output_table_definition`'s inline
41        // foreign-key handling is unreachable and SQLite output silently has no foreign keys.
42        //
43        // All drops are emitted up front, in reverse-dependency order, rather than
44        // interleaved with each table's own create (H17): SQLite has no `cascade` on
45        // `drop table`, so dropping in declaration order can fail on the first table
46        // that's still an FK target of a later one. See `tables_in_drop_order`.
47        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        // SQLite has no `ALTER TABLE ... ADD CONSTRAINT` support, so foreign keys
83        // must be declared inline in the `CREATE TABLE` statement rather than as
84        // separate statements from the relation generator.
85        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        // The table-level `constraint pk_... primary key (...)` must not also be emitted -
147        // SQLite rejects a table with more than one primary key declaration.
148        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        // Regression test for H1: `output_tables` must call back into *this* type's
156        // `output_table_definition` override (not `DefaultTableGenerator`'s), or SQLite
157        // output silently has no foreign keys under `--foreign-key-mode relations`.
158        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        // Regression test for H17: dropping in declaration order (parent first, since
199        // it must be declared before the child that references it) fails on a rerun
200        // against a populated database - the child row referencing "parent" still
201        // exists when "drop table parent" runs. All drops must be emitted up front, in
202        // reverse-dependency order (child before parent), ahead of every create.
203        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}