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.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        // The table-level `constraint pk_... primary key (...)` must not also be emitted -
132        // SQLite rejects a table with more than one primary key declaration.
133        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        // Regression test for H1: `output_tables` must call back into *this* type's
141        // `output_table_definition` override (not `DefaultTableGenerator`'s), or SQLite
142        // output silently has no foreign keys under `--foreign-key-mode relations`.
143        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        // Regression test for H17: dropping in declaration order (parent first, since
170        // it must be declared before the child that references it) fails on a rerun
171        // against a populated database - the child row referencing "parent" still
172        // exists when "drop table parent" runs. All drops must be emitted up front, in
173        // reverse-dependency order (child before parent), ahead of every create.
174        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}