use crate::{MigrationError, connect_database};
use postgres::Client;
use std::collections::BTreeMap;
mod catalog;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct IntrospectedSchema {
pub name: String,
pub tables: Vec<IntrospectedTable>,
pub foreign_keys: Vec<IntrospectedForeignKey>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct IntrospectedTable {
pub name: String,
pub columns: Vec<IntrospectedColumn>,
pub primary_key: Vec<String>,
pub unique_constraints: Vec<Vec<String>>,
pub indexes: Vec<IntrospectedIndex>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct IntrospectedIndex {
pub name: String,
pub columns: Vec<String>,
pub unique: bool,
pub method: String,
pub operator_class: Option<String>,
pub predicate: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct IntrospectedColumn {
pub name: String,
pub data_type: String,
pub udt_schema: String,
pub udt_name: String,
pub domain_schema: Option<String>,
pub domain_name: Option<String>,
pub nullable: bool,
pub default: Option<String>,
pub identity: bool,
pub generated: bool,
pub max_length: Option<i32>,
pub enum_values: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct IntrospectedForeignKey {
pub name: String,
pub source_table: String,
pub source_columns: Vec<String>,
pub target_schema: String,
pub target_table: String,
pub target_columns: Vec<String>,
pub on_delete: String,
}
pub fn inspect_database_schema(
database_url: &str,
schema: &str,
) -> Result<IntrospectedSchema, MigrationError> {
let mut client = connect_database(database_url)?;
inspect(&mut client, schema)
}
fn inspect(client: &mut Client, schema: &str) -> Result<IntrospectedSchema, MigrationError> {
if !catalog::schema_exists(client, schema)? {
return Err(MigrationError::Database(format!(
"PostgreSQL schema `{schema}` does not exist"
)));
}
let table_names = catalog::tables(client, schema)?;
let mut columns = catalog::columns(client, schema)?;
let enum_values = catalog::enum_values(client)?;
for (_, column) in &mut columns {
column.enum_values = enum_values
.get(&(column.udt_schema.clone(), column.udt_name.clone()))
.cloned()
.unwrap_or_default();
}
let constraints = catalog::key_constraints(client, schema)?;
let indexes = catalog::indexes(client, schema)?;
let mut columns_by_table = BTreeMap::<String, Vec<_>>::new();
for column in columns {
columns_by_table.entry(column.0).or_default().push(column.1);
}
let mut primary_keys = BTreeMap::<String, Vec<String>>::new();
let mut unique_constraints = BTreeMap::<String, Vec<Vec<String>>>::new();
for constraint in constraints {
if constraint.primary {
primary_keys.insert(constraint.table, constraint.columns);
} else {
unique_constraints
.entry(constraint.table)
.or_default()
.push(constraint.columns);
}
}
let mut indexes_by_table = BTreeMap::<String, Vec<IntrospectedIndex>>::new();
for index in indexes {
indexes_by_table
.entry(index.table.clone())
.or_default()
.push(IntrospectedIndex {
name: index.name,
columns: index.columns,
unique: index.unique,
method: index.method,
operator_class: index.operator_class,
predicate: index.predicate,
});
}
let tables = table_names
.into_iter()
.filter(|name| !name.starts_with("_appstruct_"))
.map(|name| IntrospectedTable {
columns: columns_by_table.remove(&name).unwrap_or_default(),
primary_key: primary_keys.remove(&name).unwrap_or_default(),
unique_constraints: unique_constraints.remove(&name).unwrap_or_default(),
indexes: indexes_by_table.remove(&name).unwrap_or_default(),
name,
})
.collect();
Ok(IntrospectedSchema {
name: schema.to_owned(),
tables,
foreign_keys: catalog::foreign_keys(client, schema)?
.into_iter()
.filter(|key| !key.source_table.starts_with("_appstruct_"))
.collect(),
})
}