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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

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

//! Lend portal registry state and capture RETURNING inputs only when requested.

use crate::{session::StatementReadSnapshot, Engine};
use uqa_execution::statement::{
    context::session::StatementPortals,
    portal::{
        context::{PortalExecutionContext, PortalReturningInputs},
        SessionPortalCommandDeclaration, SessionPortalDeclaration,
    },
};
use uqa_sql::{ast::FetchCursorStmt, SQLError, SQLResult};

impl Engine {
    pub(crate) fn portal_execution_context(
        &self,
    ) -> PortalExecutionContext<'_, StatementReadSnapshot> {
        PortalExecutionContext {
            state: self,
            queries: self,
            returning: self,
            command_scopes: self,
            routines: self,
            overloads: self,
            types: self,
            session: self,
            explain: uqa_planner::explain::run_explain,
        }
    }
}

impl PortalReturningInputs<StatementReadSnapshot> for Engine {
    fn returning_execution_context(
        &self,
    ) -> uqa_execution::mutation::returning::ReturningExecutionContext<'_, StatementReadSnapshot>
    {
        Engine::returning_execution_context(self)
    }
    fn returning_analysis_context(
        &self,
    ) -> uqa_sql::semantics::returning::ReturningAnalysisContext<'_> {
        Engine::returning_analysis_context(self)
    }
}

impl StatementPortals for Engine {
    fn in_transaction_block(&self) -> bool {
        Engine::in_transaction_block(self)
    }
    fn ensure_session_portal_available(&self, name: &str) -> Result<(), SQLError> {
        Engine::ensure_session_portal_available(self, name)
    }
    fn open_pending_session_portal(
        &self,
        declaration: SessionPortalDeclaration,
    ) -> Result<(), SQLError> {
        Engine::open_pending_session_portal(self, declaration)
    }
    fn open_pending_command_session_portal(
        &self,
        declaration: SessionPortalCommandDeclaration,
    ) -> Result<(), SQLError> {
        Engine::open_pending_command_session_portal(self, declaration)
    }
    fn fetch_session_portal(&self, fetch: &FetchCursorStmt) -> Result<SQLResult, SQLError> {
        Engine::fetch_session_portal(self, fetch)
    }
    fn close_session_portal(&self, name: &str) -> Result<(), SQLError> {
        Engine::close_session_portal(self, name)
    }
    fn close_all_session_portals(&self) {
        Engine::close_all_session_portals(self);
    }
}

impl Engine {
    pub(crate) fn portal_binding_context(
        &self,
    ) -> uqa_sql::binding::portals::PortalBindingContext<'_> {
        uqa_sql::binding::portals::PortalBindingContext {
            catalog: self,
            routines: self,
            transitions: self,
        }
    }
}

impl uqa_sql::binding::portals::PortalRelationCatalog for Engine {
    fn try_resolve_table_name(&self, name: &str) -> Result<Option<String>, String> {
        Engine::try_resolve_table_name(self, name).map_err(|error| error.to_string())
    }
    fn hierarchy_scan_tables(
        &self,
        table: &str,
        include_descendants: bool,
    ) -> Result<Vec<String>, SQLError> {
        Engine::hierarchy_scan_tables(self, table, include_descendants)
    }
    fn view_plan(&self, name: &str) -> Result<Option<uqa_sql::plan::QueryPlan>, SQLError> {
        Engine::view_plan(self, name)
    }
    fn try_resolve_visible_relation_kind(
        &self,
        name: &str,
    ) -> Result<Option<(String, &'static str)>, SQLError> {
        Engine::try_resolve_visible_relation_kind(self, name)
    }
    fn resolve_age_label_relation_name(&self, name: &str) -> Result<Option<String>, SQLError> {
        uqa_execution::catalog::projection::resolve_age_label_relation_name(
            &self.catalog_execution(),
            name,
        )
    }
    fn try_resolve_sequence_reference(&self, name: &str) -> Result<Option<String>, String> {
        Engine::try_resolve_sequence_oid_reference_for_binding(self, name)
            .map_err(|error| error.to_string())
    }
}

impl uqa_sql::binding::portals::PortalTransitionRelations for Engine {
    fn active_transition_relation_names(&self) -> std::collections::BTreeSet<String> {
        uqa_execution::mutation::triggers::current_transition_relation_names()
    }
}