uqa_engine/capabilities/
mutation_assignment.rs1use 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}