uqa_engine/session/
views.rs1use 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 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 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}