Skip to main content

uqa_sql/semantics/rules/binding/actions/query/mutation/
original.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Original UPDATE/DELETE qualifications retain unevaluated rule inputs in the same admitted command namespace.
8
9use super::{OwnedMutationRuleInput, RuleMutation};
10use crate::{
11    ast::{BooleanTest, FunctionBinding, FunctionDispatch},
12    binding::stored_routines::analysis::CatalogRoutineAnalysisContext,
13    catalog::roles::RoleReference,
14    plan::{
15        CommandPlan, MutableCommandPlan, MutableExpressionPlan, OwnedScalarExpr, ScalarQueryArena,
16    },
17    production::Buffer,
18    semantics::rules::{
19        analysis::{rule_returning_columns_with_control, RuleAnalysisContext},
20        binding::OwnedRuleQueryResolver,
21    },
22    SQLError,
23};
24use uqa_core::memory::ProductionControl;
25
26impl RuleMutation<'_> {
27    /// Bind each conditional INSTEAD predicate without evaluating NEW assignments. Stored SQL errors remain lazy; admission and cancellation failures abort production immediately.
28    pub fn original_condition_with_control(
29        self,
30        context: RuleAnalysisContext<'_>,
31        binding: CatalogRoutineAnalysisContext<'_>,
32        subject: &RoleReference,
33        control: &ProductionControl<'_>,
34    ) -> Result<Option<MutableExpressionPlan>, SQLError> {
35        control.check()?;
36        let rules =
37            context
38                .rules
39                .capture_rules_with_control(self.table(), self.event(), control)?;
40        let definitions = rule_returning_columns_with_control(context, self.table(), control)?;
41        let mut resolver = OwnedRuleQueryResolver::from_mutation_with_control(
42            context,
43            self,
44            &definitions,
45            None,
46            None,
47            control,
48            Ok,
49        )?;
50        let mut predicates = Buffer::new(control);
51        let mut arena = ScalarQueryArena::copy_from(&[], control)?;
52        for rule in rules.iter() {
53            control.check()?;
54            let rule = rule?;
55            if !rule.definition.instead {
56                continue;
57            }
58            let Some(condition) =
59                resolver.condition_with_control(binding, rule, &definitions, subject, control)?
60            else {
61                continue;
62            };
63            let function = FunctionBinding::dispatched_with_control(
64                FunctionDispatch::BooleanTest(BooleanTest::IsNotTrue),
65                control,
66            )?;
67            let predicate = OwnedScalarExpr::call(
68                control.copy_text(&function.name)?,
69                Some(function),
70                std::iter::once(arena.append_expression(condition, control)?),
71                control,
72            )?;
73            predicates.push(predicate, control)?;
74        }
75        if predicates.is_empty() {
76            return Ok(None);
77        }
78        Ok(Some(MutableExpressionPlan::from_parts(
79            OwnedScalarExpr::boolean(predicates.into_iter(), true, control)?,
80            arena,
81            control,
82        )?))
83    }
84}
85
86impl OwnedMutationRuleInput {
87    /// A suppressing rule retires the original command before resolving its assignments. Conditional rules append one private predicate arena to the surviving command.
88    pub fn qualify_original(
89        context: RuleAnalysisContext<'_>,
90        statement: MutableCommandPlan,
91        binding: CatalogRoutineAnalysisContext<'_>,
92        subject: &RoleReference,
93        control: &ProductionControl<'_>,
94    ) -> Result<Option<MutableCommandPlan>, SQLError> {
95        control.check()?;
96        let input = match &*statement {
97            CommandPlan::Update(plan) => RuleMutation::Update(plan),
98            CommandPlan::Delete(plan) => RuleMutation::Delete(plan),
99            _ => {
100                return Err(SQLError::Internal(
101                    "original qualification requires UPDATE or DELETE".into(),
102                ))
103            }
104        };
105        let rules =
106            context
107                .rules
108                .capture_rules_with_control(input.table(), input.event(), control)?;
109        if rules.any(|rule| rule.definition.instead && rule.definition.condition.is_none())? {
110            return Ok(None);
111        }
112        let condition =
113            input.original_condition_with_control(context, binding, subject, control)?;
114        let Some(condition) = condition else {
115            return Ok(Some(statement));
116        };
117        Ok(Some(statement.map_predicate_input(
118            control,
119            |previous, arena| {
120                let condition = arena.append_expression(condition, control)?;
121                Ok(Some(match previous {
122                    Some(previous) => {
123                        OwnedScalarExpr::boolean([previous, condition].into_iter(), true, control)?
124                    }
125                    None => condition,
126                }))
127            },
128        )?))
129    }
130}