Skip to main content

uqa_engine/capabilities/
mutation_rows.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind mutation row metadata and expression scopes to the selected engine generation.
8use crate::session::StatementReadSnapshot;
9use crate::Engine;
10use uqa_core::DocId;
11use uqa_execution::mutation::rows::context::{
12    MutationExpressionContext, MutationRowCatalog, MutationRowContext, MutationTupleMetadata,
13};
14use uqa_sql::{ast::ColumnDef, RowSchema, SQLError};
15use uqa_storage::DocumentMetadata;
16
17impl MutationRowCatalog for Engine {
18    fn column_definitions(&self, table: &str) -> Result<Option<Vec<ColumnDef>>, String> {
19        self.describe_table_in_execution(table)
20            .map_err(|error| error.to_string())
21    }
22    fn column_names(&self, table: &str) -> Result<Vec<String>, String> {
23        self.table_columns_in_execution(table)
24            .map_err(|error| error.to_string())
25    }
26    fn visit_column_names_with_control(
27        &self,
28        table: &str,
29        control: &uqa_core::memory::ProductionControl<'_>,
30        read: &mut dyn FnMut(&str) -> Result<(), SQLError>,
31    ) -> Result<(), SQLError> {
32        self.visit_raw_table_column_names_with_control(table, control, read)
33    }
34    fn view_schema(&self, name: &str) -> Result<RowSchema, SQLError> {
35        let definition = self
36            .view_definition(name)?
37            .ok_or_else(|| SQLError::UnknownTable(name.to_string()))?;
38        self.stored_view_schema(&definition)
39    }
40}
41impl MutationTupleMetadata for Engine {
42    fn table_relation_oid(&self, table: &str) -> Result<i64, SQLError> {
43        if self.query_catalog_snapshot.is_some() {
44            return uqa_execution::catalog::projection::table_relation_oid(
45                &self.catalog_execution(),
46                table,
47            );
48        }
49        let relation = uqa_sql::catalog::resolution::bound_relation_identity(table)?;
50        let ordinary = self
51            .storage
52            .tables
53            .read()
54            .get(&relation)
55            .map(|state| state.relation_oids().relation);
56        ordinary
57            .or_else(|| {
58                self.durable
59                    .foreign_tables
60                    .read()
61                    .get(&relation)
62                    .map(|state| state.relation_oids().relation)
63            })
64            .map(i64::from)
65            .ok_or_else(|| SQLError::UnknownTable(table.to_string()))
66    }
67    fn document_metadata(
68        &self,
69        table: &str,
70        doc_id: DocId,
71    ) -> Result<Option<DocumentMetadata>, SQLError> {
72        self.get_query_document_metadata(table, doc_id)
73    }
74    fn tuple_version_xid(&self) -> Result<u32, SQLError> {
75        self.tuple_version_xid()
76    }
77}
78impl Engine {
79    pub(crate) fn mutation_row_context(&self) -> MutationRowContext<'_> {
80        MutationRowContext {
81            catalog: self.catalog_execution(),
82            relations: self,
83            tuples: self,
84        }
85    }
86    pub(crate) fn mutation_expression_context(
87        &self,
88    ) -> MutationExpressionContext<'_, StatementReadSnapshot> {
89        MutationExpressionContext {
90            types: self,
91            expressions: self,
92        }
93    }
94}