1use 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}