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 ensure_query_select(&self, query: &uqa_sql::plan::QueryPlan) -> Result<(), SQLError> {
98        let scope = super::query_scope::new_for_current_routine(self);
99        uqa_execution::query::privileges::ensure_select_privileges_for_query(query, &scope)
100    }
101    fn view_definition(&self, name: &str) -> Result<Option<StoredView>, SQLError> {
102        self.view_definition(name)
103    }
104    fn current_role(&self) -> RoleReference {
105        self.current_role()
106    }
107    fn bound_role(
108        &self,
109        identity: uqa_sql::catalog::roles::RoleIdentity,
110    ) -> Result<RoleReference, SQLError> {
111        RoleReference::from_identity(identity, &self.durable.roles.read())
112    }
113    fn ensure_view_privilege_for(
114        &self,
115        name: &str,
116        view: &StoredView,
117        subject: &RoleReference,
118        privilege: TableAclPrivilege,
119    ) -> Result<(), SQLError> {
120        self.ensure_view_privilege_for(name, view, subject, privilege)
121    }
122    fn ensure_view_column_privilege_for(
123        &self,
124        name: &str,
125        view: &StoredView,
126        column: &str,
127        subject: &RoleReference,
128        privilege: TableAclPrivilege,
129    ) -> Result<(), SQLError> {
130        self.ensure_view_column_privilege_for(name, view, column, subject, privilege)
131    }
132    fn ensure_any_view_column_privilege_for(
133        &self,
134        name: &str,
135        view: &StoredView,
136        subject: &RoleReference,
137        privilege: TableAclPrivilege,
138    ) -> Result<(), SQLError> {
139        self.ensure_any_view_column_privilege_for(name, view, subject, privilege)
140    }
141    fn ensure_target_select(
142        &self,
143        request: TargetSelectPrivilegeRequest<'_, '_>,
144    ) -> Result<(), SQLError> {
145        let mut scope = super::query_scope::new_for_current_routine(self);
146        uqa_execution::query::privileges::ensure_target_table_select_for_expressions(
147            request, &mut scope,
148        )
149    }
150}