Skip to main content

uqa_sql/semantics/rules/binding/actions/query/
mutation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Unevaluated UPDATE and DELETE inputs retain their original namespaces and authority.
8
9use super::{
10    assignments, prepend, projection_block, BTreeMap, Expr, InternalRelationId, ProjectionPlan,
11    QueryPlan, RelationalPlan, RuleQueryInput, RuleQueryResolver, SQLError, ScalarExpr, SourcePlan,
12};
13use crate::{
14    ast::{BooleanTest, FunctionBinding, FunctionDispatch, FunctionOrderSyntax, RuleEvent},
15    binding::correlation::{expression_depends_on_outer_row, CorrelationContext},
16    catalog::roles::RoleReference,
17    plan::{CtePlan, DeletePlan, ExpressionPlan, UpdatePlan},
18    semantics::{rules::analysis::RuleAnalysisContext, view_rewrite::DeferredOuterRewrite},
19    ColumnIdentity, RowSchema,
20};
21
22#[derive(Clone, Copy)]
23pub enum RuleMutation<'a> {
24    Update(&'a UpdatePlan),
25    Delete(&'a DeletePlan),
26}
27
28macro_rules! field {
29    ($self:expr, $name:ident) => {
30        match $self {
31            RuleMutation::Update(plan) => &plan.$name,
32            RuleMutation::Delete(plan) => &plan.$name,
33        }
34    };
35}
36
37impl<'a> RuleMutation<'a> {
38    pub fn table(self) -> &'a str {
39        field!(self, table)
40    }
41
42    pub fn event(self) -> RuleEvent {
43        match self {
44            Self::Update(_) => RuleEvent::Update,
45            Self::Delete(_) => RuleEvent::Delete,
46        }
47    }
48
49    pub fn target_qualifier(self) -> &'a str {
50        field!(self, target_qualifier)
51    }
52
53    pub fn source(self) -> Option<&'a SourcePlan> {
54        field!(self, source).as_deref()
55    }
56
57    pub fn predicate(self) -> Option<&'a ScalarExpr> {
58        field!(self, predicate).as_ref()
59    }
60
61    pub fn subqueries(self) -> &'a [QueryPlan] {
62        field!(self, subqueries)
63    }
64
65    pub fn ctes(self) -> &'a [CtePlan] {
66        field!(self, ctes)
67    }
68
69    pub fn returning(self) -> &'a [ProjectionPlan] {
70        field!(self, returning)
71    }
72
73    pub fn returning_aliases(self) -> &'a crate::ast::ReturningAliases {
74        field!(self, returning_aliases)
75    }
76
77    pub fn target_source(self) -> SourcePlan {
78        SourcePlan::Table {
79            name: self.table().to_owned(),
80            executable_query: None,
81            qualifier: self.target_qualifier().to_owned(),
82            alias: field!(self, target_alias).clone(),
83            column_aliases: Vec::new(),
84            bound_columns: None,
85            include_descendants: *field!(self, include_descendants),
86        }
87    }
88
89    fn relations_bound(self) -> bool {
90        *field!(self, relations_bound)
91    }
92
93    /// Each conditional INSTEAD rule contributes its own unevaluated negative qualification to the original command.
94    pub fn original_condition(
95        self,
96        context: RuleAnalysisContext<'_>,
97        binding: crate::binding::stored_routines::analysis::CatalogRoutineAnalysisContext<'_>,
98        subject: &RoleReference,
99    ) -> Result<Option<ExpressionPlan>, SQLError> {
100        let rules = context.rules.rules_for(self.table(), self.event())?;
101        let mut resolver = resolver(context, self, None, None)?;
102        let definitions =
103            crate::semantics::rules::analysis::rule_returning_columns(context, self.table())?;
104        let mut predicates = Vec::new();
105        let mut subqueries = Vec::new();
106        for rule in rules.iter().filter(|rule| rule.definition.instead) {
107            let Some(condition) = resolver.condition(binding, rule, &definitions, subject)? else {
108                continue;
109            };
110            let binding =
111                FunctionBinding::dispatched(FunctionDispatch::BooleanTest(BooleanTest::IsNotTrue));
112            predicates.push(ScalarExpr::Func {
113                name: binding.name.clone(),
114                binding: Some(binding),
115                args: vec![crate::plan::input_projection::append_expression(
116                    &mut subqueries,
117                    condition,
118                )],
119                order_syntax: FunctionOrderSyntax::Ordinary,
120                distinct: false,
121                order_by: Vec::new(),
122                filter: None,
123            });
124        }
125        if predicates.is_empty() {
126            return Ok(None);
127        }
128        let expression = ExpressionPlan {
129            scalar: ScalarExpr::And(predicates),
130            subqueries,
131        };
132        Ok(Some(expression))
133    }
134}
135
136/// Raw event attributes and FROM/USING attributes cross separate private boundaries. NEW assignment expressions stay outside those boundaries and are copied at each reference.
137pub struct MutationRuleInput {
138    pub resolver: RuleQueryResolver,
139    pub input: RuleQueryInput,
140    pub source_context: Vec<Expr>,
141    pub source_context_schema: Option<RowSchema>,
142}
143
144impl MutationRuleInput {
145    pub fn qualify_update_original(
146        context: RuleAnalysisContext<'_>,
147        statement: &mut UpdatePlan,
148        binding: crate::binding::stored_routines::analysis::CatalogRoutineAnalysisContext<'_>,
149        subject: &RoleReference,
150    ) -> Result<bool, SQLError> {
151        if crate::semantics::rules::analysis::relation_suppresses_original_query(
152            context,
153            &statement.table,
154            RuleEvent::Update,
155        )? {
156            return Ok(false);
157        }
158        let condition =
159            RuleMutation::Update(statement).original_condition(context, binding, subject)?;
160        super::add_native_condition(
161            &mut statement.predicate,
162            &mut statement.subqueries,
163            condition,
164        );
165        Ok(true)
166    }
167
168    pub fn qualify_delete_original(
169        context: RuleAnalysisContext<'_>,
170        statement: &mut DeletePlan,
171        binding: crate::binding::stored_routines::analysis::CatalogRoutineAnalysisContext<'_>,
172        subject: &RoleReference,
173    ) -> Result<bool, SQLError> {
174        if crate::semantics::rules::analysis::relation_suppresses_original_query(
175            context,
176            &statement.table,
177            RuleEvent::Delete,
178        )? {
179            return Ok(false);
180        }
181        let condition =
182            RuleMutation::Delete(statement).original_condition(context, binding, subject)?;
183        super::add_native_condition(
184            &mut statement.predicate,
185            &mut statement.subqueries,
186            condition,
187        );
188        Ok(true)
189    }
190
191    pub fn bind(
192        context: RuleAnalysisContext<'_>,
193        correlation: CorrelationContext<'_>,
194        statement: RuleMutation<'_>,
195        schemas: (&RowSchema, Option<&RowSchema>),
196        references_event: bool,
197        input_subject: &RoleReference,
198        rule_subject: &RoleReference,
199    ) -> Result<Self, SQLError> {
200        let (target_schema, source_schema) = schemas;
201        let relation = InternalRelationId::allocate();
202        let source_relation = InternalRelationId::allocate();
203        let captured = statement
204            .source()
205            .zip(source_schema)
206            .map(|(source, schema)| {
207                capture_source(statement, source, schema, source_relation, input_subject)
208            });
209        let empty_columns = BTreeMap::new();
210        let source_columns = captured
211            .as_ref()
212            .map_or(&empty_columns, |source| &source.columns);
213        let definitions =
214            crate::semantics::rules::analysis::rule_returning_columns(context, statement.table())?;
215        let target_width = definitions.len();
216        let rewrite = input_rewrite(
217            statement,
218            &definitions,
219            source_schema,
220            relation,
221            source_relation,
222            target_schema,
223        );
224        let mut resolver = resolver(context, statement, Some(relation), Some(&rewrite))?;
225        for expression in resolver.expressions.values_mut() {
226            bind_positions(expression, relation, source_relation, target_width);
227            crate::plan::input_projection::substitute_expression_inputs(
228                expression,
229                source_columns,
230            )?;
231            super::values::retain_authority(&mut expression.subqueries, Some(input_subject));
232        }
233        let mut predicate = statement.predicate().map(|scalar| ExpressionPlan {
234            scalar: scalar.clone(),
235            subqueries: statement.subqueries().to_vec(),
236        });
237        let needs_target = references_event
238            || predicate.as_ref().is_some_and(|expression| {
239                let mut found = false;
240                expression.scalar.visit(&mut |node| {
241                found |= matches!(node, ScalarExpr::Position(position) if *position < target_width);
242            });
243                found
244            })
245            || predicate
246                .as_ref()
247                .map(|expression| {
248                    expression_depends_on_outer_row(
249                        correlation,
250                        expression,
251                        statement.source(),
252                        statement.ctes(),
253                    )
254                })
255                .transpose()?
256                .unwrap_or(false);
257        if let Some(expression) = &mut predicate {
258            bind_positions(expression, relation, source_relation, target_width);
259            rewrite.bind_expression(expression);
260            crate::plan::input_projection::substitute_expression_inputs(
261                expression,
262                source_columns,
263            )?;
264            crate::plan::subqueries::prune_expression(expression);
265            super::values::retain_authority(&mut expression.subqueries, Some(input_subject));
266        }
267        let target = needs_target.then(|| {
268            target_source(
269                statement,
270                &definitions,
271                target_schema,
272                relation,
273                rule_subject,
274            )
275        });
276        let mut block = projection_block(Vec::new());
277        // FROM/USING is the outer side of the event relation cross product, before mutation de-duplication.
278        let (source, source_context, source_context_schema) = captured.map_or_else(
279            || (None, Vec::new(), None),
280            |source| (Some(source.source), source.context, Some(source.schema)),
281        );
282        block.from = prepend(target, source);
283        super::add_native_condition(&mut block.r#where, &mut block.subqueries, predicate);
284        Ok(Self {
285            resolver,
286            input: RuleQueryInput {
287                query: query(block, statement.relations_bound(), input_subject),
288                inline: true,
289                relation,
290                condition: None,
291                expressions: BTreeMap::new(),
292            },
293            source_context,
294            source_context_schema,
295        })
296    }
297
298    pub fn finish(mut self, condition: Option<ExpressionPlan>) -> RuleQueryInput {
299        self.input.condition = condition;
300        self.input.expressions = self.resolver.expressions;
301        self.input
302    }
303}
304
305struct CapturedMutationSource {
306    source: SourcePlan,
307    columns: BTreeMap<crate::ast::InternalColumnRef, ExpressionPlan>,
308    context: Vec<Expr>,
309    schema: RowSchema,
310}
311
312fn capture_source(
313    statement: RuleMutation<'_>,
314    source: &SourcePlan,
315    schema: &RowSchema,
316    relation: InternalRelationId,
317    subject: &RoleReference,
318) -> CapturedMutationSource {
319    let mut block = projection_block(
320        (0..schema.len())
321            .map(|position| ProjectionPlan {
322                expr: ScalarExpr::Position(position),
323                alias: Some(schema.columns()[position].clone()),
324            })
325            .collect(),
326    );
327    block.from = Some(source.clone());
328    block
329        .projections
330        .extend(source_whole_rows(schema).map(|qualifier| ProjectionPlan {
331            expr: ScalarExpr::Column(qualifier.into()),
332            alias: None,
333        }));
334    block.projections.extend(virtual_projections(schema));
335    let mut slots: BTreeMap<_, _> = (0..schema.len())
336        .filter_map(|position| schema.physical_slot(position).map(|slot| (slot, position)))
337        .collect();
338    for (identity, slot) in schema.lookup_aliases() {
339        if let Some(slot) = slot {
340            slots.entry(slot).or_insert_with(|| {
341                let position = block.projections.len();
342                block.projections.push(ProjectionPlan {
343                    expr: identity.qualifier().map_or_else(
344                        || ScalarExpr::Column(identity.column().into()),
345                        |qualifier| ScalarExpr::qualified_column(qualifier, identity.column()),
346                    ),
347                    alias: None,
348                });
349                position
350            });
351        }
352    }
353    let mut columns = BTreeMap::new();
354    for (column, slot) in schema.internal_identities() {
355        let position = *slots.entry(slot).or_insert_with(|| {
356            let position = block.projections.len();
357            block.projections.push(ProjectionPlan {
358                expr: ScalarExpr::InternalColumn(column),
359                alias: None,
360            });
361            position
362        });
363        columns.insert(column, input_expression(relation, position));
364    }
365    block.subqueries = statement.subqueries().to_vec();
366    let (schema, context_slots) = schema.canonical_projection();
367    let context = context_slots
368        .into_iter()
369        .map(|slot| Expr::InternalColumn(relation.column(slots[&slot])))
370        .collect();
371    CapturedMutationSource {
372        source: capture(query(block, statement.relations_bound(), subject), relation),
373        columns,
374        context,
375        schema,
376    }
377}
378
379fn resolver(
380    context: RuleAnalysisContext<'_>,
381    statement: RuleMutation<'_>,
382    relation: Option<InternalRelationId>,
383    rewrite: Option<&DeferredOuterRewrite>,
384) -> Result<RuleQueryResolver, SQLError> {
385    let definitions =
386        crate::semantics::rules::analysis::rule_returning_columns(context, statement.table())?;
387    let mut resolver = RuleQueryResolver {
388        table: statement.table().to_owned(),
389        columns: Vec::new(),
390        old: BTreeMap::new(),
391        expressions: BTreeMap::new(),
392    };
393    for (position, column) in definitions.iter().enumerate() {
394        let old = relation.map_or_else(
395            || ScalarExpr::qualified_column(statement.target_qualifier(), &column.name),
396            |relation| ScalarExpr::InternalColumn(relation.column(position)),
397        );
398        let old_reference = InternalRelationId::allocate().column(0);
399        resolver
400            .old
401            .insert(column.name.clone(), Expr::InternalColumn(old_reference));
402        resolver.expressions.insert(
403            old_reference,
404            ExpressionPlan {
405                scalar: old.clone(),
406                subqueries: Vec::new(),
407            },
408        );
409        let expression = match statement {
410            RuleMutation::Update(update) => {
411                assignments::update_column_expression(context, update, column, old)
412            }
413            RuleMutation::Delete(_) => Ok(ExpressionPlan {
414                scalar: ScalarExpr::TypedLiteral {
415                    value: uqa_core::Value::Null,
416                    ty: column.ty.catalog_name(),
417                    bound_type: Some(column.ty.clone()),
418                    parameter_index: None,
419                    collation_oid: column.collation_oid,
420                    composite_source: None,
421                },
422                subqueries: Vec::new(),
423            }),
424        };
425        let expression = expression.map(|mut expression| {
426            let metadata = crate::semantics::rules::binding::RuleColumnMetadata {
427                ty: column.ty.clone(),
428                collation_oid: column.collation_oid,
429                uses_document_id: false,
430                position,
431            };
432            expression.scalar = metadata.bind_input(expression.scalar);
433            if let Some(rewrite) = rewrite {
434                rewrite.bind_expression(&mut expression);
435            }
436            let reference = InternalRelationId::allocate().column(0);
437            resolver.expressions.insert(reference, expression);
438            Expr::InternalColumn(reference)
439        });
440        resolver.columns.push((column.name.clone(), expression));
441    }
442    Ok(resolver)
443}
444
445fn input_expression(relation: InternalRelationId, position: usize) -> ExpressionPlan {
446    ExpressionPlan {
447        scalar: ScalarExpr::InternalColumn(relation.column(position)),
448        subqueries: Vec::new(),
449    }
450}
451
452fn bind_positions(
453    expression: &mut ExpressionPlan,
454    target: InternalRelationId,
455    source: InternalRelationId,
456    target_width: usize,
457) {
458    crate::plan::rewrite_scalar_expression(&mut expression.scalar, &mut |node| {
459        if let ScalarExpr::Position(position) = node {
460            *node = ScalarExpr::InternalColumn(if *position < target_width {
461                target.column(*position)
462            } else {
463                source.column(*position - target_width)
464            });
465        }
466    });
467}
468
469fn query(
470    block: crate::plan::QueryBlockPlan,
471    relations_bound: bool,
472    subject: &RoleReference,
473) -> QueryPlan {
474    QueryPlan {
475        analyzed_output: None,
476        analyzed_source: None,
477        analyzed_grouping: None,
478        relation_privilege_subject: Some(subject.clone()),
479        relations_bound,
480        ctes: Vec::new(),
481        root: RelationalPlan::QueryBlock(Box::new(block)),
482    }
483}
484
485fn capture(query: QueryPlan, relation: InternalRelationId) -> SourcePlan {
486    SourcePlan::Subquery {
487        captured_output: Some(relation),
488        lateral: false,
489        body: Box::new(query),
490        alias: None,
491        column_aliases: Vec::new(),
492    }
493}
494
495fn input_rewrite(
496    statement: RuleMutation<'_>,
497    definitions: &[crate::ast::ColumnDef],
498    source_schema: Option<&RowSchema>,
499    relation: InternalRelationId,
500    source_relation: InternalRelationId,
501    target_schema: &RowSchema,
502) -> DeferredOuterRewrite {
503    let mut names = BTreeMap::new();
504    names.insert(
505        ColumnIdentity::unqualified(statement.target_qualifier()),
506        input_expression(relation, definitions.len()),
507    );
508    for (position, column) in definitions.iter().enumerate() {
509        let expression = input_expression(relation, position);
510        names.insert(
511            ColumnIdentity::qualified(statement.target_qualifier(), &column.name),
512            expression.clone(),
513        );
514        names.insert(ColumnIdentity::unqualified(&column.name), expression);
515    }
516    capture_virtual_names(&mut names, target_schema, relation, definitions.len() + 1);
517    if let Some(schema) = source_schema {
518        for (position, qualifier) in source_whole_rows(schema).enumerate() {
519            names
520                .entry(ColumnIdentity::unqualified(&qualifier))
521                .or_insert_with(|| input_expression(source_relation, schema.len() + position));
522        }
523        for (position, identity) in schema.identities().iter().enumerate() {
524            names.insert(
525                identity.clone(),
526                input_expression(source_relation, position),
527            );
528            if schema.unqualified_position(identity.column()) == Some(position)
529                && !definitions
530                    .iter()
531                    .any(|column| column.name == identity.column())
532            {
533                names.insert(
534                    ColumnIdentity::unqualified(identity.column()),
535                    input_expression(source_relation, position),
536                );
537            }
538        }
539        capture_virtual_names(
540            &mut names,
541            schema,
542            source_relation,
543            schema.len() + source_whole_rows(schema).count(),
544        );
545    }
546    DeferredOuterRewrite::from_inputs(names)
547}
548
549fn target_source(
550    statement: RuleMutation<'_>,
551    definitions: &[crate::ast::ColumnDef],
552    schema: &RowSchema,
553    relation: InternalRelationId,
554    rule_subject: &RoleReference,
555) -> SourcePlan {
556    let mut block = projection_block(
557        definitions
558            .iter()
559            .map(|column| ProjectionPlan {
560                expr: ScalarExpr::qualified_column(statement.target_qualifier(), &column.name),
561                alias: Some(column.name.clone()),
562            })
563            .collect(),
564    );
565    block.from = Some(statement.target_source());
566    block.projections.push(ProjectionPlan {
567        expr: ScalarExpr::Column(statement.target_qualifier().into()),
568        alias: None,
569    });
570    block.projections.extend(virtual_projections(schema));
571    capture(
572        query(block, statement.relations_bound(), rule_subject),
573        relation,
574    )
575}
576
577fn virtual_projections(schema: &RowSchema) -> impl Iterator<Item = ProjectionPlan> + '_ {
578    schema
579        .typed_virtual_identities()
580        .filter_map(|(identity, _)| {
581            identity.qualifier().map(|qualifier| ProjectionPlan {
582                expr: ScalarExpr::qualified_column(qualifier, identity.column()),
583                alias: None,
584            })
585        })
586}
587
588fn capture_virtual_names(
589    names: &mut BTreeMap<ColumnIdentity, ExpressionPlan>,
590    schema: &RowSchema,
591    relation: InternalRelationId,
592    offset: usize,
593) {
594    for (position, (identity, _)) in schema
595        .typed_virtual_identities()
596        .filter(|(identity, _)| identity.qualifier().is_some())
597        .enumerate()
598    {
599        let expression = input_expression(relation, offset + position);
600        names.insert(identity.clone(), expression.clone());
601        names
602            .entry(ColumnIdentity::unqualified(identity.column()))
603            .or_insert(expression);
604    }
605}
606
607fn source_whole_rows(schema: &RowSchema) -> impl Iterator<Item = String> {
608    schema
609        .identities()
610        .iter()
611        .filter_map(|identity| identity.qualifier().map(str::to_owned))
612        .collect::<std::collections::BTreeSet<_>>()
613        .into_iter()
614}