Skip to main content

uqa_execution/schema/
view_references.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Persist relation and column reference rewrites before publishing view registries.
8use 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}