pub mod routine_calls;
use super::CteScope;
use std::collections::BTreeSet;
use uqa_sql::catalog::roles::RoleReference;
use uqa_sql::semantics::privileges::{
self as logical,
context::{PrivilegeCteCatalog, PrivilegeScope},
};
use uqa_sql::{
plan::{CtePlan, QueryBlockPlan, QueryPlan, SourcePlan},
SQLError, ScalarExpr,
};
#[cfg(test)]
thread_local! {
pub(crate) static SELECT_CHECKS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
impl<S: Clone> PrivilegeCteCatalog for CteScope<S> {
fn is_visible_cte(&self, name: &str) -> bool {
self.is_visible_cte(name)
}
fn materialized_columns(&self, name: &str) -> Option<Vec<String>> {
self.materialized_for_scan(name)
.map(|rows| rows.row_schema().columns().to_vec())
}
fn materialized_columns_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<Option<uqa_core::memory::Produced<Vec<String>>>, SQLError> {
let Some(rows) = self.materialized_for_scan_with_control(name, control)? else {
return Ok(None);
};
let mut columns = uqa_core::memory::ProductionVec::new(*control);
for name in rows.row_schema().columns() {
columns.push_produced(control.copy_text(name)?)?;
}
Ok(Some(columns.finish()?))
}
fn is_visible_cte_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<bool, SQLError> {
self.is_visible_cte_with_control(name, control)
}
fn deferred_reference_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<Option<&CtePlan>, SQLError> {
self.deferred_reference_with_control(name, control)
}
fn deferred_reference(&self, name: &str) -> Option<&CtePlan> {
self.deferred_reference(name)
}
fn privilege_subject(&self) -> Result<&RoleReference, SQLError> {
self.privilege_subject()
}
}
pub(crate) fn with_scope<S: Clone, T>(
ctes: &CteScope<S>,
apply: impl FnOnce(&PrivilegeScope<'_, &[QueryPlan]>) -> Result<T, SQLError>,
) -> Result<T, SQLError> {
with_scope_with_control(
ctes,
&uqa_core::memory::ProductionControl::uncontrolled(),
apply,
)
}
fn with_scope_with_control<S: Clone, T>(
ctes: &CteScope<S>,
control: &uqa_core::memory::ProductionControl<'_>,
apply: impl FnOnce(&PrivilegeScope<'_, &[QueryPlan]>) -> Result<T, SQLError>,
) -> Result<T, SQLError> {
let catalog = ctes.catalog_read_view()?;
let scope = PrivilegeScope::borrowed_with_control(
&catalog,
ctes.relation_name_resolution_with_control(control)?,
ctes,
&ctes.scalar_subqueries,
control,
);
apply(&scope)
}
pub fn ensure_select_privileges_for_query_with_control<S: Clone>(
query: &QueryPlan,
ctes: &CteScope<S>,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<(), SQLError> {
with_scope_with_control(ctes, control, |scope| {
logical::ensure_select_privileges_for_query(query, scope)
})
}
pub fn ensure_select_privileges_for_query<S: Clone>(
query: &QueryPlan,
ctes: &CteScope<S>,
) -> Result<(), SQLError> {
with_scope(ctes, |scope| {
logical::ensure_select_privileges_for_query(query, scope)
})
}
pub fn ensure_select_privileges_for_query_block<S: Clone>(
statement: &QueryBlockPlan,
source: &SourcePlan,
ctes: &CteScope<S>,
) -> Result<(), SQLError> {
check_query_source(statement, source, ctes).map(|_| ())
}
pub(crate) fn check_query_source<'a, S: Clone>(
statement: &'a QueryBlockPlan,
source: &'a SourcePlan,
ctes: &CteScope<S>,
) -> Result<logical::coverage::SelectSourceCoverage<'a>, SQLError> {
#[cfg(test)]
SELECT_CHECKS.with(|count| count.set(count.get() + 1));
with_scope(ctes, |scope| {
logical::coverage::check_query_source(statement, source, scope)
})
}
pub fn ensure_select_privileges_for_source_expressions<S: Clone>(
source: &SourcePlan,
expressions: &[&ScalarExpr],
ctes: &CteScope<S>,
) -> Result<(), SQLError> {
ensure_select_privileges_for_source_expressions_with_control(
source,
expressions,
ctes,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
}
pub fn ensure_select_privileges_for_source_expressions_with_control<S: Clone>(
source: &SourcePlan,
expressions: &[&ScalarExpr],
ctes: &CteScope<S>,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<(), SQLError> {
with_scope_with_control(ctes, control, |scope| {
logical::ensure_select_privileges_for_source_expressions(source, expressions, scope)
})
}
pub fn ensure_select_privileges_for_table_expressions<S: Clone>(
table: &str,
qualifiers: &BTreeSet<String>,
expressions: &[&ScalarExpr],
subqueries: &[QueryPlan],
required_columns: &[String],
ctes: &CteScope<S>,
) -> Result<(), SQLError> {
with_scope(ctes, |scope| {
logical::ensure_select_privileges_for_table_expressions(
table,
qualifiers,
expressions,
subqueries,
required_columns,
scope,
)
})
}
use uqa_sql::semantics::privileges::TargetSelectPrivilegeRequest;
pub fn ensure_target_table_select_for_expressions<S: Clone>(
request: TargetSelectPrivilegeRequest<'_, '_>,
ctes: &CteScope<S>,
) -> Result<(), SQLError> {
ensure_target_table_select_for_expressions_with_control(
request,
ctes,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
}
pub fn ensure_target_table_select_for_expressions_with_control<S: Clone>(
request: TargetSelectPrivilegeRequest<'_, '_>,
ctes: &CteScope<S>,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<(), SQLError> {
with_scope_with_control(ctes, control, |scope| {
logical::ensure_target_select(request, scope)
})
}