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};
21impl<S: Clone> PrivilegeCteCatalog for CteScope<S> {
22    fn is_visible_cte(&self, name: &str) -> bool {
23        self.is_visible_cte(name)
24    }
25    fn materialized_columns(&self, name: &str) -> Option<Vec<String>> {
26        self.materialized_for_scan(name)
27            .map(|rows| rows.row_schema().columns().to_vec())
28    }
29    fn deferred_reference(&self, name: &str) -> Option<&CtePlan> {
30        self.deferred_reference(name)
31    }
32    fn privilege_subject(&self) -> Result<&RoleReference, SQLError> {
33        self.privilege_subject()
34    }
35}
36pub(crate) fn with_scope<S: Clone, T>(
37    ctes: &CteScope<S>,
38    apply: impl FnOnce(&PrivilegeScope<'_>) -> Result<T, SQLError>,
39) -> Result<T, SQLError> {
40    let catalog = ctes.catalog_read_view()?;
41    let scope = PrivilegeScope::new(
42        &catalog,
43        ctes.relation_name_resolution()?,
44        ctes,
45        ctes.scalar_subqueries.clone(),
46    );
47    apply(&scope)
48}
49pub fn ensure_select_privileges_for_query_block<S: Clone>(
50    statement: &QueryBlockPlan,
51    source: &SourcePlan,
52    ctes: &CteScope<S>,
53) -> Result<(), SQLError> {
54    with_scope(ctes, |scope| {
55        logical::ensure_select_privileges_for_query_block(statement, source, scope)
56    })
57}
58
59pub fn ensure_select_privileges_for_source_expressions<S: Clone>(
60    source: &SourcePlan,
61    expressions: &[&ScalarExpr],
62    ctes: &CteScope<S>,
63) -> Result<(), SQLError> {
64    with_scope(ctes, |scope| {
65        logical::ensure_select_privileges_for_source_expressions(source, expressions, scope)
66    })
67}
68
69pub fn ensure_select_privileges_for_table_expressions<S: Clone>(
70    table: &str,
71    qualifiers: &BTreeSet<String>,
72    expressions: &[&ScalarExpr],
73    subqueries: &[QueryPlan],
74    required_columns: &[String],
75    ctes: &CteScope<S>,
76) -> Result<(), SQLError> {
77    with_scope(ctes, |scope| {
78        logical::ensure_select_privileges_for_table_expressions(
79            table,
80            qualifiers,
81            expressions,
82            subqueries,
83            required_columns,
84            scope,
85        )
86    })
87}
88
89use uqa_sql::semantics::privileges::TargetSelectPrivilegeRequest;
90pub fn ensure_target_table_select_for_expressions<S: Clone>(
91    request: TargetSelectPrivilegeRequest<'_, '_>,
92    ctes: &mut CteScope<S>,
93) -> Result<(), SQLError> {
94    let TargetSelectPrivilegeRequest {
95        table,
96        privilege_subject,
97        target_qualifier,
98        returning_aliases,
99        expressions,
100        subqueries,
101        required_columns,
102    } = request;
103    let relation =
104        uqa_core::RelationIdentity::from_legacy_name(table).map_err(SQLError::Internal)?;
105    let target_qualifiers = BTreeSet::from([
106        target_qualifier.to_string(),
107        table.to_string(),
108        relation.name,
109        returning_aliases.old.clone(),
110        returning_aliases.new.clone(),
111    ]);
112    ctes.scalar_subqueries = subqueries.to_vec();
113    if let Some(subject) = privilege_subject {
114        let scope = ctes.enter_privilege_subject(subject.clone());
115        ensure_select_privileges_for_table_expressions(
116            table,
117            &target_qualifiers,
118            expressions,
119            subqueries,
120            required_columns,
121            &scope,
122        )
123    } else {
124        ensure_select_privileges_for_table_expressions(
125            table,
126            &target_qualifiers,
127            expressions,
128            subqueries,
129            required_columns,
130            ctes,
131        )
132    }
133}