Skip to main content

uqa_sql/semantics/rules/binding/actions/query/
conditions.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Substitute native OLD/NEW expressions into the stored, analyzed condition.
8use super::{BTreeMap, RuleQueryResolver, SQLError, VariableResolver};
9use crate::{
10    ast::ColumnDef,
11    binding::stored_routines::analysis::CatalogRoutineAnalysisContext,
12    catalog::{events::StoredRule, roles::RoleReference},
13    plan::ExpressionPlan,
14};
15impl RuleQueryResolver {
16    pub fn condition(
17        &mut self,
18        catalog: CatalogRoutineAnalysisContext<'_>,
19        rule: &StoredRule,
20        columns: &[ColumnDef],
21        subject: &RoleReference,
22    ) -> Result<Option<ExpressionPlan>, SQLError> {
23        if rule.definition.condition.is_none() {
24            return Ok(None);
25        }
26        let (condition, binding) = rule.bound_condition_plan().ok_or_else(|| {
27            SQLError::Internal("stored rule condition has not been analyzed".into())
28        })?;
29        let mut condition = condition.clone();
30        let binding = binding.refresh_columns(
31            columns.iter().map(|column| column.name.clone()).collect(),
32            &mut condition,
33        );
34        if crate::semantics::rules::action_binding::rule_condition_plan_references_whole_row(
35            &condition,
36        ) {
37            catalog.bind_rule_inputs(&mut condition, &binding, &self.table, columns)?;
38        }
39        for query in &mut condition.subqueries {
40            crate::binding::stored_routines::mark_query_relations_bound(query);
41            query.relation_privilege_subject = Some(subject.clone());
42        }
43        let mut replacements = BTreeMap::new();
44        for column in binding.referenced_columns(&condition) {
45            let side = if Some(column.relation()) == binding.old_relation() {
46                "old"
47            } else {
48                "new"
49            };
50            let name = binding
51                .column_name(column)
52                .expect("condition binding owns its referenced column");
53            let expression = self
54                .rewrite_qualified(side, name)?
55                .ok_or_else(|| SQLError::UnknownColumn(format!("{side}.{name}")))?;
56            let mut expression = ExpressionPlan::lower(expression);
57            crate::plan::input_projection::substitute_expression_inputs(
58                &mut expression,
59                &self.expressions,
60            )?;
61            replacements.insert(column, expression);
62        }
63        crate::plan::input_projection::substitute_expression_inputs(&mut condition, &replacements)?;
64        Ok(Some(condition))
65    }
66}