Skip to main content

uqa_execution/schema/sequences/
dependencies.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Persist sequence-reference rewrites across retained table, foreign-table, and view catalogs.
8use crate::schema::publication::dependencies::{
9    CatalogPublicationChanges, SchemaDependencyPublicationContext,
10};
11use std::{collections::BTreeMap, ops::Deref};
12use uqa_core::RelationIdentity;
13use uqa_sql::catalog::stored_view::StoredView;
14use uqa_sql::schema::sequences::dependencies::{
15    rewrite_sequence_schema_references, rewritten_view_sequence_references,
16};
17use uqa_storage::{StorageBackendError, StorageBackendResult};
18
19pub fn rewrite_sequence_schema_dependencies(
20    context: &SchemaDependencyPublicationContext<'_>,
21    from: &RelationIdentity,
22    to: &str,
23) -> StorageBackendResult<()> {
24    let mut table_updates = Vec::new();
25    for (_, state) in context.tables.table_schemas() {
26        let mut columns = state.columns();
27        let mut constraints = state.dependency_constraints();
28        if rewrite_sequence_schema_references(&mut columns, &mut constraints.checks, from, to)
29            .map_err(StorageBackendError::Other)?
30        {
31            table_updates.push((state, columns, constraints));
32        }
33    }
34    let mut foreign_updates = Vec::new();
35    for (relation, mut table) in context.foreign.foreign_tables() {
36        if rewrite_sequence_schema_references(&mut table.columns, &mut table.checks, from, to)
37            .map_err(StorageBackendError::Other)?
38        {
39            foreign_updates.push((relation, table));
40        }
41    }
42    for (state, columns, constraints) in &mut table_updates {
43        constraints.columns_declared = Some(state.columns_declared());
44        state.persist_candidate(columns, constraints)?;
45    }
46    for (relation, table) in &foreign_updates {
47        context.foreign.persist_foreign_table(relation, table)?;
48    }
49    for (state, columns, constraints) in &table_updates {
50        state.publish_expressions(columns, &constraints.checks);
51    }
52    let foreign_tables_changed = !foreign_updates.is_empty();
53    if foreign_tables_changed {
54        context.foreign.publish_foreign_tables(foreign_updates);
55    }
56    if !table_updates.is_empty() {
57        context.changes.table_catalog_changed();
58    }
59    if foreign_tables_changed {
60        context.changes.catalog_registry_changed();
61    }
62    Ok(())
63}
64
65pub type ViewDefinitionsRead<'a> =
66    Box<dyn Deref<Target = BTreeMap<RelationIdentity, StoredView>> + 'a>;
67pub trait ViewCatalogPublication {
68    fn synchronize_catalog(&self) -> StorageBackendResult<()>;
69    fn view_definitions(&self) -> ViewDefinitionsRead<'_>;
70    fn has_catalog(&self) -> bool;
71    fn save_view_row(&self, row: &uqa_storage::ViewRow) -> StorageBackendResult<()>;
72    fn publish_views(&self, updates: Vec<(RelationIdentity, StoredView)>);
73}
74pub struct ViewSequenceRewriteContext<'a> {
75    pub views: &'a dyn ViewCatalogPublication,
76    pub changes: &'a dyn CatalogPublicationChanges,
77}
78pub fn rewrite_view_sequence_references(
79    context: &ViewSequenceRewriteContext<'_>,
80    from: &RelationIdentity,
81    to: &str,
82) -> StorageBackendResult<()> {
83    context.views.synchronize_catalog()?;
84    rewrite_loaded_view_sequence_references(context, from, to)
85}
86
87/// Rewrite the already synchronized catalog while a locked relocation is being published.
88pub(super) fn rewrite_loaded_view_sequence_references(
89    context: &ViewSequenceRewriteContext<'_>,
90    from: &RelationIdentity,
91    to: &str,
92) -> StorageBackendResult<()> {
93    let mut rewritten_views = Vec::new();
94    let views = context.views.view_definitions();
95    for (relation, stored) in views.iter() {
96        if let Some(rewritten) = rewritten_view_sequence_references(stored, from, to)
97            .map_err(StorageBackendError::Other)?
98        {
99            rewritten_views.push((relation.clone(), rewritten));
100        }
101    }
102    drop(views);
103    if context.views.has_catalog() {
104        for (relation, view) in &rewritten_views {
105            if view.persistence != uqa_sql::ast::RelationPersistence::Temporary {
106                context
107                    .views
108                    .save_view_row(&crate::catalog::view::catalog_view_row(relation, view)?)?;
109            }
110        }
111    }
112    if !rewritten_views.is_empty() {
113        context.views.publish_views(rewritten_views);
114        context.changes.catalog_registry_changed();
115    }
116    Ok(())
117}