uqa_sql/semantics/rules/binding/actions/query/mutation/
original.rs1use 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 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 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}