Skip to main content

uqa_execution/mutation/
update.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Prepare UPDATE row images, routing, transition events, and RETURNING before publication.
8use super::{
9    assignment::{validate_view_checks, ViewCheckContext},
10    constraints::{validate_key_constraints_with_previous, ConstraintStatement},
11    preparation::MutationPreparationContext,
12    prepared::PreparedDocumentRewrite,
13    referential::{prepare_partition_update_route, prepare_routed_document_rewrite},
14    returning::{build_returning_row, ReturningProjectionRow},
15    row_images::{MutationRowImage, MutationRowImages},
16    rows::{existing_tuple_metadata, new_tuple_metadata},
17    staging::stage_prepared_document_rewrite,
18    triggers::{fire_before_row_triggers, AfterRowTriggerEvent},
19};
20use crate::query::CteScope;
21use uqa_sql::{plan::UpdatePlan, SQLError, SQLParam};
22use uqa_storage::document_store::Document;
23
24pub struct PreparedUpdateRow {
25    pub rewrite: PreparedDocumentRewrite,
26    pub after_row_events: Vec<AfterRowTriggerEvent>,
27    pub returning: Option<crate::OwnedPhysicalRow>,
28    pub affected: bool,
29}
30
31#[expect(
32    clippy::too_many_arguments,
33    reason = "keeps DML row-image inputs aligned"
34)]
35#[expect(clippy::too_many_lines, reason = "preserves DML lock and event order")]
36pub fn prepare_update_row<S: Clone + 'static>(
37    context: MutationPreparationContext<'_, S>,
38    stmt: &UpdatePlan,
39    params: &[SQLParam],
40    snapshot_ctes: &CteScope<S>,
41    statement: ConstraintStatement<'_>,
42    storage_table: &str,
43    doc_id: uqa_core::DocId,
44    original_document: Document,
45    document: Document,
46    source_context: Option<&crate::OwnedPhysicalRow>,
47) -> Result<Option<PreparedUpdateRow>, SQLError> {
48    let Some(triggered_document) = fire_before_row_triggers(
49        &context.referential.triggers,
50        storage_table,
51        uqa_sql::ast::TriggerEvent::Update,
52        doc_id,
53        Some(&original_document),
54        Some(&document),
55        statement.columns,
56    )?
57    else {
58        return Ok(None);
59    };
60    let Some(route) = prepare_partition_update_route(
61        &context.referential,
62        statement,
63        storage_table,
64        doc_id,
65        &original_document,
66        triggered_document,
67        &stmt.table,
68        params,
69        stmt.include_descendants,
70        statement.columns,
71    )?
72    else {
73        return Ok(None);
74    };
75    let mut rewrite = prepare_routed_document_rewrite(
76        &context.referential,
77        storage_table,
78        doc_id,
79        original_document,
80        route,
81    )?;
82    let primary_key_doc_id = rewrite.relocation;
83    let rewritten_doc_id = rewrite
84        .destination
85        .as_ref()
86        .map(|(_, doc_id)| *doc_id)
87        .or(primary_key_doc_id)
88        .unwrap_or(rewrite.doc_id);
89    let rewritten_storage_table = rewrite
90        .destination
91        .as_ref()
92        .map_or_else(|| rewrite.table.clone(), |(table, _)| table.clone());
93    validate_key_constraints_with_previous(
94        context.referential.constraints,
95        &rewritten_storage_table,
96        &rewrite.new_document,
97        (rewritten_storage_table == rewrite.table).then_some(rewrite.doc_id),
98        (rewritten_storage_table == rewrite.table).then_some(&rewrite.old_document),
99    )?;
100    validate_view_checks(ViewCheckContext {
101        services: context.referential.assignment,
102        constraints: context.referential.constraints,
103        statement,
104        table: &stmt.table,
105        storage_table: &rewritten_storage_table,
106        target_qualifier: &stmt.target_qualifier,
107        doc_id: rewritten_doc_id,
108        document: &rewrite.new_document,
109        checks: &stmt.view_checks,
110        params,
111        scope: snapshot_ctes,
112    })?;
113    let affected = !rewrite.is_partition_move_delete();
114    let old_metadata = existing_tuple_metadata(
115        context.referential.assignment.rows,
116        &rewrite.table,
117        rewrite.doc_id,
118    )?;
119    let new_metadata = new_tuple_metadata(context.referential.assignment.rows)?;
120    let mut after_row_events = Vec::new();
121    let rewritten_doc_id = stage_prepared_document_rewrite(
122        context.staging,
123        &mut rewrite,
124        params,
125        statement,
126        Some(statement.columns),
127        &mut after_row_events,
128    )?;
129    let returning = if !affected || stmt.returning.is_empty() {
130        None
131    } else {
132        Some(build_returning_row(
133            context.returning,
134            ReturningProjectionRow {
135                table: &stmt.table,
136                target_qualifier: &stmt.target_qualifier,
137                images: MutationRowImages {
138                    old: Some(MutationRowImage {
139                        storage_table: rewrite.table.clone(),
140                        doc_id: rewrite.doc_id,
141                        document: &rewrite.old_document,
142                        metadata: old_metadata,
143                    }),
144                    new: Some(MutationRowImage {
145                        storage_table: rewritten_storage_table,
146                        doc_id: rewritten_doc_id,
147                        document: &rewrite.new_document,
148                        metadata: new_metadata,
149                    }),
150                },
151                aliases: &stmt.returning_aliases,
152                context: source_context,
153            },
154            &stmt.returning,
155            params,
156            snapshot_ctes,
157        )?)
158    };
159    Ok(Some(PreparedUpdateRow {
160        rewrite,
161        after_row_events,
162        returning,
163        affected,
164    }))
165}
166
167pub mod from;
168
169mod locked_rows;
170
171pub mod table;