1use 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}