1pub 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}