schema_reverse_engineer/
reader.rs1use 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
9pub async fn read_schema(pool: &PgPool, db_schema: &str) -> Result<DatabaseModel, SchemaReverseEngineerError> {
13 let table_names = tables::list_tables(pool, db_schema).await?;
14 let enum_types = enums::list_enum_types(pool, db_schema).await?;
15 let enum_type_names: HashSet<String> = enum_types.iter().map(|e| e.name().to_string()).collect();
16
17 let all_columns = columns::list_columns(pool, db_schema, &enum_type_names).await?;
18 let exclusion_constraint_names = constraints::list_exclusion_constraint_names(pool, db_schema).await?;
19 let mut table_keys = keys::list_keys(pool, db_schema, &exclusion_constraint_names).await?;
20 let mut table_relations = relations::list_foreign_keys(pool, db_schema).await?;
21 let mut table_constraints = constraints::list_constraints(pool, db_schema).await?;
22 let table_views = views::list_views(pool, db_schema).await?;
23
24 let mut columns_by_table: HashMap<String, Vec<columns::ColumnInfo>> = HashMap::new();
25 for column in all_columns {
26 columns_by_table.entry(column.table_name.clone()).or_default().push(column);
27 }
28
29 let mut schema_builder = SchemaBuilder::new(None::<&str>);
30 for enum_type in enum_types {
31 schema_builder = schema_builder.add_enum_type(enum_type);
32 }
33 for view in table_views {
34 schema_builder = schema_builder.add_view(view);
35 }
36
37 for table_name in &table_names {
38 let mut table_builder = TableBuilder::new(None::<&str>, table_name.as_str());
39
40 for column in columns_by_table.remove(table_name).unwrap_or_default() {
41 table_builder = table_builder.add_column(
42 ColumnBuilder::new(None::<&str>, column.column_name.as_str(), column.column_type)
43 .length(column.length)
44 .scale(column.scale)
45 .required(column.required)
46 .default_constraint(column.default_constraint)
47 .generated(column.generated)
48 .enum_type(column.enum_type)
49 .element_type(column.element_type)
50 .build(),
51 );
52 }
53
54 if let Some(keys_for_table) = table_keys.remove(table_name) {
55 if let Some(primary) = keys_for_table.primary {
56 table_builder = table_builder.add_key(build_key(KeyType::Primary, primary.columns));
57 }
58 for unique in keys_for_table.unique {
59 table_builder = table_builder.add_key(build_key(KeyType::Unique, unique.columns));
60 }
61 for index in keys_for_table.index {
62 table_builder = table_builder.add_index(build_key(KeyType::Index, index.columns));
63 }
64 }
65
66 for relation in table_relations.remove(table_name).unwrap_or_default() {
67 table_builder = table_builder.add_relation(relation);
68 }
69
70 for constraint in table_constraints.remove(table_name).unwrap_or_default() {
71 table_builder = table_builder.add_constraint(constraint);
72 }
73
74 schema_builder = schema_builder.add_table(table_builder.build());
75 }
76
77 let schema = schema_builder.build();
78
79 Ok(DatabaseModel::new(None, BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]))
80}
81
82fn build_key(key_type: KeyType, columns: Vec<String>) -> schema_model::model::key::Key {
83 let mut builder = KeyBuilder::new(key_type);
84 for column in columns {
85 builder = builder.add_column(column);
86 }
87 builder.build()
88}