Skip to main content

uqa_execution/query/
privileges.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Capture authorization analysis inputs from the statement scope.
8pub mod routine_calls;
9
10use super::CteScope;
11use std::collections::BTreeSet;
12use uqa_sql::catalog::roles::RoleReference;
13use uqa_sql::semantics::privileges::{
14    self as logical,
15    context::{PrivilegeCteCatalog, PrivilegeScope},
16};
17use uqa_sql::{
18    plan::{CtePlan, QueryBlockPlan, QueryPlan, SourcePlan},
19    SQLError, ScalarExpr,
20};
21
22#[cfg(test)]
23thread_local! {
24    pub(crate) static SELECT_CHECKS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
25}
26impl<S: Clone> PrivilegeCteCatalog for CteScope<S> {
27    fn is_visible_cte(&self, name: &str) -> bool {
28        self.is_visible_cte(name)
29    }
30    fn materialized_columns(&self, name: &str) -> Option<Vec<String>> {
31        self.materialized_for_scan(name)
32            .map(|rows| rows.row_schema().columns().to_vec())
33    }
34    fn materialized_columns_with_control(
35        &self,
36        name: &str,
37        control: &uqa_core::memory::ProductionControl<'_>,
38    ) -> Result<Option<uqa_core::memory::Produced<Vec<String>>>, SQLError> {
39        let Some(rows) = self.materialized_for_scan_with_control(name, control)? else {
40            return Ok(None);
41        };
42        let mut columns = uqa_core::memory::ProductionVec::new(*control);
43        for name in rows.row_schema().columns() {
44            columns.push_produced(control.copy_text(name)?)?;
45        }
46        Ok(Some(columns.finish()?))
47    }
48    fn is_visible_cte_with_control(
49        &self,
50        name: &str,
51        control: &uqa_core::memory::ProductionControl<'_>,
52    ) -> Result<bool, SQLError> {
53        self.is_visible_cte_with_control(name, control)
54    }
55    fn deferred_reference_with_control(
56        &self,
57        name: &str,
58        control: &uqa_core::memory::ProductionControl<'_>,
59    ) -> Result<Option<&CtePlan>, SQLError> {
60        self.deferred_reference_with_control(name, control)
61    }
62    fn deferred_reference(&self, name: &str) -> Option<&CtePlan> {
63        self.deferred_reference(name)
64    }
65    fn privilege_subject(&self) -> Result<&RoleReference, SQLError> {
66        self.privilege_subject()
67    }
68}
69pub(crate) fn with_scope<S: Clone, T>(
70    ctes: &CteScope<S>,
71    apply: impl FnOnce(&PrivilegeScope<'_, &[QueryPlan]>) -> Result<T, SQLError>,
72) -> Result<T, SQLError> {
73    with_scope_with_control(
74        ctes,
75        &uqa_core::memory::ProductionControl::uncontrolled(),
76        apply,
77    )
78}
79
80fn with_scope_with_control<S: Clone, T>(
81    ctes: &CteScope<S>,
82    control: &uqa_core::memory::ProductionControl<'_>,
83    apply: impl FnOnce(&PrivilegeScope<'_, &[QueryPlan]>) -> Result<T, SQLError>,
84) -> Result<T, SQLError> {
85    let catalog = ctes.catalog_read_view()?;
86    let scope = PrivilegeScope::borrowed_with_control(
87        &catalog,
88        ctes.relation_name_resolution_with_control(control)?,
89        ctes,
90        &ctes.scalar_subqueries,
91        control,
92    );
93    apply(&scope)
94}
95
96pub fn ensure_select_privileges_for_query_with_control<S: Clone>(
97    query: &QueryPlan,
98    ctes: &CteScope<S>,
99    control: &uqa_core::memory::ProductionControl<'_>,
100) -> Result<(), SQLError> {
101    with_scope_with_control(ctes, control, |scope| {
102        logical::ensure_select_privileges_for_query(query, scope)
103    })
104}
105
106pub fn ensure_select_privileges_for_query<S: Clone>(
107    query: &QueryPlan,
108    ctes: &CteScope<S>,
109) -> Result<(), SQLError> {
110    with_scope(ctes, |scope| {
111        logical::ensure_select_privileges_for_query(query, scope)
112    })
113}
114
115pub fn ensure_select_privileges_for_query_block<S: Clone>(
116    statement: &QueryBlockPlan,
117    source: &SourcePlan,
118    ctes: &CteScope<S>,
119) -> Result<(), SQLError> {
120    check_query_source(statement, source, ctes).map(|_| ())
121}
122
123pub(crate) fn check_query_source<'a, S: Clone>(
124    statement: &'a QueryBlockPlan,
125    source: &'a SourcePlan,
126    ctes: &CteScope<S>,
127) -> Result<logical::coverage::SelectSourceCoverage<'a>, SQLError> {
128    #[cfg(test)]
129    SELECT_CHECKS.with(|count| count.set(count.get() + 1));
130    with_scope(ctes, |scope| {
131        logical::coverage::check_query_source(statement, source, scope)
132    })
133}
134
135pub fn ensure_select_privileges_for_source_expressions<S: Clone>(
136    source: &SourcePlan,
137    expressions: &[&ScalarExpr],
138    ctes: &CteScope<S>,
139) -> Result<(), SQLError> {
140    ensure_select_privileges_for_source_expressions_with_control(
141        source,
142        expressions,
143        ctes,
144        &uqa_core::memory::ProductionControl::uncontrolled(),
145    )
146}
147
148pub fn ensure_select_privileges_for_source_expressions_with_control<S: Clone>(
149    source: &SourcePlan,
150    expressions: &[&ScalarExpr],
151    ctes: &CteScope<S>,
152    control: &uqa_core::memory::ProductionControl<'_>,
153) -> Result<(), SQLError> {
154    with_scope_with_control(ctes, control, |scope| {
155        logical::ensure_select_privileges_for_source_expressions(source, expressions, scope)
156    })
157}
158
159pub fn ensure_select_privileges_for_table_expressions<S: Clone>(
160    table: &str,
161    qualifiers: &BTreeSet<String>,
162    expressions: &[&ScalarExpr],
163    subqueries: &[QueryPlan],
164    required_columns: &[String],
165    ctes: &CteScope<S>,
166) -> Result<(), SQLError> {
167    with_scope(ctes, |scope| {
168        logical::ensure_select_privileges_for_table_expressions(
169            table,
170            qualifiers,
171            expressions,
172            subqueries,
173            required_columns,
174            scope,
175        )
176    })
177}
178
179use uqa_sql::semantics::privileges::TargetSelectPrivilegeRequest;
180pub fn ensure_target_table_select_for_expressions<S: Clone>(
181    request: TargetSelectPrivilegeRequest<'_, '_>,
182    ctes: &CteScope<S>,
183) -> Result<(), SQLError> {
184    ensure_target_table_select_for_expressions_with_control(
185        request,
186        ctes,
187        &uqa_core::memory::ProductionControl::uncontrolled(),
188    )
189}
190
191pub fn ensure_target_table_select_for_expressions_with_control<S: Clone>(
192    request: TargetSelectPrivilegeRequest<'_, '_>,
193    ctes: &CteScope<S>,
194    control: &uqa_core::memory::ProductionControl<'_>,
195) -> Result<(), SQLError> {
196    with_scope_with_control(ctes, control, |scope| {
197        logical::ensure_target_select(request, scope)
198    })
199}