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            nulls_not_distinct: false,
69            without_overlaps: false,
70        });
71    }
72}
73pub fn auto_increment_columns(columns: &[ColumnDef]) -> BTreeSet<String> {
74    columns
75        .iter()
76        .filter(|column| column.auto_increment.is_some())
77        .map(|column| column.name.clone())
78        .collect()
79}
80pub fn unique_scalar_columns(
81    constraints: Vec<TableKeyConstraint>,
82    auto_increment: &BTreeSet<String>,
83) -> Vec<String> {
84    constraints
85        .into_iter()
86        .filter(|constraint| constraint.columns.len() == 1)
87        .map(|constraint| constraint.columns[0].clone())
88        .filter(|column| !auto_increment.contains(column))
89        .collect()
90}
91/// Loaded table identities only; persisted references do not consult the session search path.
92pub trait StoredTableNames {
93    fn stored_table_exists(&self, relation: &RelationIdentity) -> bool;
94    fn stored_table_names(&self) -> Vec<RelationIdentity>;
95}
96pub fn canonical_stored_foreign_key_target(
97    catalog: &dyn StoredTableNames,
98    reference: &str,
99) -> Result<String, String> {
100    let (schema, local_name) = RelationIdentity::parse_reference(reference)
101        .map_err(|error| format!("invalid persisted foreign-key target `{reference}`: {error}"))?;
102    if let Some(schema) = schema {
103        let target = RelationIdentity::new(schema, local_name);
104        if catalog.stored_table_exists(&target) {
105            return Ok(target.qualified_name());
106        }
107        return Err(format!(
108            "dangling persisted foreign-key target `{reference}`"
109        ));
110    }
111    let candidates = catalog
112        .stored_table_names()
113        .into_iter()
114        .filter(|candidate| candidate.name == local_name)
115        .map(|candidate| candidate.qualified_name())
116        .collect::<Vec<_>>();
117    match candidates.as_slice() {
118        [target] => Ok(target.clone()),
119        [] => Err(format!(
120            "dangling persisted foreign-key target `{reference}`"
121        )),
122        _ => Err(format!(
123            "ambiguous persisted foreign-key target `{reference}` matches {}",
124            candidates.join(", ")
125        )),
126    }
127}
128pub fn bind_stored_foreign_key_targets(
129    catalog: &dyn StoredTableNames,
130    foreign_keys: &mut [ForeignKey],
131) -> Result<(), String> {
132    for foreign_key in foreign_keys {
133        foreign_key.ref_table =
134            canonical_stored_foreign_key_target(catalog, &foreign_key.ref_table)?;
135    }
136    Ok(())
137}
138
139/// Canonicalize legacy declarations before attaching durable index identities. Resolve against all stored relations, never a caller's search path.
140pub fn bind_stored_foreign_key_declarations(
141    catalog: &dyn StoredTableNames,
142    columns: &mut [ColumnDef],
143    constraints: &mut crate::ast::TableConstraintSet,
144) -> Result<bool, String> {
145    let mut changed = false;
146    let mut bind = |target: &mut String| -> Result<(), String> {
147        let canonical = canonical_stored_foreign_key_target(catalog, target)?;
148        changed |= *target != canonical;
149        *target = canonical;
150        Ok(())
151    };
152    for column in columns {
153        if let Some(reference) = &mut column.references {
154            bind(&mut reference.table)?;
155        }
156    }
157    for key in constraints
158        .foreign_keys
159        .iter_mut()
160        .chain(&mut constraints.hierarchy.partition_inherited_foreign_keys)
161    {
162        bind(&mut key.ref_table)?;
163    }
164    Ok(changed)
165}
166
167#[cfg(test)]
168mod tests;
uqa_sql/schema/constraint_views.rs

uqa_sql/schema/
constraint_views.rs
