Skip to main content

uqa_sql/binding/
stored_relations.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind durable statement relations while preserving namespace, catalog, and error ordering.
8
9mod production;
10mod query;
11pub(crate) use production::canonical_catalog_relation_with_control;
12pub use query::{
13    bind_stored_query_relations, resolve_loaded_query_sequence, StoredQueryBindingContext,
14    StoredQueryNamespace, StoredQuerySequences,
15};
16
17use crate::{
18    ast::{Expr, Statement},
19    catalog::{
20        events::RuleDependencies,
21        resolution::{RelationLookupMode, RelationResolution},
22        stored_ast::StoredAstVisitor,
23    },
24    SQLError,
25};
26use std::collections::BTreeSet;
27use uqa_core::RelationIdentity;
28
29pub trait StoredRelationCatalog {
30    fn resolve_age_label_relation_name(&self, reference: &str) -> Result<Option<String>, SQLError>;
31    fn resolve_visible_relation_kind(
32        &self,
33        reference: &str,
34    ) -> Result<RelationResolution, SQLError>;
35    fn resolve_loaded_visible_relation_kind(
36        &self,
37        reference: &str,
38    ) -> Result<RelationResolution, SQLError>;
39    fn resolve_bound_relation_kind(&self, reference: &str) -> Result<RelationResolution, SQLError>;
40
41    fn resolve_age_label_relation_name_with_control(
42        &self,
43        reference: &str,
44        control: &uqa_core::memory::ProductionControl<'_>,
45    ) -> Result<Option<uqa_core::memory::Produced<String>>, SQLError> {
46        control.check()?;
47        self.resolve_age_label_relation_name(reference)?
48            .as_deref()
49            .map(|name| control.copy_text(name).map_err(Into::into))
50            .transpose()
51    }
52    fn resolve_visible_relation_kind_with_control(
53        &self,
54        reference: &str,
55        control: &uqa_core::memory::ProductionControl<'_>,
56    ) -> Result<uqa_core::memory::Produced<RelationResolution>, SQLError> {
57        control.check()?;
58        copy_relation_resolution(&self.resolve_visible_relation_kind(reference)?, control)
59    }
60    fn resolve_loaded_visible_relation_kind_with_control(
61        &self,
62        reference: &str,
63        control: &uqa_core::memory::ProductionControl<'_>,
64    ) -> Result<uqa_core::memory::Produced<RelationResolution>, SQLError> {
65        control.check()?;
66        copy_relation_resolution(
67            &self.resolve_loaded_visible_relation_kind(reference)?,
68            control,
69        )
70    }
71    fn resolve_bound_relation_kind_with_control(
72        &self,
73        reference: &str,
74        control: &uqa_core::memory::ProductionControl<'_>,
75    ) -> Result<uqa_core::memory::Produced<RelationResolution>, SQLError> {
76        control.check()?;
77        copy_relation_resolution(&self.resolve_bound_relation_kind(reference)?, control)
78    }
79}
80
81fn copy_relation_resolution(
82    resolution: &RelationResolution,
83    control: &uqa_core::memory::ProductionControl<'_>,
84) -> Result<uqa_core::memory::Produced<RelationResolution>, SQLError> {
85    let (resolution, memory) = match resolution {
86        RelationResolution::Found(name, kind) => {
87            let (name, memory) = control.copy_text(name)?.into_parts();
88            (RelationResolution::Found(name, kind), memory)
89        }
90        RelationResolution::MissingSchema(name) => {
91            let (name, memory) = control.copy_text(name)?.into_parts();
92            (RelationResolution::MissingSchema(name), memory)
93        }
94        RelationResolution::MissingRelation => (
95            RelationResolution::MissingRelation,
96            control.empty_reservation(),
97        ),
98    };
99    Ok(control.finish(resolution, memory)?)
100}
101
102pub(crate) fn bind_catalog_relation_reference(
103    catalog: &dyn StoredRelationCatalog,
104    reference: &mut String,
105    lookup_mode: RelationLookupMode,
106    loaded_catalog: bool,
107    context: &str,
108    dependencies: &mut BTreeSet<RelationIdentity>,
109) -> Result<(), SQLError> {
110    let (canonical, age_label) = canonical_catalog_relation_with_control(
111        catalog,
112        reference,
113        lookup_mode,
114        loaded_catalog,
115        context,
116        &uqa_core::memory::ProductionControl::uncontrolled(),
117    )?;
118    let canonical = canonical
119        .into_uncontrolled()
120        .expect("ordinary relation binding");
121    let relation = RelationIdentity::from_legacy_name(&canonical).map_err(|error| {
122        SQLError::Internal(format!("decode bound rule source `{canonical}`: {error}"))
123    })?;
124    *reference = canonical;
125    if age_label || crate::catalog::VirtualRelation::at(&relation.schema, &relation.name).is_none()
126    {
127        dependencies.insert(relation);
128    }
129    Ok(())
130}
131
132pub fn bind_rule_action_relation_dependencies(
133    catalog: &dyn StoredRelationCatalog,
134    statement: &mut Statement,
135    lookup_mode: RelationLookupMode,
136) -> Result<RuleDependencies, SQLError> {
137    let mut dependencies = BTreeSet::new();
138    let mut bind = |reference: &mut String| {
139        bind_catalog_relation_reference(
140            catalog,
141            reference,
142            lookup_mode,
143            false,
144            "CREATE RULE",
145            &mut dependencies,
146        )
147    };
148    let mut ignore_routine = |_: &mut String,
149                              _: Option<&mut Option<crate::ast::FunctionBinding>>|
150     -> Result<(), SQLError> { Ok(()) };
151    StoredAstVisitor {
152        source: None,
153        merge: None,
154        expression: None,
155        projection: None,
156        ty: None,
157        relation: &mut bind,
158        routine: &mut ignore_routine,
159    }
160    .bind_statement(statement)?;
161    Ok(RuleDependencies {
162        relations: dependencies,
163        columns: BTreeSet::new(),
164        routines: BTreeSet::new(),
165    })
166}
167
168pub fn bind_rule_condition_relation_dependencies(
169    catalog: &dyn StoredRelationCatalog,
170    expression: &mut Expr,
171    lookup_mode: RelationLookupMode,
172) -> Result<RuleDependencies, SQLError> {
173    let mut dependencies = BTreeSet::new();
174    let mut bind = |reference: &mut String| {
175        bind_catalog_relation_reference(
176            catalog,
177            reference,
178            lookup_mode,
179            false,
180            "CREATE RULE",
181            &mut dependencies,
182        )
183    };
184    let mut ignore_routine = |_: &mut String,
185                              _: Option<&mut Option<crate::ast::FunctionBinding>>|
186     -> Result<(), SQLError> { Ok(()) };
187    StoredAstVisitor {
188        source: None,
189        merge: None,
190        expression: None,
191        projection: None,
192        ty: None,
193        relation: &mut bind,
194        routine: &mut ignore_routine,
195    }
196    .bind_expr(expression, &BTreeSet::new())?;
197    Ok(RuleDependencies {
198        relations: dependencies,
199        columns: BTreeSet::new(),
200        routines: BTreeSet::new(),
201    })
202}
203
204pub fn bind_stored_statement_relations(
205    catalog: &dyn StoredRelationCatalog,
206    statement: &mut Statement,
207    lookup_mode: RelationLookupMode,
208    loaded_catalog: bool,
209    context: &str,
210) -> Result<bool, SQLError> {
211    let mut dependencies = BTreeSet::new();
212    let mut changed = false;
213    let mut bind = |reference: &mut String| {
214        let previous = reference.clone();
215        bind_catalog_relation_reference(
216            catalog,
217            reference,
218            lookup_mode,
219            loaded_catalog,
220            context,
221            &mut dependencies,
222        )?;
223        changed |= reference != &previous;
224        Ok(())
225    };
226    let mut ignore_routine = |_: &mut String,
227                              _: Option<&mut Option<crate::ast::FunctionBinding>>|
228     -> Result<(), SQLError> { Ok(()) };
229    StoredAstVisitor {
230        source: None,
231        merge: None,
232        expression: None,
233        projection: None,
234        ty: None,
235        relation: &mut bind,
236        routine: &mut ignore_routine,
237    }
238    .bind_statement(statement)?;
239    match statement {
240        Statement::Insert(insert) => {
241            changed |= !insert.target_relation_bound;
242            insert.target_relation_bound = true;
243        }
244        Statement::Update(update) => {
245            changed |= !update.target_relation_bound;
246            update.target_relation_bound = true;
247        }
248        Statement::Delete(delete) => {
249            changed |= !delete.target_relation_bound;
250            delete.target_relation_bound = true;
251        }
252        _ => {}
253    }
254    Ok(changed)
255}