Skip to main content

uqa_engine/capabilities/
column_rewrites.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind column rewrites to active row generations, field publication, and catalog state.
8use crate::{session::StatementReadSnapshot, Engine};
9use uqa_core::DocId;
10use uqa_execution::schema::{
11    columns::{
12        addition::deferred::AddedColumnRows,
13        backfill::{ColumnBackfillContext, ColumnBackfillState},
14        generated::{GeneratedRewriteContext, GeneratedRewriteState},
15        rows::RewriteDeferral,
16        ColumnRewriteContext,
17    },
18    keys::KeyValidationContext,
19};
20use uqa_sql::{ast::ColumnType, SQLError};
21use uqa_storage::StorageBackendResult;
22impl Engine {
23    pub(crate) fn column_rewrite_context(&self) -> ColumnRewriteContext<'_> {
24        ColumnRewriteContext {
25            cancellation: &self.runtime.cancellation,
26            columns: self,
27            reads: self,
28            types: self,
29            expressions: self,
30            writes: self,
31        }
32    }
33    pub(crate) fn column_backfill_context(&self) -> ColumnBackfillContext<'_> {
34        ColumnBackfillContext {
35            input_types: self,
36            rewrite: self.column_rewrite_context(),
37            state: self,
38            volatility: self,
39        }
40    }
41    pub(crate) fn key_validation_context(&self) -> KeyValidationContext<'_> {
42        KeyValidationContext {
43            catalog: self,
44            constraints: self.constraint_execution_context(),
45        }
46    }
47    pub(crate) fn generated_rewrite_context(
48        &self,
49    ) -> GeneratedRewriteContext<'_, StatementReadSnapshot> {
50        GeneratedRewriteContext {
51            cancellation: &self.runtime.cancellation,
52            keys: self.key_validation_context(),
53            assignment: self.mutation_assignment_context(),
54            storage: self,
55            state: self,
56            identifiers: self,
57        }
58    }
59}
60impl ColumnBackfillState for Engine {
61    fn column_type(&self, table: &str, column: &str) -> StorageBackendResult<Option<ColumnType>> {
62        Engine::column_type(self, table, column)
63    }
64    fn clear_missing_values(&self, table: &str) -> Result<(), SQLError> {
65        for definition in self.require_table(table)?.columns.write().iter_mut() {
66            definition.missing_value = None;
67        }
68        Ok(())
69    }
70}
71impl GeneratedRewriteState for Engine {
72    fn advance_next_id(&self, table: &str, id: DocId) -> StorageBackendResult<()> {
73        Engine::advance_next_id(self, table, id)
74    }
75}
76
77impl Engine {
78    pub(crate) fn column_addition_context(
79        &self,
80    ) -> uqa_execution::schema::columns::addition::ColumnAdditionContext<'_, StatementReadSnapshot>
81    {
82        uqa_execution::schema::columns::addition::ColumnAdditionContext {
83            pending_rows: AddedColumnRows::default(),
84            analysis: uqa_sql::schema::columns::addition::AddedColumnAnalysisContext {
85                keys: self,
86                schema: self,
87                bindings: self,
88                foreign_keys: self.foreign_key_definition_context(),
89            },
90            namespace: self.relation_creation_context(),
91            sequences: self.implicit_sequence_context(),
92            ownership: self.implicit_ownership_context(),
93            state: self,
94            transactions: self,
95            generated: self.generated_rewrite_context(),
96            backfill: self.column_backfill_context(),
97        }
98    }
99}
100impl uqa_sql::schema::columns::addition::AddedColumnKeys for Engine {
101    fn try_key_constraints(
102        &self,
103        table: &str,
104    ) -> Result<
105        Vec<uqa_sql::ast::TableKeyConstraint>,
106        uqa_sql::assignment::columns::ColumnCatalogError,
107    > {
108        Engine::key_constraints_in_execution(self, table).map_err(|error| Box::new(error) as _)
109    }
110    fn try_foreign_keys(
111        &self,
112        table: &str,
113    ) -> Result<Vec<uqa_sql::ast::ForeignKey>, uqa_sql::assignment::columns::ColumnCatalogError>
114    {
115        Engine::foreign_keys_in_execution(self, table).map_err(|error| Box::new(error) as _)
116    }
117}
118
119impl uqa_execution::schema::columns::addition::ColumnAdditionState for Engine {
120    fn has_column(&self, table: &str, column: &str) -> StorageBackendResult<bool> {
121        self.table_has_column_in_execution(table, column)
122    }
123    fn create_vector_field(
124        &self,
125        table: &str,
126        column: String,
127        dimensions: u32,
128    ) -> StorageBackendResult<bool> {
129        Engine::create_vector_field(self, table, column, dimensions)
130    }
131    fn add_text_field(&self, table: &str, column: String) -> Result<(), SQLError> {
132        self.add_fts_field(table, column)
133            .map_err(|error| match self.runtime.cancellation.check() {
134                Err(cancelled) => SQLError::Cancelled(cancelled),
135                Ok(()) => SQLError::Internal(format!("add_fts_field: {error}")),
136            })
137    }
138    fn set_missing_value(
139        &self,
140        table: &str,
141        column: &str,
142        value: Option<uqa_core::Value>,
143    ) -> Result<(), SQLError> {
144        let state = self.require_table(table)?;
145        let mut columns = state.columns.write();
146        let definition = columns
147            .iter_mut()
148            .find(|definition| definition.name == column)
149            .ok_or_else(|| {
150                SQLError::Internal(format!(
151                    "new column `{column}` disappeared during ALTER TABLE"
152                ))
153            })?;
154        definition.missing_value = value;
155        Ok(())
156    }
157    fn persist_schema(&self, table: &str) -> StorageBackendResult<bool> {
158        self.try_persist_table_schema(table)
159    }
160}
161
162impl Engine {
163    pub(crate) fn column_alter_context(
164        &self,
165    ) -> uqa_execution::schema::columns::alteration::ColumnAlterContext<'_, StatementReadSnapshot>
166    {
167        uqa_execution::schema::columns::alteration::ColumnAlterContext {
168            deferred_rows: RewriteDeferral::default(),
169            analysis: uqa_sql::schema::columns::alteration::ColumnAlterAnalysisContext {
170                columns: self,
171                keys: self,
172                state: self,
173                bindings: self.schema_dependency_binding_context(),
174                constraint_types: self.constraint_type_context(),
175            },
176            fields: self,
177            indexes: self,
178            transactions: self,
179            generated: self.generated_rewrite_context(),
180            rewrite: self.column_rewrite_context(),
181        }
182    }
183}
184impl uqa_sql::schema::columns::alteration::ColumnChangeCatalog for Engine {
185    fn has_column(
186        &self,
187        table: &str,
188        column: &str,
189    ) -> Result<bool, uqa_sql::assignment::columns::ColumnCatalogError> {
190        self.table_has_column_in_execution(table, column)
191            .map_err(|error| Box::new(error) as _)
192    }
193    fn column_type(
194        &self,
195        table: &str,
196        column: &str,
197    ) -> Result<Option<ColumnType>, uqa_sql::assignment::columns::ColumnCatalogError> {
198        Engine::column_type(self, table, column).map_err(|error| Box::new(error) as _)
199    }
200    fn stored_columns(
201        &self,
202        table: &str,
203    ) -> Result<Vec<uqa_sql::ast::ColumnDef>, uqa_sql::assignment::columns::ColumnCatalogError>
204    {
205        let state = self
206            .table_entries()
207            .into_iter()
208            .find(|(name, _)| name == table)
209            .map(|(_, state)| state)
210            .ok_or_else(|| {
211                uqa_storage::StorageBackendError::Other(format!("table `{table}` does not exist"))
212            })?;
213        let columns = state.columns.read().clone();
214        Ok(columns)
215    }
216}
217impl uqa_execution::schema::columns::alteration::ColumnIndexChanges for Engine {
218    fn drop_vector_indexes(&self, table: &str, column: &str) -> StorageBackendResult<bool> {
219        self.try_drop_vector_indexes_for_column(table, column)
220    }
221    fn prepare_vector_rewrite(
222        &self,
223        table: &str,
224        column: &str,
225        dimensions: u32,
226    ) -> StorageBackendResult<()> {
227        self.with_implicit_storage_transaction(|engine| {
228            engine.prepare_vector_column_rewrite(table, column, dimensions)
229        })
230    }
231    fn rebuild_vector_index(
232        &self,
233        table: &str,
234        column: &str,
235        dimensions: u32,
236    ) -> StorageBackendResult<bool> {
237        self.try_rebuild_vector_index_for_column(table, column, dimensions)
238    }
239}