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(
92 ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
93 .required(true)
94 .build(),
95 )
96 .add_column(
97 ColumnBuilder::new(None::<&str>, "name", ColumnType::Varchar)
98 .length(50)
99 .required(true)
100 .build(),
101 )
102 .build();
103 let schema = SchemaBuilder::new(None::<&str>)
104 .add_table(table.clone())
105 .build();
106 let model =
107 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
108 let (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
109
110 let generator = PostgresTableGenerator::new(ctx);
111 generator.output_table_header(&table);
112 generator.output_table_definition(&table);
113 generator.output_table_footer(&table);
114
115 let output = buffer.contents();
116 assert!(output.contains("create table public.users"));
117 assert!(output.contains("id serial"));
118 assert!(output.contains("name text"));
119 assert!(output.contains(");"));
120 }
121}