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