uqa_execution/schema/
view_references.rs1use super::{
9 publication::dependencies::CatalogPublicationChanges,
10 view_dependencies::{self, ViewDependencyContext},
11};
12use crate::catalog::{
13 context::CatalogContext,
14 projection,
15 view::{catalog_view_row, ViewPublication, ViewRegistryState},
16};
17use uqa_core::RelationIdentity;
18use uqa_sql::binding::view_dependencies::query_plan_references_relation;
19use uqa_storage::{StorageBackendError, StorageBackendResult};
20
21pub struct ViewReferenceContext<'a> {
22 pub registry: &'a dyn ViewRegistryState,
23 pub publication: &'a dyn ViewPublication,
24 pub changes: &'a dyn CatalogPublicationChanges,
25 pub dependencies: ViewDependencyContext<'a>,
26 pub catalog: CatalogContext<'a>,
27}
28pub fn rewrite_view_relation_references(
29 context: &ViewReferenceContext<'_>,
30 replacements: &std::collections::BTreeMap<RelationIdentity, RelationIdentity>,
31) -> StorageBackendResult<()> {
32 if replacements.is_empty() {
33 return Ok(());
34 }
35 let updates = uqa_sql::catalog::stored_view::references::rewritten_relation_references(
36 &context.registry.views_read(),
37 replacements,
38 )
39 .map_err(StorageBackendError::Other)?;
40 if context.publication.has_catalog() {
41 for (relation, view) in &updates {
42 if view.persistence != uqa_sql::ast::RelationPersistence::Temporary {
43 context
44 .publication
45 .save_view(&catalog_view_row(relation, view)?)?;
46 }
47 }
48 }
49 let mut views = context.registry.views_write();
50 for (relation, view) in updates {
51 context.changes.prepared_catalog_changed(
52 crate::statement::prepared::invalidation::PreparedCatalogChange::Relation(
53 view.relation_oids().relation,
54 ),
55 );
56 views.insert(relation, view);
57 }
58 Ok(())
59}
60pub fn views_depending_on_column(
61 context: &ViewReferenceContext<'_>,
62 table: &str,
63 column: &str,
64) -> StorageBackendResult<Vec<String>> {
65 let candidates = view_dependencies::views_depending_on_relation(&context.dependencies, table)?;
66 let views = (**context.registry.views_read()).clone();
67 let mut dependent = Vec::new();
68 for name in candidates {
69 let identity =
70 RelationIdentity::from_legacy_name(&name).map_err(StorageBackendError::Other)?;
71 if let Some(view) = views.get(&identity) {
72 if projection::view_query_references_column(
73 &context.catalog,
74 &view.query,
75 table,
76 column,
77 )
78 .map_err(|error| StorageBackendError::Other(error.to_string()))?
79 {
80 dependent.push(name);
81 }
82 }
83 }
84 Ok(dependent)
85}
86
87pub fn rewrite_view_column_references(
88 context: &ViewReferenceContext<'_>,
89 table: &str,
90 from: &str,
91 to: &str,
92) -> StorageBackendResult<()> {
93 let target = RelationIdentity::from_legacy_name(table).map_err(StorageBackendError::Other)?;
94 let mut next = (**context.registry.views_read()).clone();
95 let mut changed = Vec::new();
96 for (relation, view) in &mut next {
97 if query_plan_references_relation(&view.query, &target, &std::collections::BTreeSet::new())
98 {
99 projection::rename_view_column_query(
100 &context.catalog,
101 &mut view.query,
102 table,
103 from,
104 to,
105 )
106 .map_err(|error| StorageBackendError::Other(error.to_string()))?;
107 changed.push(relation.clone());
108 }
109 }
110 if changed.is_empty() {
111 return Ok(());
112 }
113 if context.publication.has_catalog() {
114 for relation in &changed {
115 let view = next
116 .get(relation)
117 .expect("rewritten view retained in replacement catalog");
118 if view.persistence != uqa_sql::ast::RelationPersistence::Temporary {
119 context
120 .publication
121 .save_view(&catalog_view_row(relation, view)?)?;
122 }
123 }
124 }
125 for relation in changed {
126 if let Some(view) = next.get(&relation) {
127 context.changes.prepared_catalog_changed(
128 crate::statement::prepared::invalidation::PreparedCatalogChange::Relation(
129 view.relation_oids().relation,
130 ),
131 );
132 }
133 }
134 **context.registry.views_write() = next;
135 context.changes.catalog_registry_changed();
136 Ok(())
137}