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