use super::{RuleContext, RuleExecutionGuard, RuleExecutionOutcome, RuleReturningRequest};
use crate::{
mutation::returning::ReturningRows, query::consumer::QueryRowConsumer,
statement::plan_executor::StatementOutput,
};
use std::{collections::BTreeSet, rc::Rc};
use uqa_sql::{
ast::{InternalRelationId, RuleEvent, Statement},
plan::InsertPlan,
semantics::rules::{
action_binding::{bind_rule_action, rule_action_target_columns},
binding::{RuleQueryInput, RuleQueryResolver},
clear_statement_returning,
returning::{augment_rule_returning_action, validate_rule_returning_provider_width},
statement_has_returning,
},
SQLError, SQLParam,
};
fn execute_insert_query_rules<S: Clone + 'static>(
context: &RuleContext<'_, S>,
insert: &InsertPlan,
params: &[SQLParam],
scope: &crate::query::CteScope<S>,
prune: crate::mutation::views::commands::SourceOutputPruning,
) -> Result<RuleExecutionOutcome, SQLError> {
let rules = context
.analysis
.rules
.rules_for(&insert.table, RuleEvent::Insert)?;
let _guard = RuleExecutionGuard::enter(&insert.table, RuleEvent::Insert)?;
let privilege_subject = context.security.privilege_subject(&insert.table)?;
let definitions = super::rule_returning_columns(context.analysis, &insert.table)?;
let request = RuleReturningRequest::from_plan(
&insert.returning,
&insert.returning_aliases,
&insert.subqueries,
);
let mut outcome = RuleExecutionOutcome::default();
for rule in rules {
for action in &rule.definition.actions {
let target_columns = rule_action_target_columns(context.analysis.sources, action)?;
let relation = InternalRelationId::allocate();
let mut resolver = RuleQueryResolver::from_insert(context.analysis, insert, relation)?;
let mut bound = bind_rule_action(
context.analysis.sources,
action,
&target_columns,
&mut resolver,
)?;
let condition =
resolver.condition(context.binding, &rule, &definitions, &privilege_subject)?;
let captures = request.captures() && statement_has_returning(action);
let consumer = if captures {
if outcome.returning.is_some() {
return Err(SQLError::Routine {
sqlstate: "0A000".into(),
message: "cannot have RETURNING lists in multiple rules".into(),
});
}
Some(returning_consumer(
context,
&definitions,
action,
&mut bound,
request,
&target_columns,
)?)
} else {
clear_statement_returning(&mut bound);
None
};
let input = if matches!(action, Statement::Notify { .. }) {
None
} else {
let required = resolver.input_columns(
context.analysis,
insert,
action,
rule.definition.condition.as_ref(),
&target_columns,
)?;
let query = copy_rule_input_query(context, insert, scope, required, prune)?;
Some(RuleQueryInput {
query,
inline: insert
.rule_values_input
.as_ref()
.is_some_and(uqa_sql::plan::RuleValuesInput::is_inline),
relation,
condition,
expressions: resolver.expressions,
})
};
let result = context.execute_action(
bound,
input,
params,
scope,
&privilege_subject,
consumer
.as_ref()
.map(|consumer| Rc::clone(consumer) as Rc<dyn QueryRowConsumer>),
)?;
complete_action(
&mut outcome,
RuleEvent::Insert,
&rule,
action,
result,
consumer,
)?;
}
}
Ok(outcome)
}
fn copy_rule_input_query<S: Clone + 'static>(
context: &RuleContext<'_, S>,
insert: &InsertPlan,
scope: &crate::query::CteScope<S>,
required: Option<(BTreeSet<usize>, usize)>,
prune: crate::mutation::views::commands::SourceOutputPruning,
) -> Result<uqa_sql::plan::QueryPlan, SQLError> {
let mut query = insert.source.as_deref().expect("query input").clone();
if let Some((positions, width)) = required {
prune(
context.volatility,
context.returning.routines,
&mut query,
&positions,
width,
&|name| insert.ctes.iter().any(|cte| cte.name == name) || scope.contains_cte_name(name),
)?;
}
Ok(query)
}
pub(super) fn complete_action(
outcome: &mut RuleExecutionOutcome,
event: RuleEvent,
rule: &uqa_sql::catalog::events::StoredRule,
action: &Statement,
result: StatementOutput,
consumer: Option<Rc<super::returning::RuleReturningConsumer<'_>>>,
) -> Result<(), SQLError> {
if rule.definition.instead
&& rule.definition.condition.is_none()
&& matches!(
(event, action),
(RuleEvent::Insert, Statement::Insert(_))
| (RuleEvent::Update, Statement::Update(_))
| (RuleEvent::Delete, Statement::Delete(_))
)
{
outcome.affected_rows = match &result {
StatementOutput::Mutation(result) => result.affected_rows,
StatementOutput::Command(result) => result.affected_rows,
StatementOutput::Query(_) => 0,
};
outcome.sets_command_tag = true;
}
if let Some(consumer) = consumer {
let StatementOutput::Mutation(result) = result else {
return Err(SQLError::Internal(
"rule RETURNING provider is not a mutation".into(),
));
};
let consumer = Rc::try_unwrap(consumer).map_err(|_| {
SQLError::Internal("completed rule action retained its row consumer".into())
})?;
outcome.returning = Some(consumer.finish(result.affected_rows));
}
Ok(())
}
fn returning_consumer<'a, S: Clone + 'static>(
context: &RuleContext<'a, S>,
definitions: &'a [uqa_sql::ast::ColumnDef],
action: &Statement,
bound: &mut Statement,
request: RuleReturningRequest,
target_columns: &BTreeSet<String>,
) -> Result<Rc<super::returning::RuleReturningConsumer<'a>>, SQLError> {
let provider = uqa_sql::semantics::rules::returning::rule_action_returning_schema(
context.analysis.sources,
context.returning,
action,
RuleEvent::Insert,
definitions,
)?;
validate_rule_returning_provider_width(provider.len(), definitions.len())?;
augment_rule_returning_action(bound, None, definitions.len(), request, target_columns)?;
Ok(Rc::new(super::returning::RuleReturningConsumer::new(
context.assignment,
definitions,
context.projection,
ReturningRows::with_budget(
context.memory.work_mem_bytes()?,
context.cancellation.clone(),
),
)))
}
pub fn run_insert_query_rules<S: Clone + 'static>(
rules: &RuleContext<'_, S>,
context: crate::mutation::returning::ReturningExecutionContext<'_, S>,
queries: &uqa_sql::semantics::rules::binding::InsertRuleQueries,
params: &[SQLParam],
scope: &crate::query::CteScope<S>,
prune: crate::mutation::views::commands::SourceOutputPruning,
) -> Result<crate::mutation::output::MutationOutput, SQLError> {
let mut output = None;
let mut affected = 0;
for insert in queries.relations.iter().rev() {
let projection = super::RuleOutputProjection::insert(context, insert, params, scope);
let outcome = execute_insert_query_rules(
&rules.with_projection(&projection),
insert,
params,
scope,
prune,
)?;
if outcome.sets_command_tag {
affected = outcome.affected_rows;
}
if let Some(returning) = outcome.returning {
if output.is_some() {
return Err(SQLError::Routine {
sqlstate: "0A000".into(),
message: "cannot have RETURNING lists in multiple rules".into(),
});
}
output = Some(returning.project(context, projection.shape)?);
}
}
Ok(output.unwrap_or_else(|| crate::mutation::output::MutationOutput::from_affected(affected)))
}