Skip to main content

uqa_engine/capabilities/
stored_relations.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind stored relation analysis to catalog lookup and retained sequence registry state.
8
9use crate::Engine;
10use uqa_sql::{
11    binding::stored_relations::{
12        self as analysis, StoredQueryBindingContext, StoredQuerySequences, StoredRelationCatalog,
13    },
14    catalog::resolution::RelationResolution,
15    plan::QueryPlan,
16    SQLError,
17};
18
19impl StoredRelationCatalog for Engine {
20    fn resolve_age_label_relation_name(&self, reference: &str) -> Result<Option<String>, SQLError> {
21        uqa_execution::catalog::projection::resolve_age_label_relation_name(
22            &self.catalog_execution(),
23            reference,
24        )
25    }
26    fn resolve_visible_relation_kind(
27        &self,
28        reference: &str,
29    ) -> Result<RelationResolution, SQLError> {
30        Engine::resolve_visible_relation_kind(self, reference)
31    }
32    fn resolve_loaded_visible_relation_kind(
33        &self,
34        reference: &str,
35    ) -> Result<RelationResolution, SQLError> {
36        Engine::resolve_loaded_visible_relation_kind(self, reference)
37    }
38    fn resolve_bound_relation_kind(&self, reference: &str) -> Result<RelationResolution, SQLError> {
39        Engine::resolve_bound_relation_kind(self, reference)
40    }
41}
42impl StoredQuerySequences for Engine {
43    fn query_sequence(&self, reference: &str) -> Result<String, String> {
44        self.resolve_sequence_reference_for_binding(reference)
45            .map_err(|error| error.to_string())
46    }
47    fn loaded_query_sequence(&self, reference: &str) -> Result<String, String> {
48        let sequences = self.durable.sequences.read();
49        let candidates = self
50            .relation_lookup_candidates(reference)
51            .map_err(|error| error.to_string())?;
52        analysis::resolve_loaded_query_sequence(reference, candidates, |candidate| {
53            sequences.contains_key(candidate)
54        })
55    }
56}
57impl Engine {
58    pub(crate) fn bind_stored_query_relations(
59        &self,
60        plan: &mut QueryPlan,
61        context: &str,
62        reject_transition_relations: bool,
63    ) -> Result<bool, SQLError> {
64        let temporary_schema = self.temporary_schema_name();
65        let transition_relations =
66            uqa_execution::mutation::triggers::current_transition_relation_names();
67        analysis::bind_stored_query_relations(
68            &StoredQueryBindingContext {
69                relations: self,
70                lookup_mode: uqa_sql::catalog::resolution::RelationLookupMode::Dynamic,
71                sequences: self,
72                temporary_schema: &temporary_schema,
73                transition_relations: &transition_relations,
74            },
75            plan,
76            context,
77            reject_transition_relations,
78            false,
79        )
80    }
81}