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 deferred_reference(&self, name: &str) -> Option<&CtePlan> {
35        self.deferred_reference(name)
36    }
37    fn privilege_subject(&self) -> Result<&RoleReference, SQLError> {
38        self.privilege_subject()
39    }
40}
41pub(crate) fn with_scope<S: Clone, T>(
42    ctes: &CteScope<S>,
43    apply: impl FnOnce(&PrivilegeScope<'_, &[QueryPlan]>) -> Result<T, SQLError>,
44) -> Result<T, SQLError> {
45    let catalog = ctes.catalog_read_view()?;
46    let scope = PrivilegeScope::borrowed(
47        &catalog,
48        ctes.relation_name_resolution()?,
49        ctes,
50        &ctes.scalar_subqueries,
51    );
52    apply(&scope)
53}
54pub fn ensure_select_privileges_for_query<S: Clone>(
55    query: &QueryPlan,
56    ctes: &CteScope<S>,
57) -> Result<(), SQLError> {
58    with_scope(ctes, |scope| {
59        logical::ensure_select_privileges_for_query(query, scope)
60    })
61}
62
63pub fn ensure_select_privileges_for_query_block<S: Clone>(
64    statement: &QueryBlockPlan,
65    source: &SourcePlan,
66    ctes: &CteScope<S>,
67) -> Result<(), SQLError> {
68    check_query_source(statement, source, ctes).map(|_| ())
69}
70
71pub(crate) fn check_query_source<'a, S: Clone>(
72    statement: &'a QueryBlockPlan,
73    source: &'a SourcePlan,
74    ctes: &CteScope<S>,
75) -> Result<logical::coverage::SelectSourceCoverage<'a>, SQLError> {
76    #[cfg(test)]
77    SELECT_CHECKS.with(|count| count.set(count.get() + 1));
78    with_scope(ctes, |scope| {
79        logical::coverage::check_query_source(statement, source, scope)
80    })
81}
82
83pub fn ensure_select_privileges_for_source_expressions<S: Clone>(
84    source: &SourcePlan,
85    expressions: &[&ScalarExpr],
86    ctes: &CteScope<S>,
87) -> Result<(), SQLError> {
88    with_scope(ctes, |scope| {
89        logical::ensure_select_privileges_for_source_expressions(source, expressions, scope)
90    })
91}
92
93pub fn ensure_select_privileges_for_table_expressions<S: Clone>(
94    table: &str,
95    qualifiers: &BTreeSet<String>,
96    expressions: &[&ScalarExpr],
97    subqueries: &[QueryPlan],
98    required_columns: &[String],
99    ctes: &CteScope<S>,
100) -> Result<(), SQLError> {
101    with_scope(ctes, |scope| {
102        logical::ensure_select_privileges_for_table_expressions(
103            table,
104            qualifiers,
105            expressions,
106            subqueries,
107            required_columns,
108            scope,
109        )
110    })
111}
112
113use uqa_sql::semantics::privileges::TargetSelectPrivilegeRequest;
114pub fn ensure_target_table_select_for_expressions<S: Clone>(
115    request: TargetSelectPrivilegeRequest<'_, '_>,
116    ctes: &mut CteScope<S>,
117) -> Result<(), SQLError> {
118    let TargetSelectPrivilegeRequest {
119        table,
120        privilege_subject,
121        target_qualifier,
122        returning_aliases,
123        expressions,
124        subqueries,
125        required_columns,
126    } = request;
127    let relation =
128        uqa_core::RelationIdentity::from_legacy_name(table).map_err(SQLError::Internal)?;
129    let target_qualifiers = BTreeSet::from([
130        target_qualifier.to_string(),
131        table.to_string(),
132        relation.name,
133        returning_aliases.old.clone(),
134        returning_aliases.new.clone(),
135    ]);
136    ctes.scalar_subqueries = subqueries.into();
137    if let Some(subject) = privilege_subject {
138        let scope = ctes.enter_privilege_subject(subject.clone());
139        ensure_select_privileges_for_table_expressions(
140            table,
141            &target_qualifiers,
142            expressions,
143            subqueries,
144            required_columns,
145            &scope,
146        )
147    } else {
148        ensure_select_privileges_for_table_expressions(
149            table,
150            &target_qualifiers,
151            expressions,
152            subqueries,
153            required_columns,
154            ctes,
155        )
156    }
157}