uqa_execution/mutation/rules/
mutation_inputs.rs1use super::{RuleContext, RuleExecutionGuard, RuleExecutionOutcome, RuleReturningRequest};
10use crate::{
11 mutation::returning::ReturningRows,
12 query::{consumer::QueryRowConsumer, CteScope},
13};
14use std::rc::Rc;
15use uqa_core::memory::ProductionControl;
16use uqa_sql::{
17 ast::Statement,
18 binding::correlation::CorrelationContext,
19 semantics::rules::{
20 action_binding::{
21 rule_action_references_row_with_control, rule_action_target_columns_with_control,
22 ActionColumns, BoundRuleStatement,
23 },
24 binding::{OwnedMutationRuleInput, RuleMutation},
25 returning::validate_rule_returning_provider_width,
26 statement_has_returning,
27 },
28 SQLError, SQLParam,
29};
30
31pub fn execute_mutation_query_rules<S: Clone + 'static>(
32 context: &RuleContext<'_, S>,
33 statement: RuleMutation<'_>,
34 params: &[SQLParam],
35 scope: &CteScope<S>,
36) -> Result<RuleExecutionOutcome, SQLError> {
37 let rules = context.capture_rules(statement.table(), statement.event())?;
38 let _guard = RuleExecutionGuard::enter(statement.table(), statement.event())?;
39 let rule_subject = context.security.privilege_subject(statement.table())?;
40 let input_subject = scope.privilege_subject()?;
41 let definitions = context.returning_columns(statement.table())?;
42 let request = context.returning_request(
43 statement.returning(),
44 statement.returning_aliases(),
45 statement.subqueries(),
46 )?;
47 let retained = context.statements.read_control()?;
48 let control = ProductionControl::new(
49 retained.memory(),
50 retained.cancellation(),
51 context.cancellation,
52 );
53 let binding = crate::query::binding::binding_context_with_control(scope, &control)?;
54 let (target_schema, source_schema) =
55 context.mutation_input_schemas(statement, params, &binding, &control)?;
56 let mut outcome = RuleExecutionOutcome::default();
57 for rule in rules.iter() {
58 let rule = rule?;
59 for action in &rule.definition.actions {
60 let target_columns = rule_action_target_columns_with_control(
61 context.analysis.sources,
62 action,
63 &control,
64 )?;
65 let references_event = rule_action_references_row_with_control(
66 context.analysis.sources,
67 action,
68 &*target_columns,
69 rule.definition.condition.as_ref(),
70 &control,
71 )?;
72 let mut input = OwnedMutationRuleInput::bind(
73 context.analysis,
74 CorrelationContext {
75 routines: context.returning.routines,
76 catalog: binding.catalog.as_ref(),
77 resolution: &binding.resolution,
78 scoped_relations: Some(scope),
79 },
80 statement,
81 (&target_schema, source_schema.as_ref()),
82 references_event,
83 input_subject,
84 &rule_subject,
85 &control,
86 )?;
87 let mut bound = BoundRuleStatement::bind(
88 context.analysis.sources,
89 action,
90 &*target_columns,
91 &mut input.resolver,
92 &control,
93 )?;
94 let condition = input.resolver.condition_with_control(
95 context.binding,
96 rule,
97 &definitions,
98 &rule_subject,
99 &control,
100 )?;
101 let consumer = returning_consumer(
102 context,
103 &definitions,
104 action,
105 statement.event(),
106 &mut bound,
107 request,
108 &*target_columns,
109 &input,
110 outcome.returning.is_some(),
111 )?;
112 let input = (!matches!(action, Statement::Notify { .. }))
113 .then(|| input.finish(condition, &control))
114 .transpose()?;
115 let result = context.execute_bound_action(
116 &bound,
117 input,
118 params,
119 scope,
120 &rule_subject,
121 consumer
122 .as_ref()
123 .map(|consumer| Rc::clone(consumer) as Rc<dyn QueryRowConsumer>),
124 )?;
125
126 super::query_inputs::complete_action(
127 &mut outcome,
128 statement.event(),
129 rule,
130 action,
131 result,
132 consumer,
133 )?;
134 }
135 }
136 Ok(outcome)
137}
138
139#[expect(
140 clippy::too_many_arguments,
141 reason = "keeps provider syntax, original event descriptors, and source context distinct"
142)]
143fn returning_consumer<'a, S: Clone + 'static>(
144 context: &RuleContext<'a, S>,
145 definitions: &'a [uqa_sql::ast::ColumnDef],
146 action: &Statement,
147 event: uqa_sql::ast::RuleEvent,
148 bound: &mut BoundRuleStatement,
149 request: RuleReturningRequest,
150 target_columns: &dyn ActionColumns,
151 input: &OwnedMutationRuleInput,
152 has_returning: bool,
153) -> Result<Option<Rc<super::returning::RuleReturningConsumer<'a>>>, SQLError> {
154 if !request.captures() || !statement_has_returning(action) {
155 bound.clear_returning()?;
156 return Ok(None);
157 }
158 if has_returning {
159 return Err(SQLError::Routine {
160 sqlstate: "0A000".into(),
161 message: "cannot have RETURNING lists in multiple rules".into(),
162 });
163 }
164 let provider = uqa_sql::semantics::rules::returning::rule_action_returning_schema(
165 context.analysis.sources,
166 context.returning,
167 action,
168 event,
169 definitions,
170 )?;
171 validate_rule_returning_provider_width(provider.len(), definitions.len())?;
172 bound.augment_returning(None, definitions.len(), request, target_columns)?;
173 let context_schema = if matches!(action, Statement::Update(_) | Statement::Delete(_)) {
174 bound.append_returning_context(&input.source_context)?;
175 input.source_context_schema.clone()
176 } else {
177 None
178 };
179 Ok(Some(Rc::new(
180 super::returning::RuleReturningConsumer::new(
181 context.assignment,
182 definitions,
183 context.projection,
184 ReturningRows::with_budget(
185 context.memory.work_mem_bytes()?,
186 context.cancellation.clone(),
187 ),
188 )
189 .with_context(context_schema),
190 )))
191}