schema_sql_generator/postgresql/
postgres_table_generator.rs1use 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 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}