uqa_execution/query/
privileges.rs1pub 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<'_, &[QueryPlan]>) -> Result<T, SQLError>,
39) -> Result<T, SQLError> {
40 let catalog = ctes.catalog_read_view()?;
41 let scope = PrivilegeScope::borrowed(
42 &catalog,
43 ctes.relation_name_resolution()?,
44 ctes,
45 &ctes.scalar_subqueries,
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.into();
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}