Skip to main content

schema_reverse_engineer/
reader.rs

1use crate::error::SchemaReverseEngineerError;
2use crate::postgres::{columns, constraints, enums, keys, relations, tables, views};
3use schema_model::builder::{ColumnBuilder, KeyBuilder, SchemaBuilder, TableBuilder};
4use schema_model::model::database_model::DatabaseModel;
5use schema_model::model::types::{BooleanMode, ForeignKeyMode, KeyType};
6use sqlx::PgPool;
7use std::collections::{HashMap, HashSet};
8
9/// Introspects the given Postgres schema (`db_schema`, e.g. `"public"`) and builds a
10/// `DatabaseModel` describing its tables, columns, keys, foreign keys, check/exclusion
11/// constraints, enum types, and views.
12pub async fn read_schema(
13    pool: &PgPool,
14    db_schema: &str,
15) -> Result<DatabaseModel, SchemaReverseEngineerError> {
16    let table_names = tables::list_tables(pool, db_schema).await?;
17    let enum_types = enums::list_enum_types(pool, db_schema).await?;
18    let enum_type_names: HashSet<String> =
19        enum_types.iter().map(|e| e.name().to_string()).collect();
20
21    let all_columns = columns::list_columns(pool, db_schema, &enum_type_names).await?;
22    let exclusion_constraint_names =
23        constraints::list_exclusion_constraint_names(pool, db_schema).await?;
24    let mut table_keys = keys::list_keys(pool, db_schema, &exclusion_constraint_names).await?;
25    let mut table_relations = relations::list_foreign_keys(pool, db_schema).await?;
26    let mut table_constraints = constraints::list_constraints(pool, db_schema).await?;
27    let table_views = views::list_views(pool, db_schema).await?;
28
29    let mut columns_by_table: HashMap<String, Vec<columns::ColumnInfo>> = HashMap::new();
30    for column in all_columns {
31        columns_by_table
32            .entry(column.table_name.clone())
33            .or_default()
34            .push(column);
35    }
36
37    let mut schema_builder = SchemaBuilder::new(Some(db_schema));
38    for enum_type in enum_types {
39        schema_builder = schema_builder.add_enum_type(enum_type);
40    }
41    for view in table_views {
42        schema_builder = schema_builder.add_view(view);
43    }
44
45    for table_name in &table_names {
46        let mut table_builder = TableBuilder::new(Some(db_schema), table_name.as_str());
47
48        for column in columns_by_table.remove(table_name).unwrap_or_default() {
49            table_builder = table_builder.add_column(
50                ColumnBuilder::new(
51                    Some(db_schema),
52                    column.column_name.as_str(),
53                    column.column_type,
54                )
55                .length(column.length)
56                .scale(column.scale)
57                .required(column.required)
58                .default_constraint(column.default_constraint)
59                .generated(column.generated)
60                .enum_type(column.enum_type)
61                .element_type(column.element_type)
62                .build(),
63            );
64        }
65
66        if let Some(keys_for_table) = table_keys.remove(table_name) {
67            if let Some(primary) = keys_for_table.primary {
68                table_builder = table_builder.add_key(build_key(KeyType::Primary, primary.columns));
69            }
70            for unique in keys_for_table.unique {
71                table_builder = table_builder.add_key(build_key(KeyType::Unique, unique.columns));
72            }
73            for index in keys_for_table.index {
74                table_builder = table_builder.add_index(build_key(KeyType::Index, index.columns));
75            }
76        }
77
78        for relation in table_relations.remove(table_name).unwrap_or_default() {
79            table_builder = table_builder.add_relation(relation);
80        }
81
82        for constraint in table_constraints.remove(table_name).unwrap_or_default() {
83            table_builder = table_builder.add_constraint(constraint);
84        }
85
86        schema_builder = schema_builder.add_table(table_builder.build());
87    }
88
89    let schema = schema_builder.build();
90
91    Ok(DatabaseModel::new(
92        BooleanMode::Native,
93        ForeignKeyMode::Relations,
94        vec![schema],
95    ))
96}
97
98fn build_key(key_type: KeyType, columns: Vec<String>) -> schema_model::model::key::Key {
99    let mut builder = KeyBuilder::new(key_type);
100    for column in columns {
101        builder = builder.add_column(column);
102    }
103    builder.build()
104}