Skip to main content

uqa_engine/capabilities/
view_rewrite.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind logical view analysis to current catalog generations and session state.
8
9use crate::Engine;
10use std::{collections::BTreeSet, sync::Arc};
11use uqa_sql::catalog::roles::RoleReference;
12use uqa_sql::{
13    ast::{ColumnDef, RuleEvent, TriggerEvent, TriggerTiming},
14    binding::snapshot::BindingSnapshot,
15    catalog::{
16        analysis::CatalogReadView,
17        events::StoredRule,
18        resolution::RelationNameResolution,
19        view::{StoredViewKind, ViewRewriteDefinition},
20    },
21    semantics::view_rewrite::context::ViewRewriteCatalog,
22    SQLError,
23};
24
25impl ViewRewriteCatalog for Engine {
26    fn view_definition(&self, name: &str) -> Result<Option<ViewRewriteDefinition>, SQLError> {
27        Ok(Engine::view_definition(self, name)?.map(|definition| definition.rewrite_definition()))
28    }
29    fn try_resolve_view_name(&self, name: &str) -> Result<Option<String>, String> {
30        Engine::try_resolve_view_name(self, name).map_err(|error| error.to_string())
31    }
32    fn try_describe_table(&self, name: &str) -> Result<Option<Vec<ColumnDef>>, String> {
33        Engine::describe_table_in_execution(self, name).map_err(|error| error.to_string())
34    }
35    fn try_table_columns(&self, name: &str) -> Result<Vec<String>, String> {
36        Engine::table_columns_in_execution(self, name).map_err(|error| error.to_string())
37    }
38    fn rules_for(&self, name: &str, event: RuleEvent) -> Result<Vec<StoredRule>, SQLError> {
39        self.event_lookup_context().rules_for(name, event)
40    }
41    fn rule_definitions_for(
42        &self,
43        name: &str,
44        event: RuleEvent,
45    ) -> Result<Vec<StoredRule>, SQLError> {
46        self.event_lookup_context()
47            .rule_definitions_for(name, event)
48    }
49    fn has_trigger_definition(
50        &self,
51        name: &str,
52        timing: TriggerTiming,
53        event: TriggerEvent,
54        row: bool,
55    ) -> Result<bool, SQLError> {
56        self.event_lookup_context()
57            .has_trigger_definition(name, timing, event, row)
58    }
59    fn rule_new_row_columns(
60        &self,
61        rule: &StoredRule,
62    ) -> Result<Option<BTreeSet<String>>, SQLError> {
63        uqa_sql::semantics::rules::action_binding::rule_new_row_columns(self, rule)
64    }
65    fn target_view_kind(&self, name: &str) -> Result<Option<StoredViewKind>, SQLError> {
66        self.mutation_view_kind(name)
67    }
68    fn binding_scope(&self) -> Result<BindingSnapshot, SQLError> {
69        let scope = crate::capabilities::query_scope::new_for_current_routine(self);
70        uqa_execution::query::binding::binding_context(&scope).map(BindingSnapshot::from)
71    }
72    fn restored_view_catalog(&self) -> (CatalogReadView, RelationNameResolution) {
73        (
74            Arc::new(self.restored_catalog_read_view()),
75            self.session_execution_view().relation_name_resolution(),
76        )
77    }
78}
79
80use uqa_sql::{
81    catalog::{security::table::TableAclPrivilege, stored_view::StoredView},
82    semantics::{
83        privileges::TargetSelectPrivilegeRequest, view_privileges::ViewPrivilegeCatalog,
84        view_rewrite::context::ViewRewriteContext,
85    },
86};
87impl Engine {
88    pub(crate) fn view_rewrite_context(&self) -> ViewRewriteContext<'_> {
89        ViewRewriteContext {
90            catalog: self,
91            routines: self,
92            authorization: self,
93        }
94    }
95}
96impl ViewPrivilegeCatalog for Engine {
97    fn view_definition(&self, name: &str) -> Result<Option<StoredView>, SQLError> {
98        self.view_definition(name)
99    }
100    fn current_role(&self) -> RoleReference {
101        self.current_role()
102    }
103    fn bound_role(
104        &self,
105        identity: uqa_sql::catalog::roles::RoleIdentity,
106    ) -> Result<RoleReference, SQLError> {
107        RoleReference::from_identity(identity, &self.durable.roles.read())
108    }
109    fn ensure_view_privilege_for(
110        &self,
111        name: &str,
112        view: &StoredView,
113        subject: &RoleReference,
114        privilege: TableAclPrivilege,
115    ) -> Result<(), SQLError> {
116        self.ensure_view_privilege_for(name, view, subject, privilege)
117    }
118    fn ensure_view_column_privilege_for(
119        &self,
120        name: &str,
121        view: &StoredView,
122        column: &str,
123        subject: &RoleReference,
124        privilege: TableAclPrivilege,
125    ) -> Result<(), SQLError> {
126        self.ensure_view_column_privilege_for(name, view, column, subject, privilege)
127    }
128    fn ensure_any_view_column_privilege_for(
129        &self,
130        name: &str,
131        view: &StoredView,
132        subject: &RoleReference,
133        privilege: TableAclPrivilege,
134    ) -> Result<(), SQLError> {
135        self.ensure_any_view_column_privilege_for(name, view, subject, privilege)
136    }
137    fn ensure_target_select(
138        &self,
139        request: TargetSelectPrivilegeRequest<'_, '_>,
140    ) -> Result<(), SQLError> {
141        let mut scope = super::query_scope::new_for_current_routine(self);
142        uqa_execution::query::privileges::ensure_target_table_select_for_expressions(
143            request, &mut scope,
144        )
145    }
146}