uqa_execution/schema/sequences/
dependencies.rs1use 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
87pub(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}