uqa_sql/schema/dependencies/
regclass.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind literal relation references in persisted SQL schema expressions to the relations they name when the expressions are published or loaded. Analysis reads them earlier, in `oid_alias`.
8use super::walk_schema_expr_mut;
9use crate::ast::{ColumnDef, Expr, TableCheck};
10use crate::schema::sequences::implicit_ownership::StoredSequenceNames;
11use uqa_core::Value;
12
13#[cfg(test)]
14mod tests;
15
16pub trait SchemaReferenceCatalog {
17    fn loaded_relation_name(&self, reference: &str) -> Result<Option<String>, String>;
18    fn bound_relation_oid(&self, canonical: &str) -> Result<Option<i64>, String>;
19    fn visible_relation_oid(&self, reference: &str) -> Result<Option<i64>, String>;
20    fn sequence_for_binding(&self, reference: &str) -> Result<String, String>;
21}
22
23fn is_regclass(ty: &str) -> bool {
24    ty.eq_ignore_ascii_case("regclass") || ty.eq_ignore_ascii_case("pg_catalog.regclass")
25}
26
27pub fn bind_schema_regclass_constants(
28    catalog: &dyn SchemaReferenceCatalog,
29    expression: &mut Expr,
30    loaded: bool,
31) -> Result<bool, String> {
32    let mut changed = false;
33    walk_schema_expr_mut(expression, &mut |node| {
34        let Expr::Cast { expr, ty, .. } = node else {
35            return Ok(());
36        };
37        if !is_regclass(ty) {
38            return Ok(());
39        }
40        let Expr::Literal(Value::Str(reference)) = expr.as_ref() else {
41            return Ok(());
42        };
43        let oid = if loaded {
44            match reference.parse::<u32>() {
45                Ok(oid) => Some(i64::from(oid)),
46                Err(_) => match catalog.loaded_relation_name(reference)? {
47                    Some(canonical) => catalog.bound_relation_oid(&canonical)?,
48                    None => None,
49                },
50            }
51        } else {
52            catalog.visible_relation_oid(reference)?
53        }
54        .ok_or_else(|| format!("relation \"{reference}\" does not exist"))?;
55        **expr = Expr::TypedLiteral {
56            value: Value::Int(oid),
57            ty: "regclass".into(),
58        };
59        changed = true;
60        Ok(())
61    })?;
62    Ok(changed)
63}
64
65pub fn bind_table_schema_regclass_constants(
66    catalog: &dyn SchemaReferenceCatalog,
67    columns: &mut [ColumnDef],
68    checks: &mut [TableCheck],
69    loaded: bool,
70) -> Result<bool, String> {
71    let mut changed = false;
72    for column in columns {
73        for expression in [&mut column.default, &mut column.check]
74            .into_iter()
75            .flatten()
76        {
77            changed |= bind_schema_regclass_constants(catalog, expression, loaded)?;
78        }
79        if let Some(generated) = &mut column.generated {
80            changed |= bind_schema_regclass_constants(catalog, &mut generated.expression, loaded)?;
81        }
82    }
83    for check in checks {
84        changed |= bind_schema_regclass_constants(catalog, &mut check.expr, loaded)?;
85    }
86    Ok(changed)
87}
88pub fn bind_sequence_references_in_expr(
89    catalog: &dyn SchemaReferenceCatalog,
90    expression: &mut Expr,
91) -> Result<(), String> {
92    super::rewrites::rewrite_sequence_function_references(expression, &mut |reference| {
93        *reference = catalog.sequence_for_binding(reference)?;
94        Ok(())
95    })?;
96    bind_schema_regclass_constants(catalog, expression, false)?;
97    Ok(())
98}
99
100/// Convert a legacy selected builtin's creation-bound sequence name to its OID.
101/// The caller owns initial-open publication; this only changes its candidate.
102/// Explicit text conversions and user or unresolved routine bindings remain unchanged.
103pub fn bind_legacy_sequence_regclass_constants(
104    catalog: &dyn SchemaReferenceCatalog,
105    sequences: &dyn StoredSequenceNames,
106    expression: &mut Expr,
107) -> Result<bool, String> {
108    let mut changed = false;
109    walk_schema_expr_mut(expression, &mut |node| {
110        let Expr::Func {
111            name,
112            binding: Some(binding),
113            args,
114            ..
115        } = node
116        else {
117            return Ok(());
118        };
119        if !super::rewrites::is_sequence_function(name, Some(binding)) {
120            return Ok(());
121        }
122        let Some(argument @ Expr::Literal(Value::Str(_))) = args.first_mut() else {
123            return Ok(());
124        };
125        let Expr::Literal(Value::Str(reference)) = &*argument else {
126            unreachable!("legacy sequence argument is a string literal");
127        };
128        let canonical = sequences.stored_sequence_name(reference)?;
129        let oid = catalog
130            .bound_relation_oid(&canonical)?
131            .ok_or_else(|| format!("relation \"{canonical}\" does not exist"))?;
132        *argument = Expr::TypedLiteral {
133            value: Value::Int(oid),
134            ty: "regclass".into(),
135        };
136        if let Some(target) = binding.argument_types.first_mut() {
137            "regclass".clone_into(target);
138        }
139        changed = true;
140        Ok(())
141    })?;
142    Ok(changed)
143}
uqa_sql/schema/dependencies/regclass.rs

uqa_sql/schema/dependencies/
regclass.rs
