Skip to main content

schema_reverse_engineer/
reader.rs

1use crate::error::SchemaReverseEngineerError;
2use crate::info::{ColumnInfo, KeyInfo, TableKeys};
3use crate::postgres::{columns, constraints, enums, keys, relations, routines, tables, views};
4use schema_model::builder::{ColumnBuilder, KeyBuilder, SchemaBuilder, TableBuilder};
5use schema_model::model::constraint::Constraint;
6use schema_model::model::database_model::DatabaseModel;
7use schema_model::model::enum_type::EnumType;
8use schema_model::model::function::Function;
9use schema_model::model::procedure::Procedure;
10use schema_model::model::relation::Relation;
11use schema_model::model::types::{BooleanMode, ForeignKeyMode, KeyType};
12use schema_model::model::view::View;
13use sqlx::PgPool;
14use std::collections::{HashMap, HashSet};
15
16/// Introspects the given Postgres schema (`db_schema`, e.g. `"public"`) and builds a
17/// `DatabaseModel` describing its tables, columns, keys, foreign keys, check/exclusion
18/// constraints, enum types, views, functions, and procedures.
19pub async fn read_schema(
20    pool: &PgPool,
21    db_schema: &str,
22) -> Result<DatabaseModel, SchemaReverseEngineerError> {
23    let table_names = tables::list_tables(pool, db_schema).await?;
24    let enum_types = enums::list_enum_types(pool, db_schema).await?;
25    let enum_type_names: HashSet<String> =
26        enum_types.iter().map(|e| e.name().to_string()).collect();
27
28    let all_columns = columns::list_columns(pool, db_schema, &enum_type_names).await?;
29    let exclusion_constraint_names =
30        constraints::list_exclusion_constraint_names(pool, db_schema).await?;
31    let table_keys = keys::list_keys(pool, db_schema, &exclusion_constraint_names).await?;
32    let table_relations = relations::list_foreign_keys(pool, db_schema).await?;
33    let table_constraints = constraints::list_constraints(pool, db_schema).await?;
34    let table_views = views::list_views(pool, db_schema).await?;
35    let (functions, procedures) = routines::list_routines(pool, db_schema).await?;
36
37    Ok(assemble_schema(
38        db_schema,
39        SchemaParts {
40            table_names,
41            enum_types,
42            columns: all_columns,
43            keys: table_keys,
44            relations: table_relations,
45            constraints: table_constraints,
46            views: table_views,
47            functions,
48            procedures,
49        },
50    ))
51}
52
53/// Everything a dialect reader collected for one database schema.
54pub(crate) struct SchemaParts {
55    pub table_names: Vec<String>,
56    pub enum_types: Vec<EnumType>,
57    pub columns: Vec<ColumnInfo>,
58    pub keys: HashMap<String, TableKeys>,
59    pub relations: HashMap<String, Vec<Relation>>,
60    pub constraints: HashMap<String, Vec<Constraint>>,
61    pub views: Vec<View>,
62    pub functions: Vec<Function>,
63    pub procedures: Vec<Procedure>,
64}
65
66/// Builds the dialect-neutral `DatabaseModel` from a reader's collected parts.
67pub(crate) fn assemble_schema(db_schema: &str, parts: SchemaParts) -> DatabaseModel {
68    let SchemaParts {
69        table_names,
70        enum_types,
71        columns: all_columns,
72        keys: mut table_keys,
73        relations: mut table_relations,
74        constraints: mut table_constraints,
75        views: table_views,
76        functions,
77        procedures,
78    } = parts;
79
80    let mut columns_by_table: HashMap<String, Vec<ColumnInfo>> = HashMap::new();
81    for column in all_columns {
82        columns_by_table
83            .entry(column.table_name.clone())
84            .or_default()
85            .push(column);
86    }
87
88    let mut schema_builder = SchemaBuilder::new(Some(db_schema));
89    for enum_type in enum_types {
90        schema_builder = schema_builder.add_enum_type(enum_type);
91    }
92    for view in table_views {
93        schema_builder = schema_builder.add_view(view);
94    }
95    schema_builder = schema_builder
96        .add_functions(functions)
97        .add_procedures(procedures);
98
99    for table_name in &table_names {
100        let mut table_builder = TableBuilder::new(Some(db_schema), table_name.as_str());
101
102        let table_columns = columns_by_table.remove(table_name).unwrap_or_default();
103        for column in table_columns.iter().cloned() {
104            table_builder = table_builder.add_column(
105                ColumnBuilder::new(
106                    Some(db_schema),
107                    column.column_name.as_str(),
108                    column.column_type,
109                )
110                .length(column.length)
111                .scale(column.scale)
112                .required(column.required)
113                .default_constraint(column.default_constraint)
114                .generated(column.generated)
115                .enum_type(column.enum_type)
116                .element_type(column.element_type)
117                .build(),
118            );
119        }
120
121        if let Some(mut keys_for_table) = table_keys.remove(table_name) {
122            promote_lone_unique_key(&mut keys_for_table, &table_columns);
123            if let Some(primary) = keys_for_table.primary {
124                table_builder = table_builder.add_key(build_key(KeyType::Primary, primary));
125            }
126            for unique in keys_for_table.unique {
127                table_builder = table_builder.add_key(build_key(KeyType::Unique, unique));
128            }
129            for index in keys_for_table.index {
130                table_builder = table_builder.add_index(build_key(KeyType::Index, index));
131            }
132        }
133
134        for relation in table_relations.remove(table_name).unwrap_or_default() {
135            table_builder = table_builder.add_relation(relation);
136        }
137
138        for constraint in table_constraints.remove(table_name).unwrap_or_default() {
139            table_builder = table_builder.add_constraint(constraint);
140        }
141
142        schema_builder = schema_builder.add_table(table_builder.build());
143    }
144
145    let schema = schema_builder.build();
146
147    DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema])
148}
149
150/// A table with no primary key but exactly one unique key gets that key promoted to primary
151/// (mirrors a heuristic in the Java original). Only done when every key column is already
152/// `NOT NULL`: promoting a nullable column would invent a `NOT NULL` the database doesn't have.
153fn promote_lone_unique_key(keys: &mut TableKeys, table_columns: &[columns::ColumnInfo]) {
154    if keys.primary.is_some() || keys.unique.len() != 1 {
155        return;
156    }
157    let all_required = keys.unique[0].columns.iter().all(|key_column| {
158        table_columns
159            .iter()
160            .any(|c| c.column_name.eq_ignore_ascii_case(key_column) && c.required)
161    });
162    if all_required {
163        keys.primary = Some(keys.unique.remove(0));
164    }
165}
166
167fn build_key(key_type: KeyType, info: KeyInfo) -> schema_model::model::key::Key {
168    let mut builder = KeyBuilder::new(key_type);
169    for column in info.columns {
170        builder = builder.add_column(column);
171    }
172    if key_type == KeyType::Index && info.unique {
173        builder = builder.unique(true);
174    }
175    if !info.include.is_empty() {
176        builder = builder.include(info.include.join(","));
177    }
178    if let Some(filter) = info.filter {
179        builder = builder.filter(filter);
180    }
181    builder.build()
182}