Skip to main content

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

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Condition bindings retain refreshed identities, original scopes and independently owned substitutions.
8
9use super::{insert_expression, OwnedRuleQueryResolver};
10use crate::{
11    ast::ColumnDef,
12    binding::stored_routines::analysis::CatalogRoutineAnalysisContext,
13    catalog::{events::StoredRule, roles::RoleReference},
14    plan::{
15        input_projection::substitute_expression_inputs_owned, ExpressionPlan,
16        MutableExecutablePlan, MutableExpressionPlan,
17    },
18    plpgsql::{RewriteReference, VariableResolver},
19    SQLError, ScalarExpr,
20};
21use uqa_core::memory::{OwnedMap, ProductionControl, ProductionMap};
22
23impl OwnedRuleQueryResolver {
24    pub fn condition_with_control(
25        &mut self,
26        catalog: CatalogRoutineAnalysisContext<'_>,
27        rule: &StoredRule,
28        columns: &[ColumnDef],
29        subject: &RoleReference,
30        control: &ProductionControl<'_>,
31    ) -> Result<Option<MutableExpressionPlan>, SQLError> {
32        control.check()?;
33        if rule.definition.condition.is_none() {
34            return Ok(None);
35        }
36        let (original, binding) = rule.bound_condition_plan().ok_or_else(|| {
37            SQLError::Internal("stored rule condition has not been analyzed".into())
38        })?;
39        let (binding, mut condition) = binding.refresh_columns_with_control(
40            columns,
41            original.copy_for_rewrite(control)?,
42            control,
43        )?;
44        if crate::semantics::rules::action_binding::rule_condition_plan_references_whole_row(
45            original,
46        ) {
47            condition = catalog.bind_rule_inputs_owned(
48                condition,
49                &binding,
50                &self.table,
51                columns,
52                control,
53            )?;
54        }
55        for index in 0..condition.queries().len() {
56            condition = condition.map_query(index, control, |query| {
57                let plan =
58                    MutableExecutablePlan::Query(query).mark_catalog_relations_bound(control)?;
59                let MutableExecutablePlan::Query(query) = plan else {
60                    unreachable!()
61                };
62                query.set_privilege_subject(Some(subject.clone_with_control(control)?), control)
63            })?;
64        }
65        let mut selected = ProductionMap::new(*control);
66        let mut inspect = |scalar: &ScalarExpr| {
67            scalar.try_visit(&mut |node| {
68                control.check()?;
69                if let ScalarExpr::InternalColumn(column) = node {
70                    if binding.column_name(*column).is_some() {
71                        selected.insert_copy(*column, ())?;
72                    }
73                }
74                Ok::<_, SQLError>(true)
75            })
76        };
77        inspect(condition.scalar())?;
78        for query in condition.queries() {
79            let mut result = Ok(());
80            query.visit_scalar_expressions(&mut |scalar| {
81                if result.is_ok() {
82                    result = inspect(scalar);
83                }
84            });
85            result?;
86        }
87        let mut replacements = OwnedMap::new();
88        for (column, ()) in &selected {
89            let side = if Some(column.relation()) == binding.old_relation() {
90                "old"
91            } else {
92                "new"
93            };
94            let name = binding
95                .column_name(*column)
96                .expect("condition binding owns its referenced column");
97            let expression = self
98                .rewrite_with_control(
99                    RewriteReference::Qualified {
100                        qualifier: side,
101                        column: name,
102                    },
103                    control,
104                )?
105                .ok_or_else(|| SQLError::UnknownColumn(format!("{side}.{name}")))?;
106            let expression = ExpressionPlan::lower_borrowed_for_rewrite(&expression, control)?;
107            let expression =
108                substitute_expression_inputs_owned(expression, &self.expressions, control)?;
109            insert_expression(
110                &mut replacements,
111                *column,
112                expression.finish(control)?,
113                control,
114            )?;
115        }
116        Ok(Some(substitute_expression_inputs_owned(
117            condition,
118            &replacements,
119            control,
120        )?))
121    }
122}