uqa-execution 0.6.3

Volcano physical operators with row-batch pipelines
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Capture authorization analysis inputs from the statement scope.
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)
    })
}