Skip to main content

uqa_engine/capabilities/
mutation_assignment.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind declared columns, routine scopes and identity state for mutation execution.
8use crate::Engine;
9use uqa_execution::mutation::{
10    assignment::MutationAssignmentContext,
11    identity::{IdentitySequences, InsertIdentityCatalog, InsertIdentityContext},
12};
13use uqa_sql::{
14    assignment::columns::{AssignmentColumnCatalog, ColumnShape},
15    ast::{AutoIncrement, ColumnDef, Expr},
16    SQLError,
17};
18impl AssignmentColumnCatalog for Engine {
19    fn try_describe_table(
20        &self,
21        table: &str,
22    ) -> Result<Option<Vec<ColumnDef>>, uqa_sql::assignment::columns::ColumnCatalogError> {
23        Engine::describe_table_in_execution(self, table)
24            .map_err(|error| Box::new(error) as uqa_sql::assignment::columns::ColumnCatalogError)
25    }
26    fn columns_declared(
27        &self,
28        table: &str,
29    ) -> Result<bool, uqa_sql::assignment::columns::ColumnCatalogError> {
30        self.try_table(table)
31            .map(|table| table.is_some_and(|table| *table.columns_declared.read()))
32            .map_err(|error| Box::new(error) as uqa_sql::assignment::columns::ColumnCatalogError)
33    }
34    fn try_column_insert_default_expr(
35        &self,
36        table: &str,
37        column: &str,
38    ) -> Result<Option<Expr>, uqa_sql::assignment::columns::ColumnCatalogError> {
39        Engine::try_column_insert_default_expr(self, table, column)
40            .map_err(|error| Box::new(error) as uqa_sql::assignment::columns::ColumnCatalogError)
41    }
42    fn try_identity_column_sequence(
43        &self,
44        table: &str,
45        column: &str,
46    ) -> Result<Option<String>, uqa_sql::SQLError> {
47        let stored = self
48            .try_table(table)
49            .map_err(|error| {
50                uqa_sql::catalog::errors::storage_error("read identity column", &error)
51            })?
52            .ok_or_else(|| uqa_sql::SQLError::UnknownTable(table.to_string()))?;
53        let columns = stored.columns.read();
54        let Some(definition) = columns.iter().find(|definition| definition.name == column) else {
55            return Ok(None);
56        };
57        uqa_sql::schema::sequences::implicit_ownership::identity_column_sequence(
58            self, table, definition,
59        )
60    }
61    fn try_column_shape(
62        &self,
63        table: &str,
64        column: &str,
65    ) -> Result<Option<Option<ColumnShape>>, uqa_sql::assignment::columns::ColumnCatalogError> {
66        let table = self
67            .try_table(table)
68            .map_err(|error| Box::new(error) as uqa_sql::assignment::columns::ColumnCatalogError)?;
69        Ok(table.map(|table| {
70            table
71                .columns
72                .read()
73                .iter()
74                .find(|definition| definition.name == column)
75                .map(|definition| ColumnShape {
76                    ty: definition.ty.clone(),
77                    generated: definition
78                        .generated
79                        .as_ref()
80                        .map(|generated| generated.kind),
81                    identity_sequence: definition
82                        .auto_increment
83                        .as_ref()
84                        .filter(|provenance| provenance.is_identity())
85                        .and_then(|provenance| provenance.sequence.clone()),
86                })
87        }))
88    }
89}
90impl InsertIdentityCatalog for Engine {
91    fn auto_increment_column(&self, table: &str) -> Result<Option<String>, String> {
92        Engine::auto_increment_column(self, table).map_err(|error| error.to_string())
93    }
94    fn auto_increment_columns(&self, table: &str) -> Result<Vec<(String, AutoIncrement)>, String> {
95        Engine::auto_increment_columns(self, table).map_err(|error| error.to_string())
96    }
97}
98impl IdentitySequences for Engine {
99    fn nextval_sql(&self, sequence: &str) -> Result<i64, SQLError> {
100        Engine::nextval_sql(self, sequence)
101    }
102}
103impl Engine {
104    pub(crate) fn mutation_assignment_context(
105        &self,
106    ) -> MutationAssignmentContext<'_, crate::session::StatementReadSnapshot> {
107        MutationAssignmentContext {
108            columns: self,
109            assignment: self,
110            rows: self.mutation_row_context(),
111            expressions: self.mutation_expression_context(),
112            scopes: self,
113        }
114    }
115    pub(crate) fn insert_identity_context(&self) -> InsertIdentityContext<'_> {
116        InsertIdentityContext {
117            catalog: self,
118            columns: self,
119            assignment: self,
120            identifiers: self,
121            sequences: self,
122            locks: self,
123            partitions: self,
124        }
125    }
126}
127
128impl Engine {
129    pub(crate) fn mutation_preparation_context(
130        &self,
131    ) -> uqa_execution::mutation::preparation::MutationPreparationContext<
132        '_,
133        crate::session::StatementReadSnapshot,
134    > {
135        uqa_execution::mutation::preparation::MutationPreparationContext {
136            referential: self.referential_execution_context(),
137            staging: self.mutation_staging_context(),
138            returning: self.returning_execution_context(),
139        }
140    }
141}