uqa-engine 0.3.0

Engine: schema-aware table store, catalog restore, transactions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Bind stored relation analysis to catalog lookup and retained sequence registry state.

use crate::Engine;
use uqa_sql::{
    binding::stored_relations::{
        self as analysis, StoredQueryBindingContext, StoredQuerySequences, StoredRelationCatalog,
    },
    catalog::resolution::RelationResolution,
    plan::QueryPlan,
    SQLError,
};

impl StoredRelationCatalog for Engine {
    fn resolve_age_label_relation_name(&self, reference: &str) -> Result<Option<String>, SQLError> {
        uqa_execution::catalog::projection::resolve_age_label_relation_name(
            &self.catalog_execution(),
            reference,
        )
    }
    fn resolve_visible_relation_kind(
        &self,
        reference: &str,
    ) -> Result<RelationResolution, SQLError> {
        Engine::resolve_visible_relation_kind(self, reference)
    }
    fn resolve_loaded_visible_relation_kind(
        &self,
        reference: &str,
    ) -> Result<RelationResolution, SQLError> {
        Engine::resolve_loaded_visible_relation_kind(self, reference)
    }
    fn resolve_bound_relation_kind(&self, reference: &str) -> Result<RelationResolution, SQLError> {
        Engine::resolve_bound_relation_kind(self, reference)
    }
}
impl StoredQuerySequences for Engine {
    fn query_sequence(&self, reference: &str) -> Result<String, String> {
        self.resolve_sequence_reference_for_binding(reference)
            .map_err(|error| error.to_string())
    }
    fn loaded_query_sequence(&self, reference: &str) -> Result<String, String> {
        let sequences = self.durable.sequences.read();
        let candidates = self
            .relation_lookup_candidates(reference)
            .map_err(|error| error.to_string())?;
        analysis::resolve_loaded_query_sequence(reference, candidates, |candidate| {
            sequences.contains_key(candidate)
        })
    }
}
impl Engine {
    pub(crate) fn bind_stored_query_relations(
        &self,
        plan: &mut QueryPlan,
        context: &str,
        reject_transition_relations: bool,
    ) -> Result<bool, SQLError> {
        let temporary_schema = self.temporary_schema_name();
        let transition_relations =
            uqa_execution::mutation::triggers::current_transition_relation_names();
        analysis::bind_stored_query_relations(
            &StoredQueryBindingContext {
                relations: self,
                sequences: self,
                temporary_schema: &temporary_schema,
                transition_relations: &transition_relations,
            },
            plan,
            context,
            reject_transition_relations,
            false,
        )
    }
}