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, RelationIdentity, StorageBackendError, StorageBackendResult};
12#[cfg(test)]
13use uqa_sql::binding::view_dependencies::restoration::bind_stored_view_relations;
14
15impl Engine {
16    #[cfg(test)]
17    pub(super) fn bind_stored_view_plan(
18        &self,
19        plan: &mut QueryPlan,
20        relations: &std::collections::BTreeSet<RelationIdentity>,
21    ) -> StorageBackendResult<()> {
22        bind_stored_view_relations(plan, relations).map_err(StorageBackendError::Other)?;
23        let mut refreshed = false;
24        uqa_sql::binding::view_dependencies::bind_query_plan_sequence_references(
25            plan,
26            &mut |reference| {
27                if !refreshed {
28                    self.refresh_sequences_from_catalog()?;
29                    refreshed = true;
30                }
31                self.resolve_stored_sequence_reference_from_loaded_registry(reference)
32            },
33        )
34    }
35
36    pub(crate) fn stored_view_schema(
37        &self,
38        view: &StoredView,
39    ) -> Result<uqa_execution::RowSchema, SQLError> {
40        self.stored_view_schema_with_catalog(
41            view,
42            self.restored_catalog_read_view(),
43            self.session_execution_view().relation_name_resolution(),
44        )
45    }
46
47    pub(crate) fn stored_view_schema_with_catalog(
48        &self,
49        view: &StoredView,
50        catalog: crate::capabilities::CatalogReadView,
51        resolution: crate::capabilities::RelationNameResolution,
52    ) -> Result<uqa_execution::RowSchema, SQLError> {
53        view.row_schema(self, std::sync::Arc::new(catalog), resolution)
54    }
55
56    pub(crate) fn view_schema(
57        &self,
58        name: &str,
59    ) -> Result<Option<uqa_execution::RowSchema>, SQLError> {
60        self.view_definition(name)?
61            .map(|view| self.stored_view_schema(&view))
62            .transpose()
63    }
64
65    pub(crate) fn view_definition(&self, name: &str) -> Result<Option<StoredView>, SQLError> {
66        let Some(resolved) = self
67            .try_resolve_view_name(name)
68            .map_err(|err| SQLError::Internal(format!("refresh view catalog: {err}")))?
69        else {
70            return Ok(None);
71        };
72        let relation = Self::resolved_relation_identity(&resolved)
73            .map_err(|err| SQLError::Internal(format!("resolve view `{resolved}`: {err}")))?;
74        if let Some(snapshot) = self.query_view_snapshots.as_ref() {
75            return Ok(snapshot.get(&relation).cloned());
76        }
77        Ok(self.durable.views.read().get(&relation).cloned())
78    }
79
80    /// Resolve a view only against the live restored registry without starting another registry synchronization pass.
81    pub(crate) fn restored_catalog_view_definition(
82        &self,
83        name: &str,
84    ) -> Result<Option<StoredView>, SQLError> {
85        let views = self.durable.views.read();
86        Ok(self
87            .relation_lookup_candidates(name)
88            .map_err(|error| {
89                SQLError::Internal(format!("resolve restored view `{name}`: {error}"))
90            })?
91            .into_iter()
92            .find_map(|relation| views.get(&relation).cloned()))
93    }
94
95    pub fn view(&self, name: &str) -> Result<Option<uqa_planner::QueryPlan>, SQLError> {
96        self.with_direct_read_snapshot(|engine| engine.view_plan(name))
97    }
98
99    pub(crate) fn view_plan(&self, name: &str) -> Result<Option<uqa_planner::QueryPlan>, SQLError> {
100        Ok(self.view_definition(name)?.and_then(|definition| {
101            (definition.kind == StoredViewKind::View).then_some(definition.definition.query)
102        }))
103    }
104
105    pub fn list_views(&self) -> Result<Vec<String>, SQLError> {
106        self.with_direct_read_snapshot(|engine| {
107            engine
108                .synchronize_catalog_registries()
109                .map_err(|err| SQLError::Internal(format!("refresh view catalog: {err}")))?;
110            let mut out: Vec<String> = engine
111                .durable
112                .views
113                .read()
114                .iter()
115                .filter(|(_, view)| view.kind == StoredViewKind::View)
116                .map(|(relation, _)| relation.qualified_name())
117                .collect();
118            out.sort_unstable();
119            Ok(out)
120        })
121    }
122}