Skip to main content

schema_sql_generator/postgresql/
postgres_table_generator.rs

1use crate::common::generator_context::GeneratorContext;
2use crate::common::table_generator::{DefaultTableGenerator, TableGenerator};
3use crate::postgresql::postgres_column_constraint_generator::PostgresColumnConstraintGenerator;
4use crate::postgresql::postgres_column_generator::PostgresColumnGenerator;
5use crate::postgresql::postgres_index_generator::PostgresIndexGenerator;
6use crate::postgresql::postgres_key_generator::PostgresKeyGenerator;
7use crate::postgresql::postgres_table_constraint_generator::PostgresTableConstraintGenerator;
8use schema_model::model::table::Table;
9
10pub struct PostgresTableGenerator {
11    context: GeneratorContext,
12    table_generator: DefaultTableGenerator,
13}
14
15impl PostgresTableGenerator {
16    pub fn new(context: GeneratorContext) -> Self {
17        Self {
18            table_generator: DefaultTableGenerator::new(
19                context.clone(),
20                Box::new(PostgresColumnGenerator::new(context.clone())),
21                Box::new(PostgresKeyGenerator::new(context.clone())),
22                Box::new(PostgresColumnConstraintGenerator::new(context.clone())),
23                Box::new(PostgresTableConstraintGenerator::new(context.clone())),
24                Box::new(PostgresIndexGenerator::new(context.clone())),
25            ),
26            context,
27        }
28    }
29}
30
31impl TableGenerator for PostgresTableGenerator {
32    fn output_tables(&self) {
33        // Self-dispatching loop, not a delegation to `DefaultTableGenerator::output_tables` -
34        // see `SqliteTableGenerator`/`SqlServerTableGenerator` for why: delegating would call
35        // `self.output_table` on the `DefaultTableGenerator`, statically bypassing any future
36        // override of `output_table`/its steps on this type.
37        let database_model = self.context.settings().database_model();
38        for schema in database_model.schemas() {
39            for table in schema.tables() {
40                self.output_table(table);
41            }
42        }
43    }
44
45    fn output_table(&self, table: &Table) {
46        self.output_table_drop(table);
47        self.output_table_header(table);
48        self.output_table_definition(table);
49        self.output_table_footer(table);
50        self.output_indexes(table);
51        self.output_initial_data(table);
52    }
53
54    fn output_table_drop(&self, table: &Table) {
55        self.table_generator.output_table_drop(table);
56    }
57
58    fn output_table_header(&self, table: &Table) {
59        self.table_generator.output_table_header(table);
60    }
61
62    fn output_table_definition(&self, table: &Table) {
63        self.table_generator.output_table_definition(table);
64    }
65
66    fn output_table_footer(&self, table: &Table) {
67        self.table_generator.output_table_footer(table);
68    }
69
70    fn output_indexes(&self, table: &Table) {
71        self.table_generator.output_indexes(table);
72    }
73
74    fn output_initial_data(&self, table: &Table) {
75        self.table_generator.output_initial_data(table);
76    }
77}
78
79#[cfg(test)]
80mod tests {
81    use super::*;
82    use crate::common::test_support::make_context;
83    use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
84    use schema_model::model::column_type::ColumnType;
85    use schema_model::model::database_model::DatabaseModel;
86    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
87
88    #[test]
89    fn output_table_renders_header_and_columns() {
90        let table = TableBuilder::new(None::<&str>, "users")
91            .add_column(ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence).required(true).build())
92            .add_column(ColumnBuilder::new(None::<&str>, "name", ColumnType::Varchar).length(50).required(true).build())
93            .build();
94        let schema = SchemaBuilder::new(None::<&str>).add_table(table.clone()).build();
95        let model = DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
96        let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
97
98        let generator = PostgresTableGenerator::new(ctx);
99        generator.output_table_header(&table);
100        generator.output_table_definition(&table);
101        generator.output_table_footer(&table);
102
103        let output = buffer.contents();
104        assert!(output.contains("create table public.users"));
105        assert!(output.contains("id serial"));
106        assert!(output.contains("name text"));
107        assert!(output.contains(");"));
108    }
109}