1use crate::Engine;
10use std::{collections::BTreeSet, sync::Arc};
11use uqa_core::memory::{Produced, ProductionControl};
12use uqa_sql::catalog::roles::RoleReference;
13use uqa_sql::{
14 ast::{ColumnDef, RuleEvent, TriggerEvent, TriggerTiming},
15 binding::snapshot::BindingSnapshot,
16 catalog::{
17 analysis::CatalogReadView,
18 events::StoredRule,
19 resolution::RelationNameResolution,
20 view::{StoredViewKind, ViewRewriteDefinition},
21 },
22 semantics::view_rewrite::context::ViewRewriteCatalog,
23 SQLError,
24};
25
26impl ViewRewriteCatalog for Engine {
27 fn visit_table_column_names_with_control(
28 &self,
29 name: &str,
30 control: &ProductionControl<'_>,
31 read: &mut dyn FnMut(&str) -> Result<(), SQLError>,
32 ) -> Result<(), SQLError> {
33 if uqa_sql::semantics::returning::ReturningCatalog::with_table_row_type_with_control(
34 self,
35 name,
36 control,
37 &mut |columns| columns.iter().try_for_each(|column| read(&column.name)),
38 )? {
39 Ok(())
40 } else {
41 Err(SQLError::UnknownTable(
42 control.copy_text(name)?.into_parts().0,
43 ))
44 }
45 }
46
47 fn capture_rules(
48 &self,
49 name: &str,
50 event: RuleEvent,
51 ) -> Result<uqa_sql::catalog::events::selection::CapturedRules, SQLError> {
52 uqa_sql::semantics::rules::RuleCatalog::capture_rules(self, name, event)
53 }
54 fn capture_rules_with_control(
55 &self,
56 name: &str,
57 event: RuleEvent,
58 control: &ProductionControl<'_>,
59 ) -> Result<uqa_sql::catalog::events::selection::CapturedRules, SQLError> {
60 uqa_sql::semantics::rules::RuleCatalog::capture_rules_with_control(
61 self, name, event, control,
62 )
63 }
64 fn with_view_definition_with_control(
65 &self,
66 name: &str,
67 control: &uqa_core::memory::ProductionControl<'_>,
68 read: &mut dyn FnMut(
69 Option<uqa_sql::catalog::view::ViewRewriteDefinitionRef<'_>>,
70 ) -> Result<(), SQLError>,
71 ) -> Result<(), SQLError> {
72 if Engine::with_view_definition_with_control(self, name, control, |_, view| {
73 read(Some(view.rewrite_definition_ref()))
74 })?
75 .is_none()
76 {
77 read(None)?;
78 }
79 Ok(())
80 }
81 fn try_resolve_view_name_with_control(
82 &self,
83 name: &str,
84 control: &uqa_core::memory::ProductionControl<'_>,
85 ) -> Result<Option<uqa_core::memory::Produced<String>>, SQLError> {
86 Engine::try_resolve_view_name_with_control(self, name, control)
87 }
88 fn visit_rules_with_control(
89 &self,
90 name: &str,
91 event: RuleEvent,
92 reverse: bool,
93 control: &uqa_core::memory::ProductionControl<'_>,
94 visit: &mut dyn FnMut(&StoredRule) -> Result<(), SQLError>,
95 ) -> Result<(), SQLError> {
96 uqa_sql::semantics::rules::RuleCatalog::visit_rules_with_control(
97 self, name, event, reverse, control, visit,
98 )
99 }
100 fn target_view_kind_with_control(
101 &self,
102 name: &str,
103 control: &uqa_core::memory::ProductionControl<'_>,
104 ) -> Result<Option<StoredViewKind>, SQLError> {
105 self.mutation_view_kind_with_control(name, control)
106 }
107 fn has_trigger_definition_with_control(
108 &self,
109 name: &str,
110 timing: TriggerTiming,
111 event: TriggerEvent,
112 row: bool,
113 control: &uqa_core::memory::ProductionControl<'_>,
114 ) -> Result<bool, SQLError> {
115 let relation = self
116 .event_analysis_context()
117 .resolve_trigger_table_with_control(name, control)?;
118 let triggers = self.query_catalog_snapshot.as_ref().map_or_else(
119 || self.durable.triggers.snapshot(),
120 |snapshot| snapshot.triggers.clone(),
121 );
122 uqa_sql::catalog::events::selection::has_trigger_definition_with_control(
123 &triggers, &relation, timing, event, row, control,
124 )
125 }
126 fn binding_scope_with_control(
127 &self,
128 control: &uqa_core::memory::ProductionControl<'_>,
129 ) -> Result<uqa_sql::binding::production::ControlledBindingSnapshot, SQLError> {
130 let scope =
131 crate::capabilities::query_scope::new_for_current_routine_with_control(self, control)?;
132 uqa_execution::query::binding::binding_snapshot_with_control(&scope, control)
133 }
134 fn restored_view_scope_with_control(
135 &self,
136 control: &uqa_core::memory::ProductionControl<'_>,
137 ) -> Result<uqa_sql::binding::production::ControlledBindingContext<'static>, SQLError> {
138 use uqa_sql::binding::production::{
139 BindingMap, BindingNameSet, BindingResolution, ControlledBindingContext,
140 };
141 let catalog = control
142 .finish(
143 self.restored_catalog_read_view_with_control(control)?,
144 control.empty_reservation(),
145 )?
146 .into_shared(control)?;
147 let resolution = uqa_execution::catalog::services::CatalogSession::relation_name_resolution_with_control(self, control)?;
148 Ok(ControlledBindingContext {
149 catalog,
150 resolution: BindingResolution::from_produced(resolution),
151 ctes: BindingMap::new(),
152 deferred_ctes: BindingMap::new(),
153 non_returning_ctes: BindingNameSet::new(),
154 scalar_subqueries: &[],
155 })
156 }
157 fn view_definition(&self, name: &str) -> Result<Option<ViewRewriteDefinition>, SQLError> {
158 Ok(Engine::view_definition(self, name)?.map(|definition| definition.rewrite_definition()))
159 }
160 fn try_resolve_view_name(&self, name: &str) -> Result<Option<String>, String> {
161 Engine::try_resolve_view_name(self, name).map_err(|error| error.to_string())
162 }
163 fn try_describe_table(&self, name: &str) -> Result<Option<Vec<ColumnDef>>, String> {
164 Engine::describe_table_in_execution(self, name).map_err(|error| error.to_string())
165 }
166 fn try_table_columns(&self, name: &str) -> Result<Vec<String>, String> {
167 Engine::table_columns_in_execution(self, name).map_err(|error| error.to_string())
168 }
169 fn rules_for(&self, name: &str, event: RuleEvent) -> Result<Vec<StoredRule>, SQLError> {
170 self.event_lookup_context().rules_for(name, event)
171 }
172 fn rule_definitions_for(
173 &self,
174 name: &str,
175 event: RuleEvent,
176 ) -> Result<Vec<StoredRule>, SQLError> {
177 self.event_lookup_context()
178 .rule_definitions_for(name, event)
179 }
180 fn has_trigger_definition(
181 &self,
182 name: &str,
183 timing: TriggerTiming,
184 event: TriggerEvent,
185 row: bool,
186 ) -> Result<bool, SQLError> {
187 self.event_lookup_context()
188 .has_trigger_definition(name, timing, event, row)
189 }
190 fn rule_new_row_columns(
191 &self,
192 rule: &StoredRule,
193 ) -> Result<Option<BTreeSet<String>>, SQLError> {
194 uqa_sql::semantics::rules::action_binding::rule_new_row_columns(self, rule)
195 }
196 fn rule_new_row_columns_with_control(
197 &self,
198 rule: &StoredRule,
199 control: &ProductionControl<'_>,
200 ) -> Result<Option<Produced<Vec<String>>>, SQLError> {
201 uqa_sql::semantics::rules::action_binding::rule_new_row_columns_with_control(
202 self, rule, control,
203 )
204 }
205 fn target_view_kind(&self, name: &str) -> Result<Option<StoredViewKind>, SQLError> {
206 self.mutation_view_kind(name)
207 }
208 fn binding_scope(&self) -> Result<BindingSnapshot, SQLError> {
209 let scope = crate::capabilities::query_scope::new_for_current_routine(self)?;
210 uqa_execution::query::binding::binding_context(&scope).map(BindingSnapshot::from)
211 }
212 fn restored_view_catalog(&self) -> (CatalogReadView, RelationNameResolution) {
213 (
214 Arc::new(self.restored_catalog_read_view()),
215 self.session_execution_view().relation_name_resolution(),
216 )
217 }
218}
219
220use uqa_sql::{
221 catalog::{security::table::TableAclPrivilege, stored_view::StoredView},
222 semantics::{
223 privileges::TargetSelectPrivilegeRequest, view_privileges::ViewPrivilegeCatalog,
224 view_rewrite::context::ViewRewriteContext,
225 },
226};
227impl Engine {
228 pub(crate) fn view_rewrite_context(&self) -> ViewRewriteContext<'_> {
229 ViewRewriteContext {
230 catalog: self,
231 routines: self,
232 authorization: self,
233 }
234 }
235}
236impl ViewPrivilegeCatalog for Engine {
237 fn with_view_definition_with_control(
238 &self,
239 name: &str,
240 control: &uqa_core::memory::ProductionControl<'_>,
241 read: &mut dyn FnMut(Option<&StoredView>) -> Result<(), SQLError>,
242 ) -> Result<(), SQLError> {
243 if Engine::with_view_definition_with_control(self, name, control, |_, view| {
244 read(Some(view))
245 })?
246 .is_none()
247 {
248 read(None)?;
249 }
250 Ok(())
251 }
252 fn ensure_query_select_with_control(
253 &self,
254 query: &uqa_sql::plan::QueryPlan,
255 control: &uqa_core::memory::ProductionControl<'_>,
256 ) -> Result<(), SQLError> {
257 let scope = super::query_scope::new_for_current_routine_with_control(self, control)?;
258 uqa_execution::query::privileges::ensure_select_privileges_for_query_with_control(
259 query, &scope, control,
260 )
261 }
262 fn bound_role_with_control(
263 &self,
264 identity: uqa_sql::catalog::roles::RoleIdentity,
265 control: &uqa_core::memory::ProductionControl<'_>,
266 ) -> Result<uqa_core::memory::Produced<RoleReference>, SQLError> {
267 let role = RoleReference::from_identity_with_control(
268 identity,
269 &self.durable.roles.read(),
270 control,
271 )?;
272 Ok(control.finish(role, control.empty_reservation())?)
273 }
274 fn ensure_query_select(&self, query: &uqa_sql::plan::QueryPlan) -> Result<(), SQLError> {
275 let scope = super::query_scope::new_for_current_routine(self)?;
276 uqa_execution::query::privileges::ensure_select_privileges_for_query(query, &scope)
277 }
278 fn view_definition(&self, name: &str) -> Result<Option<StoredView>, SQLError> {
279 self.view_definition(name)
280 }
281 fn current_role(&self) -> RoleReference {
282 self.current_role()
283 }
284 fn bound_role(
285 &self,
286 identity: uqa_sql::catalog::roles::RoleIdentity,
287 ) -> Result<RoleReference, SQLError> {
288 RoleReference::from_identity(identity, &self.durable.roles.read())
289 }
290 fn ensure_view_privilege_for_with_control(
291 &self,
292 name: &str,
293 view: &StoredView,
294 subject: &RoleReference,
295 privilege: TableAclPrivilege,
296 control: &uqa_core::memory::ProductionControl<'_>,
297 ) -> Result<(), SQLError> {
298 uqa_sql::catalog::security::view_authorization::ViewAuthorizationContext { roles: self }
299 .ensure_view_privilege_for_with_control(name, view, subject, privilege, control)
300 }
301 fn ensure_view_column_privilege_for_with_control(
302 &self,
303 name: &str,
304 view: &StoredView,
305 column: &str,
306 subject: &RoleReference,
307 privilege: TableAclPrivilege,
308 control: &uqa_core::memory::ProductionControl<'_>,
309 ) -> Result<(), SQLError> {
310 uqa_sql::catalog::security::view_authorization::ViewAuthorizationContext { roles: self }
311 .ensure_view_column_privilege_for_with_control(
312 name, view, column, subject, privilege, control,
313 )
314 }
315 fn ensure_any_view_column_privilege_for_with_control(
316 &self,
317 name: &str,
318 view: &StoredView,
319 subject: &RoleReference,
320 privilege: TableAclPrivilege,
321 control: &uqa_core::memory::ProductionControl<'_>,
322 ) -> Result<(), SQLError> {
323 uqa_sql::catalog::security::view_authorization::ViewAuthorizationContext { roles: self }
324 .ensure_any_view_column_privilege_for_with_control(
325 name, view, subject, privilege, control,
326 )
327 }
328 fn ensure_view_privilege_for(
329 &self,
330 name: &str,
331 view: &StoredView,
332 subject: &RoleReference,
333 privilege: TableAclPrivilege,
334 ) -> Result<(), SQLError> {
335 self.ensure_view_privilege_for(name, view, subject, privilege)
336 }
337 fn ensure_view_column_privilege_for(
338 &self,
339 name: &str,
340 view: &StoredView,
341 column: &str,
342 subject: &RoleReference,
343 privilege: TableAclPrivilege,
344 ) -> Result<(), SQLError> {
345 self.ensure_view_column_privilege_for(name, view, column, subject, privilege)
346 }
347 fn ensure_any_view_column_privilege_for(
348 &self,
349 name: &str,
350 view: &StoredView,
351 subject: &RoleReference,
352 privilege: TableAclPrivilege,
353 ) -> Result<(), SQLError> {
354 self.ensure_any_view_column_privilege_for(name, view, subject, privilege)
355 }
356 fn ensure_target_select(
357 &self,
358 request: TargetSelectPrivilegeRequest<'_, '_>,
359 ) -> Result<(), SQLError> {
360 self.ensure_target_select_with_control(
361 request,
362 &uqa_core::memory::ProductionControl::uncontrolled(),
363 )
364 }
365 fn ensure_target_select_with_control(
366 &self,
367 request: TargetSelectPrivilegeRequest<'_, '_>,
368 control: &uqa_core::memory::ProductionControl<'_>,
369 ) -> Result<(), SQLError> {
370 let scope = super::query_scope::new_for_current_routine_with_control(self, control)?;
371 uqa_execution::query::privileges::ensure_target_table_select_for_expressions_with_control(
372 request, &scope, control,
373 )
374 }
375}