Skip to main content

uqa_engine/session/
views.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind public view lookups to the active catalog and session namespace.
8
9use super::{Engine, SQLError, StoredView, StoredViewKind};
10#[cfg(test)]
11use super::{QueryPlan, StorageBackendError, StorageBackendResult};
12#[cfg(test)]
13use uqa_sql::binding::view_dependencies::restoration::bind_stored_view_relations;
14#[cfg(test)]
15use uqa_storage::RelationIdentity;
16
17impl Engine {
18    #[cfg(test)]
19    pub(super) fn bind_stored_view_plan(
20        &self,
21        plan: &mut QueryPlan,
22        relations: &std::collections::BTreeSet<RelationIdentity>,
23    ) -> StorageBackendResult<()> {
24        bind_stored_view_relations(plan, relations).map_err(StorageBackendError::Other)?;
25        let mut refreshed = false;
26        uqa_sql::binding::view_dependencies::bind_query_plan_sequence_references(
27            plan,
28            &mut |reference| {
29                if !refreshed {
30                    self.refresh_sequences_from_catalog()?;
31                    refreshed = true;
32                }
33                self.resolve_stored_sequence_reference_from_loaded_registry(reference)
34            },
35        )
36    }
37
38    pub(crate) fn stored_view_schema(
39        &self,
40        view: &StoredView,
41    ) -> Result<uqa_execution::RowSchema, SQLError> {
42        self.stored_view_schema_with_catalog(
43            view,
44            self.restored_catalog_read_view(),
45            self.session_execution_view().relation_name_resolution(),
46        )
47    }
48
49    pub(crate) fn stored_view_schema_with_catalog(
50        &self,
51        view: &StoredView,
52        catalog: crate::capabilities::CatalogReadView,
53        resolution: crate::capabilities::RelationNameResolution,
54    ) -> Result<uqa_execution::RowSchema, SQLError> {
55        view.row_schema(self, std::sync::Arc::new(catalog), resolution)
56    }
57
58    pub(crate) fn view_schema(
59        &self,
60        name: &str,
61    ) -> Result<Option<uqa_execution::RowSchema>, SQLError> {
62        self.with_view_definition(name, |view| self.stored_view_schema(view))?
63            .transpose()
64    }
65
66    pub(crate) fn view_definition(&self, name: &str) -> Result<Option<StoredView>, SQLError> {
67        self.with_view_definition(name, Clone::clone)
68    }
69
70    /// Select the existing immutable catalog owner, then lend the definition without holding a registry lock through the reader.
71    pub(crate) fn with_view_definition<R>(
72        &self,
73        name: &str,
74        read: impl FnOnce(&StoredView) -> R,
75    ) -> Result<Option<R>, SQLError> {
76        let Some(resolved) = self
77            .try_resolve_view_name(name)
78            .map_err(|err| SQLError::Internal(format!("refresh view catalog: {err}")))?
79        else {
80            return Ok(None);
81        };
82        let relation = Self::resolved_relation_identity(&resolved)
83            .map_err(|err| SQLError::Internal(format!("resolve view `{resolved}`: {err}")))?;
84        let snapshot = self
85            .query_view_snapshots
86            .clone()
87            .unwrap_or_else(|| self.durable.views.snapshot());
88        Ok(snapshot.get(&relation).map(read))
89    }
90
91    /// Resolve a view only against the live restored registry without starting another registry synchronization pass.
92    pub(crate) fn restored_catalog_view_definition(
93        &self,
94        name: &str,
95    ) -> Result<Option<StoredView>, SQLError> {
96        let views = self.durable.views.read();
97        Ok(self
98            .relation_lookup_candidates(name)
99            .map_err(|error| {
100                SQLError::Internal(format!("resolve restored view `{name}`: {error}"))
101            })?
102            .into_iter()
103            .find_map(|relation| views.get(&relation).cloned()))
104    }
105
106    pub fn view(&self, name: &str) -> Result<Option<uqa_planner::QueryPlan>, SQLError> {
107        self.with_direct_read_snapshot(|engine| engine.view_plan(name))
108    }
109
110    pub(crate) fn view_plan(&self, name: &str) -> Result<Option<uqa_planner::QueryPlan>, SQLError> {
111        Ok(self
112            .with_view_definition(name, |definition| {
113                (definition.kind == StoredViewKind::View)
114                    .then(|| definition.definition.query.clone())
115            })?
116            .flatten())
117    }
118
119    pub fn list_views(&self) -> Result<Vec<String>, SQLError> {
120        self.with_direct_read_snapshot(|engine| {
121            engine
122                .synchronize_catalog_registries()
123                .map_err(|err| SQLError::Internal(format!("refresh view catalog: {err}")))?;
124            let mut out: Vec<String> = engine
125                .durable
126                .views
127                .read()
128                .iter()
129                .filter(|(_, view)| view.kind == StoredViewKind::View)
130                .map(|(relation, _)| relation.qualified_name())
131                .collect();
132            out.sort_unstable();
133            Ok(out)
134        })
135    }
136}