Skip to main content

appstruct_migrate/
introspection.rs

1use crate::{MigrationError, connect_database};
2use postgres::Client;
3use std::collections::BTreeMap;
4
5mod catalog;
6
7#[derive(Clone, Debug, PartialEq, Eq)]
8pub struct IntrospectedSchema {
9    pub name: String,
10    pub tables: Vec<IntrospectedTable>,
11    pub foreign_keys: Vec<IntrospectedForeignKey>,
12}
13
14#[derive(Clone, Debug, PartialEq, Eq)]
15pub struct IntrospectedTable {
16    pub name: String,
17    pub columns: Vec<IntrospectedColumn>,
18    pub primary_key: Vec<String>,
19    pub unique_constraints: Vec<Vec<String>>,
20    pub indexes: Vec<IntrospectedIndex>,
21}
22
23#[derive(Clone, Debug, PartialEq, Eq)]
24pub struct IntrospectedIndex {
25    pub name: String,
26    pub columns: Vec<String>,
27    pub unique: bool,
28    pub method: String,
29    pub operator_class: Option<String>,
30    pub predicate: Option<String>,
31}
32
33#[derive(Clone, Debug, PartialEq, Eq)]
34pub struct IntrospectedColumn {
35    pub name: String,
36    pub data_type: String,
37    pub udt_schema: String,
38    pub udt_name: String,
39    pub domain_schema: Option<String>,
40    pub domain_name: Option<String>,
41    pub nullable: bool,
42    pub default: Option<String>,
43    pub identity: bool,
44    pub generated: bool,
45    pub max_length: Option<i32>,
46    pub enum_values: Vec<String>,
47}
48
49#[derive(Clone, Debug, PartialEq, Eq)]
50pub struct IntrospectedForeignKey {
51    pub name: String,
52    pub source_table: String,
53    pub source_columns: Vec<String>,
54    pub target_schema: String,
55    pub target_table: String,
56    pub target_columns: Vec<String>,
57    pub on_delete: String,
58}
59
60/// Inspect one PostgreSQL schema without changing database state.
61///
62/// # Errors
63///
64/// Returns an error when the connection fails, the schema does not exist, or catalog rows cannot
65/// be read.
66pub fn inspect_database_schema(
67    database_url: &str,
68    schema: &str,
69) -> Result<IntrospectedSchema, MigrationError> {
70    let mut client = connect_database(database_url)?;
71    inspect(&mut client, schema)
72}
73
74fn inspect(client: &mut Client, schema: &str) -> Result<IntrospectedSchema, MigrationError> {
75    if !catalog::schema_exists(client, schema)? {
76        return Err(MigrationError::Database(format!(
77            "PostgreSQL schema `{schema}` does not exist"
78        )));
79    }
80    let table_names = catalog::tables(client, schema)?;
81    let mut columns = catalog::columns(client, schema)?;
82    let enum_values = catalog::enum_values(client)?;
83    for (_, column) in &mut columns {
84        column.enum_values = enum_values
85            .get(&(column.udt_schema.clone(), column.udt_name.clone()))
86            .cloned()
87            .unwrap_or_default();
88    }
89    let constraints = catalog::key_constraints(client, schema)?;
90    let indexes = catalog::indexes(client, schema)?;
91    let mut columns_by_table = BTreeMap::<String, Vec<_>>::new();
92    for column in columns {
93        columns_by_table.entry(column.0).or_default().push(column.1);
94    }
95    let mut primary_keys = BTreeMap::<String, Vec<String>>::new();
96    let mut unique_constraints = BTreeMap::<String, Vec<Vec<String>>>::new();
97    for constraint in constraints {
98        if constraint.primary {
99            primary_keys.insert(constraint.table, constraint.columns);
100        } else {
101            unique_constraints
102                .entry(constraint.table)
103                .or_default()
104                .push(constraint.columns);
105        }
106    }
107    let mut indexes_by_table = BTreeMap::<String, Vec<IntrospectedIndex>>::new();
108    for index in indexes {
109        indexes_by_table
110            .entry(index.table.clone())
111            .or_default()
112            .push(IntrospectedIndex {
113                name: index.name,
114                columns: index.columns,
115                unique: index.unique,
116                method: index.method,
117                operator_class: index.operator_class,
118                predicate: index.predicate,
119            });
120    }
121    let tables = table_names
122        .into_iter()
123        .filter(|name| !name.starts_with("_appstruct_"))
124        .map(|name| IntrospectedTable {
125            columns: columns_by_table.remove(&name).unwrap_or_default(),
126            primary_key: primary_keys.remove(&name).unwrap_or_default(),
127            unique_constraints: unique_constraints.remove(&name).unwrap_or_default(),
128            indexes: indexes_by_table.remove(&name).unwrap_or_default(),
129            name,
130        })
131        .collect();
132    Ok(IntrospectedSchema {
133        name: schema.to_owned(),
134        tables,
135        foreign_keys: catalog::foreign_keys(client, schema)?
136            .into_iter()
137            .filter(|key| !key.source_table.starts_with("_appstruct_"))
138            .collect(),
139    })
140}