Skip to main content

uqa_execution/mutation/rules/
mutation_inputs.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Run UPDATE/DELETE rewrite actions as independent queries before their original mutation.
8
9use 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}