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