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

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

//! Bind declared columns, routine scopes and identity state for mutation execution.
use crate::Engine;
use uqa_execution::mutation::{
    assignment::MutationAssignmentContext,
    identity::{IdentitySequences, InsertIdentityCatalog, InsertIdentityContext},
};
use uqa_sql::{
    assignment::columns::AssignmentColumnCatalog,
    ast::{AutoIncrement, ColumnDef, Expr},
    SQLError,
};
impl AssignmentColumnCatalog for Engine {
    fn try_describe_table(
        &self,
        table: &str,
    ) -> Result<Option<Vec<ColumnDef>>, uqa_sql::assignment::columns::ColumnCatalogError> {
        Engine::try_describe_table(self, table)
            .map_err(|error| Box::new(error) as uqa_sql::assignment::columns::ColumnCatalogError)
    }
    fn columns_declared(
        &self,
        table: &str,
    ) -> Result<bool, uqa_sql::assignment::columns::ColumnCatalogError> {
        self.try_table(table)
            .map(|table| table.is_some_and(|table| *table.columns_declared.read()))
            .map_err(|error| Box::new(error) as uqa_sql::assignment::columns::ColumnCatalogError)
    }
    fn try_column_insert_default_expr(
        &self,
        table: &str,
        column: &str,
    ) -> Result<Option<Expr>, uqa_sql::assignment::columns::ColumnCatalogError> {
        Engine::try_column_insert_default_expr(self, table, column)
            .map_err(|error| Box::new(error) as uqa_sql::assignment::columns::ColumnCatalogError)
    }
}
impl InsertIdentityCatalog for Engine {
    fn auto_increment_column(&self, table: &str) -> Result<Option<String>, String> {
        Engine::auto_increment_column(self, table).map_err(|error| error.to_string())
    }
    fn auto_increment_columns(&self, table: &str) -> Result<Vec<(String, AutoIncrement)>, String> {
        Engine::auto_increment_columns(self, table).map_err(|error| error.to_string())
    }
}
impl IdentitySequences for Engine {
    fn nextval_sql(&self, sequence: &str) -> Result<i64, SQLError> {
        Engine::nextval_sql(self, sequence)
    }
}
impl Engine {
    pub(crate) fn mutation_assignment_context(
        &self,
    ) -> MutationAssignmentContext<'_, crate::session::StatementReadSnapshot> {
        MutationAssignmentContext {
            columns: self,
            assignment: self,
            rows: self.mutation_row_context(),
            expressions: self.mutation_expression_context(),
            scopes: self,
        }
    }
    pub(crate) fn insert_identity_context(&self) -> InsertIdentityContext<'_> {
        InsertIdentityContext {
            catalog: self,
            columns: self,
            assignment: self,
            identifiers: self,
            sequences: self,
            locks: self,
            partitions: self,
        }
    }
}

impl Engine {
    pub(crate) fn mutation_preparation_context(
        &self,
    ) -> uqa_execution::mutation::preparation::MutationPreparationContext<
        '_,
        crate::session::StatementReadSnapshot,
    > {
        uqa_execution::mutation::preparation::MutationPreparationContext {
            referential: self.referential_execution_context(),
            staging: self.mutation_staging_context(),
            returning: self.returning_execution_context(),
        }
    }
}