use super::{RuleContext, RuleExecutionGuard, RuleExecutionOutcome, RuleReturningRequest};
use crate::{
mutation::returning::ReturningRows,
query::{consumer::QueryRowConsumer, CteScope},
};
use std::rc::Rc;
use uqa_core::memory::ProductionControl;
use uqa_sql::{
ast::Statement,
binding::correlation::CorrelationContext,
semantics::rules::{
action_binding::{
rule_action_references_row_with_control, rule_action_target_columns_with_control,
ActionColumns, BoundRuleStatement,
},
binding::{OwnedMutationRuleInput, RuleMutation},
returning::validate_rule_returning_provider_width,
statement_has_returning,
},
SQLError, SQLParam,
};
pub fn execute_mutation_query_rules<S: Clone + 'static>(
context: &RuleContext<'_, S>,
statement: RuleMutation<'_>,
params: &[SQLParam],
scope: &CteScope<S>,
) -> Result<RuleExecutionOutcome, SQLError> {
let rules = context.capture_rules(statement.table(), statement.event())?;
let _guard = RuleExecutionGuard::enter(statement.table(), statement.event())?;
let rule_subject = context.security.privilege_subject(statement.table())?;
let input_subject = scope.privilege_subject()?;
let definitions = context.returning_columns(statement.table())?;
let request = context.returning_request(
statement.returning(),
statement.returning_aliases(),
statement.subqueries(),
)?;
let retained = context.statements.read_control()?;
let control = ProductionControl::new(
retained.memory(),
retained.cancellation(),
context.cancellation,
);
let binding = crate::query::binding::binding_context_with_control(scope, &control)?;
let (target_schema, source_schema) =
context.mutation_input_schemas(statement, params, &binding, &control)?;
let mut outcome = RuleExecutionOutcome::default();
for rule in rules.iter() {
let rule = rule?;
for action in &rule.definition.actions {
let target_columns = rule_action_target_columns_with_control(
context.analysis.sources,
action,
&control,
)?;
let references_event = rule_action_references_row_with_control(
context.analysis.sources,
action,
&*target_columns,
rule.definition.condition.as_ref(),
&control,
)?;
let mut input = OwnedMutationRuleInput::bind(
context.analysis,
CorrelationContext {
routines: context.returning.routines,
catalog: binding.catalog.as_ref(),
resolution: &binding.resolution,
scoped_relations: Some(scope),
},
statement,
(&target_schema, source_schema.as_ref()),
references_event,
input_subject,
&rule_subject,
&control,
)?;
let mut bound = BoundRuleStatement::bind(
context.analysis.sources,
action,
&*target_columns,
&mut input.resolver,
&control,
)?;
let condition = input.resolver.condition_with_control(
context.binding,
rule,
&definitions,
&rule_subject,
&control,
)?;
let consumer = returning_consumer(
context,
&definitions,
action,
statement.event(),
&mut bound,
request,
&*target_columns,
&input,
outcome.returning.is_some(),
)?;
let input = (!matches!(action, Statement::Notify { .. }))
.then(|| input.finish(condition, &control))
.transpose()?;
let result = context.execute_bound_action(
&bound,
input,
params,
scope,
&rule_subject,
consumer
.as_ref()
.map(|consumer| Rc::clone(consumer) as Rc<dyn QueryRowConsumer>),
)?;
super::query_inputs::complete_action(
&mut outcome,
statement.event(),
rule,
action,
result,
consumer,
)?;
}
}
Ok(outcome)
}
#[expect(
clippy::too_many_arguments,
reason = "keeps provider syntax, original event descriptors, and source context distinct"
)]
fn returning_consumer<'a, S: Clone + 'static>(
context: &RuleContext<'a, S>,
definitions: &'a [uqa_sql::ast::ColumnDef],
action: &Statement,
event: uqa_sql::ast::RuleEvent,
bound: &mut BoundRuleStatement,
request: RuleReturningRequest,
target_columns: &dyn ActionColumns,
input: &OwnedMutationRuleInput,
has_returning: bool,
) -> Result<Option<Rc<super::returning::RuleReturningConsumer<'a>>>, SQLError> {
if !request.captures() || !statement_has_returning(action) {
bound.clear_returning()?;
return Ok(None);
}
if has_returning {
return Err(SQLError::Routine {
sqlstate: "0A000".into(),
message: "cannot have RETURNING lists in multiple rules".into(),
});
}
let provider = uqa_sql::semantics::rules::returning::rule_action_returning_schema(
context.analysis.sources,
context.returning,
action,
event,
definitions,
)?;
validate_rule_returning_provider_width(provider.len(), definitions.len())?;
bound.augment_returning(None, definitions.len(), request, target_columns)?;
let context_schema = if matches!(action, Statement::Update(_) | Statement::Delete(_)) {
bound.append_returning_context(&input.source_context)?;
input.source_context_schema.clone()
} else {
None
};
Ok(Some(Rc::new(
super::returning::RuleReturningConsumer::new(
context.assignment,
definitions,
context.projection,
ReturningRows::with_budget(
context.memory.work_mem_bytes()?,
context.cancellation.clone(),
),
)
.with_context(context_schema),
)))
}