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_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}