uqa_sql/schema/
constraint_views.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Effective constraint views over stored column and table declarations.
8use crate::ast::{ColumnDef, ForeignKey, TableCheck, TableKeyConstraint, TableKeyConstraintKind};
9use std::collections::BTreeSet;
10use uqa_core::RelationIdentity;
11
12pub fn column_checks(columns: &[ColumnDef]) -> Vec<TableCheck> {
13    let mut out = Vec::new();
14    for column in columns {
15        if let Some(expr) = column.check.clone() {
16            out.push(TableCheck {
17                catalog_oid: column.check_catalog_oid,
18                name: column
19                    .check_name
20                    .clone()
21                    .or_else(|| Some(format!("{}_check", column.name))),
22                expr,
23                enforced: column.check_enforced,
24                validated: column.check_validated,
25                no_inherit: column.check_no_inherit,
26                object_id: column.check_object_id,
27                is_local: column.check_is_local,
28                partition_constraint: None,
29            });
30        }
31    }
32    out
33}
34pub fn append_column_foreign_keys(columns: &[ColumnDef], foreign_keys: &mut Vec<ForeignKey>) {
35    for column in columns {
36        if let Some(reference) = &column.references {
37            let mut foreign_key = super::foreign_keys::column_foreign_key(column, reference);
38            foreign_key.name = foreign_key
39                .name
40                .or_else(|| Some(format!("{}_fkey", column.name)));
41            foreign_keys.push(foreign_key);
42        }
43    }
44}
45pub fn append_column_keys(columns: &[ColumnDef], constraints: &mut Vec<TableKeyConstraint>) {
46    for column in columns {
47        let kind = if column.primary_key {
48            Some(TableKeyConstraintKind::PrimaryKey)
49        } else if column.unique {
50            Some(TableKeyConstraintKind::Unique)
51        } else {
52            None
53        };
54        let Some(kind) = kind else {
55            continue;
56        };
57        if constraints.iter().any(|constraint| {
58            constraint.kind == kind
59                && constraint.columns.as_slice() == std::slice::from_ref(&column.name)
60        }) {
61            continue;
62        }
63        constraints.push(TableKeyConstraint {
64            catalog_identity: None,
65            name: None,
66            kind,
67            columns: vec![column.name.clone()],
68            included_columns: Vec::new(),
69            nulls_not_distinct: false,
70            without_overlaps: false,
71        });
72    }
73}
74pub fn auto_increment_columns(columns: &[ColumnDef]) -> BTreeSet<String> {
75    columns
76        .iter()
77        .filter(|column| column.auto_increment.is_some())
78        .map(|column| column.name.clone())
79        .collect()
80}
81pub fn unique_scalar_columns(
82    constraints: Vec<TableKeyConstraint>,
83    auto_increment: &BTreeSet<String>,
84) -> Vec<String> {
85    constraints
86        .into_iter()
87        .filter(|constraint| constraint.columns.len() == 1)
88        .map(|constraint| constraint.columns[0].clone())
89        .filter(|column| !auto_increment.contains(column))
90        .collect()
91}
92/// Loaded table identities only; persisted references do not consult the session search path.
93pub trait StoredTableNames {
94    fn stored_table_exists(&self, relation: &RelationIdentity) -> bool;
95    fn stored_table_names(&self) -> Vec<RelationIdentity>;
96}
97pub fn canonical_stored_foreign_key_target(
98    catalog: &dyn StoredTableNames,
99    reference: &str,
100) -> Result<String, String> {
101    let (schema, local_name) = RelationIdentity::parse_reference(reference)
102        .map_err(|error| format!("invalid persisted foreign-key target `{reference}`: {error}"))?;
103    if let Some(schema) = schema {
104        let target = RelationIdentity::new(schema, local_name);
105        if catalog.stored_table_exists(&target) {
106            return Ok(target.qualified_name());
107        }
108        return Err(format!(
109            "dangling persisted foreign-key target `{reference}`"
110        ));
111    }
112    let candidates = catalog
113        .stored_table_names()
114        .into_iter()
115        .filter(|candidate| candidate.name == local_name)
116        .map(|candidate| candidate.qualified_name())
117        .collect::<Vec<_>>();
118    match candidates.as_slice() {
119        [target] => Ok(target.clone()),
120        [] => Err(format!(
121            "dangling persisted foreign-key target `{reference}`"
122        )),
123        _ => Err(format!(
124            "ambiguous persisted foreign-key target `{reference}` matches {}",
125            candidates.join(", ")
126        )),
127    }
128}
129pub fn bind_stored_foreign_key_targets(
130    catalog: &dyn StoredTableNames,
131    foreign_keys: &mut [ForeignKey],
132) -> Result<(), String> {
133    for foreign_key in foreign_keys {
134        foreign_key.ref_table =
135            canonical_stored_foreign_key_target(catalog, &foreign_key.ref_table)?;
136    }
137    Ok(())
138}
139
140/// Canonicalize legacy declarations before attaching durable index identities. Resolve against all stored relations, never a caller's search path.
141pub fn bind_stored_foreign_key_declarations(
142    catalog: &dyn StoredTableNames,
143    columns: &mut [ColumnDef],
144    constraints: &mut crate::ast::TableConstraintSet,
145) -> Result<bool, String> {
146    let mut changed = false;
147    let mut bind = |target: &mut String| -> Result<(), String> {
148        let canonical = canonical_stored_foreign_key_target(catalog, target)?;
149        changed |= *target != canonical;
150        *target = canonical;
151        Ok(())
152    };
153    for column in columns {
154        if let Some(reference) = &mut column.references {
155            bind(&mut reference.table)?;
156        }
157    }
158    for key in constraints
159        .foreign_keys
160        .iter_mut()
161        .chain(&mut constraints.hierarchy.partition_inherited_foreign_keys)
162    {
163        bind(&mut key.ref_table)?;
164    }
165    Ok(changed)
166}
167
168#[cfg(test)]
169mod tests;
uqa_sql/schema/constraint_views.rs

uqa_sql/schema/
constraint_views.rs
