1use super::{
10 table_next_id_metadata_key, table_not_found, Engine, RelationIdentity, StorageBackendError,
11 StorageBackendResult,
12};
13use crate::VectorIndexSpec;
14
15impl Engine {
16 pub fn register_column(
20 &self,
21 table: &str,
22 column: uqa_sql::ast::ColumnDef,
23 ) -> StorageBackendResult<()> {
24 self.try_register_column(table, column)
25 }
26
27 pub(crate) fn try_register_column(
28 &self,
29 table: &str,
30 column: uqa_sql::ast::ColumnDef,
31 ) -> StorageBackendResult<()> {
32 self.with_implicit_storage_definition_transaction(|engine| {
33 engine.try_register_column_inner(table, column, None)
34 })
35 }
36
37 pub(super) fn try_register_column_inner(
38 &self,
39 table: &str,
40 column: uqa_sql::ast::ColumnDef,
41 check_columns: Option<&[uqa_sql::ast::ColumnDef]>,
42 ) -> StorageBackendResult<()> {
43 uqa_execution::schema::publication::register_column(
44 &self.schema_publication_context(),
45 table,
46 column,
47 check_columns,
48 &[],
49 )
50 }
51
52 pub fn drop_column(&self, table: &str, column: &str) -> StorageBackendResult<bool> {
54 use uqa_execution::schema::columns::deletion::ColumnDrop;
55 use uqa_execution::schema::deletion::CatalogRemovalInputs;
56 self.with_implicit_definition_transaction(|engine| {
57 let Some(canonical) = engine
58 .resolve_table_ddl_target(table, "ALTER TABLE DROP COLUMN")
59 .map_err(|error| uqa_sql::SQLError::Internal(error.to_string()))?
60 else {
61 return Ok(false);
62 };
63 let outcome = uqa_execution::schema::columns::deletion::drop_column(
64 &engine.catalog_removal_context(),
65 &canonical,
66 column,
67 (true, false, true),
68 &mut |_| {
69 Err(uqa_sql::SQLError::Internal(
70 "a recursive column drop keeps no inherited copy".into(),
71 ))
72 },
73 )?;
74 Ok(matches!(outcome, ColumnDrop::Dropped))
75 })
76 .map_err(|error| {
77 uqa_storage::StorageBackendError::backend("ALTER TABLE DROP COLUMN", error)
78 })
79 }
80
81 pub(crate) fn try_drop_vector_indexes_for_column(
82 &self,
83 table: &str,
84 column: &str,
85 ) -> StorageBackendResult<bool> {
86 self.with_implicit_storage_transaction(|engine| {
87 engine.try_drop_vector_indexes_for_column_inner(table, column)
88 })
89 }
90
91 pub(super) fn try_drop_vector_indexes_for_column_inner(
92 &self,
93 table: &str,
94 column: &str,
95 ) -> StorageBackendResult<bool> {
96 let Some(table_name) = self.resolve_table_ddl_target(table, "ALTER TABLE ALTER COLUMN")?
97 else {
98 return Ok(false);
99 };
100 uqa_execution::catalog::index::vectors::remove_for_column_conversion(
101 &self.index_registry_context(),
102 &table_name,
103 column,
104 || {
105 let state = self
106 .try_table(&table_name)?
107 .ok_or_else(|| table_not_found(&table_name))?;
108 let dimensions = state
109 .vector_indexes
110 .read()
111 .get(column)
112 .map(uqa_storage::VectorIndex::dimensions);
113 if let Some(dimensions) = dimensions {
114 self.prepare_vector_column_rewrite(&table_name, column, dimensions)?;
115 state.vector_indexes.write().live_mut()?.remove(column);
116 }
117 self.try_save_table_schema(&table_name, &state)
118 },
119 )?;
120 Ok(true)
121 }
122
123 pub(crate) fn prepare_vector_column_rewrite(
124 &self,
125 table: &str,
126 column: &str,
127 dimensions: u32,
128 ) -> StorageBackendResult<()> {
129 let table_name = self
130 .try_resolve_table_name(table)?
131 .ok_or_else(|| table_not_found(table))?;
132 let state = self
133 .try_table(&table_name)?
134 .ok_or_else(|| table_not_found(&table_name))?;
135 uqa_execution::schema::indexes::diskann::retire_column(
136 &self.index_registry_context(),
137 &table_name,
138 column,
139 )?;
140 let canonical = self.build_vector_index_with_mode(
141 &table_name,
142 column,
143 dimensions,
144 VectorIndexSpec::BruteForce,
145 uqa_storage::VectorIndexOpenMode::Create,
146 )?;
147 uqa_execution::catalog::index::vectors::prepare_column_rewrite(
148 &mut state.vector_indexes.write(),
149 column,
150 canonical,
151 )?;
152 Ok(())
153 }
154
155 pub(crate) fn try_rebuild_vector_index_for_column(
156 &self,
157 table: &str,
158 column: &str,
159 dimensions: u32,
160 ) -> StorageBackendResult<bool> {
161 self.with_implicit_storage_transaction(|engine| {
162 engine.try_rebuild_vector_index_for_column_inner(table, column, dimensions)
163 })
164 }
165
166 pub(super) fn try_rebuild_vector_index_for_column_inner(
167 &self,
168 table: &str,
169 column: &str,
170 dimensions: u32,
171 ) -> StorageBackendResult<bool> {
172 let table_name = self
173 .try_resolve_table_name(table)?
174 .ok_or_else(|| table_not_found(table))?;
175 let spec = self
176 .vector_index_spec_for_column(&table_name, column, dimensions)?
177 .unwrap_or(VectorIndexSpec::BruteForce);
178 let t = self
179 .try_table(&table_name)?
180 .ok_or_else(|| table_not_found(&table_name))?;
181 self.try_save_table_schema(&table_name, &t)?;
182 if uqa_execution::schema::indexes::diskann::create_column(
183 &self.index_registry_context(),
184 &table_name,
185 column,
186 )? {
187 return Ok(true);
188 }
189 let rebuilt = self.rebuild_vector_field_with_spec(&table_name, column, dimensions, spec)?;
190 if !rebuilt {
191 return Err(StorageBackendError::Other(format!(
192 "failed to rebuild vector index for `{table_name}`.`{column}`"
193 )));
194 }
195 Ok(true)
196 }
197
198 pub fn rename_column(&self, table: &str, from: &str, to: &str) -> StorageBackendResult<bool> {
199 self.try_rename_column(table, from, to)
200 }
201
202 pub(crate) fn try_rename_column(
203 &self,
204 table: &str,
205 from: &str,
206 to: &str,
207 ) -> StorageBackendResult<bool> {
208 self.with_implicit_storage_definition_transaction(|engine| {
209 engine.try_rename_column_inner(table, from, to)
210 })
211 }
212
213 fn rename_column_acl(table: &super::TableState, from: &str, to: &str) {
214 if from == to {
215 return;
216 }
217 let mut security = table.security.write();
218 security.rename_column_acl(from, to);
219 }
220
221 fn rename_column_analyzer_assignments(&self, table_name: &str, from: &str, to: &str) {
222 let mut analyzers = self.durable.table_field_analyzers.write();
223 let mut moved = Vec::new();
224 analyzers.retain(|(table, field), value| {
225 if table == table_name && field == from {
226 moved.push(((table_name.to_string(), to.to_string()), value.clone()));
227 false
228 } else {
229 true
230 }
231 });
232 analyzers.extend(moved);
233 }
234
235 fn rename_document_fields(
236 &self,
237 table_name: &str,
238 table: &super::TableState,
239 from: &str,
240 to: &str,
241 ) -> StorageBackendResult<()> {
242 let ids = table.document_store.read().doc_ids()?;
243 for doc_id in ids {
244 let Some(mut doc) = table.document_store.read().get(doc_id)? else {
245 continue;
246 };
247 if let Some(value) = doc.remove(from) {
248 doc.insert(to.to_string(), value);
249 self.rewrite_document_for_schema_change(table_name, doc_id, doc)
250 .map_err(|err| StorageBackendError::Other(err.to_string()))?;
251 }
252 }
253 Ok(())
254 }
255
256 fn bind_renamed_vector_field(
257 &self,
258 table: &str,
259 field: &str,
260 dimensions: u32,
261 restore: bool,
262 ) -> StorageBackendResult<()> {
263 let Some(spec) = self.vector_index_spec_for_column(table, field, dimensions)? else {
264 return Ok(());
265 };
266 let bound = if restore {
267 self.restore_vector_field_index(table, field, dimensions, spec)?
268 } else {
269 self.rebuild_vector_field_with_spec(table, field, dimensions, spec)?
270 };
271 if !bound {
272 return Err(StorageBackendError::Other(format!(
273 "failed to bind renamed vector index for `{table}`.`{field}`"
274 )));
275 }
276 Ok(())
277 }
278
279 pub(super) fn try_rename_column_inner(
280 &self,
281 table: &str,
282 from: &str,
283 to: &str,
284 ) -> StorageBackendResult<bool> {
285 let Some(table_name) = self.resolve_table_ddl_target(table, "ALTER TABLE RENAME COLUMN")?
286 else {
287 return Ok(false);
288 };
289 let Some(t) = self.try_table(table)? else {
290 return Ok(false);
291 };
292 {
293 let columns = t.columns.read();
294 if !columns.iter().any(|candidate| candidate.name == from) {
295 return Ok(false);
296 }
297 if from != to && columns.iter().any(|candidate| candidate.name == to) {
298 return Ok(false);
299 }
300 }
301 let analyzer_binding = if from != to && t.fts_fields().iter().any(|field| field == from) {
302 Some(self.current_field_analyzer_binding(&table_name, &t, from)?)
303 } else {
304 None
305 };
306 self.rewrite_column_rename_dependencies(&table_name, from, to)?;
307 Self::value_indexes_clear(&t);
308 uqa_sql::schema::columns::publication::rename_column(&mut t.columns.write(), from, to);
309 Self::rename_column_acl(&t, from, to);
310 uqa_sql::schema::columns::publication::rename_local_column(
311 &mut t.hierarchy.write(),
312 from,
313 to,
314 );
315 for constraint in t.key_constraints.write().iter_mut() {
316 for column in constraint
317 .columns
318 .iter_mut()
319 .chain(&mut constraint.included_columns)
320 {
321 if column == from {
322 *column = to.to_string();
323 }
324 }
325 }
326 {
327 let mut fts = t.fts_fields.write();
328 for f in fts.iter_mut() {
329 if f == from {
330 *f = to.to_string();
331 }
332 }
333 }
334 if let Some(binding) = &analyzer_binding {
336 binding.install(to, t.inverted_index.write().as_mut())?;
337 }
338 self.rename_column_analyzer_assignments(&table_name, from, to);
339 let vector_rename = uqa_execution::catalog::index::vectors::detach_for_column_rename(
340 &mut t.vector_indexes.write(),
341 from,
342 )?;
343 let vector_dimensions = vector_rename.as_ref().map(|rename| rename.dimensions);
344 let retained_vector = vector_rename.and_then(|rename| rename.retained);
345 let restore_vector = retained_vector.is_some();
346 self.rename_document_fields(&table_name, &t, from, to)?;
347 if analyzer_binding.is_some() {
348 t.inverted_index
349 .write()
350 .remove_field_analyzers(from)
351 .map_err(StorageBackendError::Other)?;
352 }
353 if let Some(index) = retained_vector {
354 t.vector_indexes
355 .write()
356 .live_mut()?
357 .insert(to.into(), index);
358 } else if let Some(dimensions) = vector_dimensions {
359 self.create_vector_field(&table_name, to, dimensions)?;
360 }
361 self.rename_catalog_index_column_refs(&table_name, from, to)?;
362 if self.is_persistent() {
363 if let Some(catalog) = self.storage.catalog.as_ref() {
364 catalog.rename_column_data(&table_name, from, to)?;
365 }
366 self.try_save_table_schema(&table_name, &t)?;
367 if let Some(dimensions) = vector_dimensions {
368 self.bind_renamed_vector_field(&table_name, to, dimensions, restore_vector)?;
369 }
370 }
371 let relation = Self::resolved_relation_identity(&table_name)?;
372 self.rewrite_routine_column_references(&relation, from, to)
373 .map_err(|error| {
374 StorageBackendError::Other(format!("rewrite routine column references: {error}"))
375 })?;
376 self.event_lifecycle_context()
377 .rename_event_column_inner(&table_name, from, to)?;
378 self.mark_column_stats_dirty(&table_name, &t)?;
379 self.refresh_value_indexes_for_table(&table_name)?;
380 self.note_prepared_table_change(&t);
381 Ok(true)
382 }
383
384 pub fn rename_table(&self, from: &str, to: &str) -> StorageBackendResult<bool> {
385 self.try_rename_table(from, to)
386 }
387
388 pub(crate) fn try_rename_table(&self, from: &str, to: &str) -> StorageBackendResult<bool> {
389 self.with_implicit_storage_definition_transaction(|engine| {
390 engine.try_rename_table_inner(from, to)
391 })
392 }
393
394 fn reserve_table_array_rename(
395 &self,
396 from: &RelationIdentity,
397 to: &RelationIdentity,
398 ) -> StorageBackendResult<Option<String>> {
399 let state = self
400 .require_table(&from.qualified_name())
401 .map_err(|error| StorageBackendError::backend("ALTER TABLE array type", error))?;
402 let recorded_array = state.row_type_array_name.read().clone();
403 uqa_execution::schema::types::relation_arrays::rename(
404 &self.relation_creation_context(),
405 from,
406 to,
407 recorded_array.as_deref(),
408 state.relation_oids().array_type,
409 )
410 .map_err(|error| StorageBackendError::backend("ALTER TABLE array type", error))
411 }
412
413 pub(crate) fn try_rename_table_inner(
415 &self,
416 from: &str,
417 to: &str,
418 ) -> StorageBackendResult<bool> {
419 let Some(from) = self.resolve_table_ddl_target(from, "ALTER TABLE RENAME")? else {
420 return Ok(false);
421 };
422 let from_relation = Self::resolved_relation_identity(&from)?;
423 let (target_schema, target_name) =
424 RelationIdentity::parse_reference(to).map_err(StorageBackendError::Other)?;
425 let to_relation = RelationIdentity::new(
426 target_schema.unwrap_or_else(|| from_relation.schema.clone()),
427 target_name,
428 );
429 if to_relation.schema != self.temporary_schema_name()
430 && !self
431 .durable
432 .schemas
433 .read()
434 .contains_key(&to_relation.schema)
435 {
436 return Err(StorageBackendError::Other(format!(
437 "schema `{}` does not exist",
438 to_relation.schema
439 )));
440 }
441 let to = to_relation.qualified_name();
442 if let Some(kind) = self.relation_kind_at(&to)? {
443 return Err(StorageBackendError::Other(format!(
444 "relation `{to}` already exists as {kind}"
445 )));
446 }
447 let array_name = self.reserve_table_array_rename(&from_relation, &to_relation)?;
448 let persist_catalog = {
449 let tables = self.storage.tables.read();
450 if !tables.contains_key(&from_relation) || tables.contains_key(&to_relation) {
451 return Ok(false);
452 }
453 self.is_persistent()
454 && tables.get(&from_relation).is_some_and(|table| {
455 table.persistence != uqa_sql::ast::RelationPersistence::Temporary
456 })
457 };
458 self.rewrite_table_rename_dependencies(&from, &to)?;
459 if persist_catalog {
460 if let Some(catalog) = self.storage.catalog.as_ref() {
461 catalog.rename_table_data(&from, &to)?;
462 }
463 }
464 let mut tables = self.storage.tables.write();
465 if tables.contains_key(&to_relation) {
466 return Ok(false);
467 }
468 let Some(state) = tables.remove(&from_relation) else {
469 return Ok(false);
470 };
471 tables.insert(to_relation.clone(), state.clone());
472 drop(tables);
473 *state.row_type_array_name.write() = array_name;
474 self.rewrite_relation_rename_dependents(&from_relation, &to_relation)?;
475 self.rename_catalog_index_table_refs(&from, &to);
476 {
477 let mut analyzers = self.durable.table_field_analyzers.write();
478 let mut moved = Vec::new();
479 analyzers.retain(|(table, field), value| {
480 if table == &from {
481 moved.push(((to.clone(), field.clone()), value.clone()));
482 false
483 } else {
484 true
485 }
486 });
487 analyzers.extend(moved);
488 }
489 if persist_catalog {
490 self.rebind_persistent_table_stores(&to, &state)?;
491 self.try_save_table_schema(&to, &state)?;
492 if state.columns.read().iter().any(|column| {
493 column
494 .auto_increment
495 .as_ref()
496 .is_some_and(uqa_sql::ast::AutoIncrement::is_legacy)
497 }) {
498 self.persist_next_id(&to)?;
499 }
500 if let Some(catalog) = self.storage.catalog.as_ref() {
501 catalog.set_metadata(&table_next_id_metadata_key(&from), "")?;
502 }
503 }
504 self.mark_column_stats_dirty(&to, &state)?;
505 self.refresh_value_indexes_for_table(&to)?;
506 self.rename_constraint_transaction_relation(&from_relation, &to_relation);
507 self.note_prepared_table_change(&state);
508 self.clear_regtype_output_cache();
509 Ok(true)
510 }
511}