Skip to main content

uqa_engine/capabilities/
rules.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Capture rule namespaces and expression scopes for execution.
8use crate::Engine;
9use uqa_execution::{
10    mutation::rules::{RuleContext, RuleSecurity, RuleStatements},
11    statement::plan_executor::StatementOutput,
12};
13use uqa_sql::catalog::roles::RoleReference;
14use uqa_sql::{semantics::rules::analysis::RuleAnalysisContext, SQLError};
15impl Engine {
16    pub(crate) fn rule_analysis_context(&self) -> RuleAnalysisContext<'_> {
17        RuleAnalysisContext {
18            rules: self,
19            sources: self,
20            returning: self,
21            domains: self,
22            composites: uqa_sql::expr::EngineHook::composite_types(self),
23        }
24    }
25    pub(crate) fn rule_execution_context(
26        &self,
27    ) -> RuleContext<'_, crate::session::StatementReadSnapshot> {
28        let runtime = self.query_runtime_view();
29        RuleContext {
30            memory: runtime.settings,
31            cancellation: runtime.cancellation,
32            analysis: self.rule_analysis_context(),
33            binding: self.catalog_routine_analysis_context(),
34            security: self,
35            statements: self,
36            returning: self.returning_analysis_context(),
37            assignment: self,
38            projection: None,
39            volatility: self,
40        }
41    }
42}
43impl RuleSecurity for Engine {
44    fn privilege_subject(&self, table: &str) -> Result<RoleReference, SQLError> {
45        self.event_lookup_context().rule_privilege_subject(table)
46    }
47}
48impl RuleStatements<crate::session::StatementReadSnapshot> for Engine {
49    fn execute(
50        &self,
51        action: uqa_sql::semantics::rules::binding::RuleAction,
52        params: &[uqa_sql::SQLParam],
53        inherited_ctes: Option<
54            &uqa_execution::query::CteScope<crate::session::StatementReadSnapshot>,
55        >,
56        privilege_subject: &RoleReference,
57        consumer: Option<std::rc::Rc<dyn uqa_execution::query::consumer::QueryRowConsumer + '_>>,
58    ) -> Result<StatementOutput, SQLError> {
59        let planning = self.statement_planning_context();
60        let scopes = inherited_ctes.map(|parent| {
61            uqa_sql::binding::statements::InheritedStatementAnalysisScopes {
62                current: planning.analysis.scopes,
63                parent,
64            }
65        });
66        let planning = uqa_planner::statement_planning::executable::StatementPlanningContext {
67            analysis: uqa_sql::binding::statements::StatementAnalysisContext {
68                scopes: scopes
69                    .as_ref()
70                    .map_or(planning.analysis.scopes, |scope| scope),
71                ..planning.analysis
72            },
73            ..planning
74        };
75        let mut compiled = self.compiled_statement_context();
76        compiled.planning = &planning;
77        uqa_execution::statement::compiled::execute_output_with_privilege_subject(
78            &compiled,
79            action,
80            params,
81            inherited_ctes,
82            privilege_subject,
83            consumer,
84        )
85    }
86}
87
88impl Engine {
89    pub(crate) fn view_rule_execution_context(
90        &self,
91    ) -> uqa_execution::mutation::rules::ViewRuleContext<'_, crate::session::StatementReadSnapshot>
92    {
93        uqa_execution::mutation::rules::ViewRuleContext {
94            rules: self.rule_execution_context(),
95            views: self.view_rewrite_context(),
96        }
97    }
98}