schema_reverse_engineer/
reader.rs1use 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::other_sql::OtherSql;
10use schema_model::model::procedure::Procedure;
11use schema_model::model::relation::Relation;
12use schema_model::model::types::{BooleanMode, ForeignKeyMode, KeyType};
13use schema_model::model::view::View;
14use sqlx::PgPool;
15use std::collections::{HashMap, HashSet};
16
17pub async fn read_schema(
21 pool: &PgPool,
22 db_schema: &str,
23) -> Result<DatabaseModel, SchemaReverseEngineerError> {
24 let table_names = tables::list_tables(pool, db_schema).await?;
25 let enum_types = enums::list_enum_types(pool, db_schema).await?;
26 let enum_type_names: HashSet<String> =
27 enum_types.iter().map(|e| e.name().to_string()).collect();
28
29 let all_columns = columns::list_columns(pool, db_schema, &enum_type_names).await?;
30 let exclusion_constraint_names =
31 constraints::list_exclusion_constraint_names(pool, db_schema).await?;
32 let table_keys = keys::list_keys(pool, db_schema, &exclusion_constraint_names).await?;
33 let table_relations = relations::list_foreign_keys(pool, db_schema).await?;
34 let table_constraints = constraints::list_constraints(pool, db_schema).await?;
35 let table_views = views::list_views(pool, db_schema).await?;
36 let (functions, procedures) = routines::list_routines(pool, db_schema).await?;
37
38 Ok(assemble_schema(
39 db_schema,
40 SchemaParts {
41 table_names,
42 enum_types,
43 columns: all_columns,
44 keys: table_keys,
45 relations: table_relations,
46 constraints: table_constraints,
47 views: table_views,
48 functions,
49 procedures,
50 other_sql: Vec::new(),
51 },
52 ))
53}
54
55pub(crate) struct SchemaParts {
57 pub table_names: Vec<String>,
58 pub enum_types: Vec<EnumType>,
59 pub columns: Vec<ColumnInfo>,
60 pub keys: HashMap<String, TableKeys>,
61 pub relations: HashMap<String, Vec<Relation>>,
62 pub constraints: HashMap<String, Vec<Constraint>>,
63 pub views: Vec<View>,
64 pub functions: Vec<Function>,
65 pub procedures: Vec<Procedure>,
66 pub other_sql: Vec<OtherSql>,
67}
68
69pub(crate) fn assemble_schema(db_schema: &str, parts: SchemaParts) -> DatabaseModel {
71 let SchemaParts {
72 table_names,
73 enum_types,
74 columns: all_columns,
75 keys: mut table_keys,
76 relations: mut table_relations,
77 constraints: mut table_constraints,
78 views: table_views,
79 functions,
80 procedures,
81 other_sql,
82 } = parts;
83
84 let mut columns_by_table: HashMap<String, Vec<ColumnInfo>> = HashMap::new();
85 for column in all_columns {
86 columns_by_table
87 .entry(column.table_name.clone())
88 .or_default()
89 .push(column);
90 }
91
92 let mut schema_builder = SchemaBuilder::new(Some(db_schema));
93 for enum_type in enum_types {
94 schema_builder = schema_builder.add_enum_type(enum_type);
95 }
96 for view in table_views {
97 schema_builder = schema_builder.add_view(view);
98 }
99 schema_builder = schema_builder
100 .add_functions(functions)
101 .add_procedures(procedures);
102 for other in other_sql {
103 schema_builder = schema_builder.add_other_sql(other);
104 }
105
106 for table_name in &table_names {
107 let mut table_builder = TableBuilder::new(Some(db_schema), table_name.as_str());
108
109 let table_columns = columns_by_table.remove(table_name).unwrap_or_default();
110 for column in table_columns.iter().cloned() {
111 table_builder = table_builder.add_column(
112 ColumnBuilder::new(
113 Some(db_schema),
114 column.column_name.as_str(),
115 column.column_type,
116 )
117 .length(column.length)
118 .scale(column.scale)
119 .required(column.required)
120 .default_constraint(column.default_constraint)
121 .generated(column.generated)
122 .enum_type(column.enum_type)
123 .element_type(column.element_type)
124 .build(),
125 );
126 }
127
128 if let Some(mut keys_for_table) = table_keys.remove(table_name) {
129 promote_lone_unique_key(&mut keys_for_table, &table_columns);
130 if let Some(primary) = keys_for_table.primary {
131 table_builder = table_builder.add_key(build_key(KeyType::Primary, primary));
132 }
133 for unique in keys_for_table.unique {
134 table_builder = table_builder.add_key(build_key(KeyType::Unique, unique));
135 }
136 for index in keys_for_table.index {
137 table_builder = table_builder.add_index(build_key(KeyType::Index, index));
138 }
139 }
140
141 for relation in table_relations.remove(table_name).unwrap_or_default() {
142 table_builder = table_builder.add_relation(relation);
143 }
144
145 for constraint in table_constraints.remove(table_name).unwrap_or_default() {
146 table_builder = table_builder.add_constraint(constraint);
147 }
148
149 schema_builder = schema_builder.add_table(table_builder.build());
150 }
151
152 let schema = schema_builder.build();
153
154 DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema])
155}
156
157fn promote_lone_unique_key(keys: &mut TableKeys, table_columns: &[columns::ColumnInfo]) {
161 if keys.primary.is_some() || keys.unique.len() != 1 {
162 return;
163 }
164 let all_required = keys.unique[0].columns.iter().all(|key_column| {
165 table_columns
166 .iter()
167 .any(|c| c.column_name.eq_ignore_ascii_case(key_column) && c.required)
168 });
169 if all_required {
170 keys.primary = Some(keys.unique.remove(0));
171 }
172}
173
174fn build_key(key_type: KeyType, info: KeyInfo) -> schema_model::model::key::Key {
175 let mut builder = KeyBuilder::new(key_type);
176 for column in info.columns {
177 builder = builder.add_column(column);
178 }
179 if key_type == KeyType::Index && info.unique {
180 builder = builder.unique(true);
181 }
182 if !info.include.is_empty() {
183 builder = builder.include(info.include.join(","));
184 }
185 if let Some(filter) = info.filter {
186 builder = builder.filter(filter);
187 }
188 builder.build()
189}