Skip to main content

uqa_execution/mutation/
dispatch.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Resolve mutation execution paths using SQL view rewriting and execution-owned command loops.
8use super::{insert::table::InsertPlanning, views::commands::SourceOutputPruning};
9use crate::mutation::output::MutationOutput;
10use crate::mutation::statement::context::MutationStatementContext;
11use crate::query::CteScope;
12use uqa_sql::{
13    plan::{DeletePlan, InsertPlan, MergePlan, UpdatePlan},
14    semantics::{view_privileges, view_rewrite},
15    SQLError, SQLParam,
16};
17
18pub fn run_insert<S: Clone + Send + Sync + 'static>(
19    context: &MutationStatementContext<'_, S>,
20    planning: InsertPlanning<'_>,
21    stmt: &InsertPlan,
22    params: &[SQLParam],
23    inherited_ctes: Option<&CteScope<S>>,
24) -> Result<MutationOutput, SQLError> {
25    let rewrite = context.mutation.rules.views.rewrite;
26    if let Some(kind) = rewrite.catalog.target_view_kind(&stmt.table)? {
27        if kind == uqa_sql::catalog::view::StoredViewKind::Materialized {
28            let _ = view_privileges::ensure_insert(rewrite.authorization, stmt)?;
29            let relation = uqa_core::RelationIdentity::from_legacy_name(&stmt.table)
30                .map_err(SQLError::Internal)?;
31            return Err(SQLError::Routine {
32                sqlstate: "42809".into(),
33                message: format!("cannot change materialized view \"{}\"", relation.name),
34            });
35        }
36        if view_rewrite::has_instead_of_trigger(
37            rewrite,
38            &stmt.table,
39            uqa_sql::ast::TriggerEvent::Insert,
40        )? || uqa_sql::semantics::rules::analysis::relation_suppresses_original_query(
41            context.mutation.rules.rules.analysis,
42            &stmt.table,
43            uqa_sql::ast::RuleEvent::Insert,
44        )? {
45            let _ = view_privileges::ensure_insert(rewrite.authorization, stmt)?;
46            let expanded = set_returning_values_query(context, stmt)?;
47            let stmt = expanded.as_ref().unwrap_or(stmt);
48            super::routine_calls::insert(context, stmt, params, inherited_ctes)?;
49            return super::views::commands::run_view_insert_inner(
50                context,
51                planning.prune_source_outputs,
52                stmt,
53                params,
54                inherited_ctes,
55            );
56        }
57        let bindings = inherited_ctes
58            .map(crate::query::binding::binding_context)
59            .transpose()?
60            .map(uqa_sql::binding::snapshot::BindingSnapshot::from);
61        let rewritten =
62            view_rewrite::rewrite_insert_to_base(rewrite, stmt, params, bindings.as_ref())?;
63        return run_insert(context, planning, &rewritten, params, inherited_ctes);
64    }
65    let expanded = set_returning_values_query(context, stmt)?;
66    crate::mutation::insert::table::run_table_insert(
67        context,
68        planning,
69        expanded.as_ref().unwrap_or(stmt),
70        params,
71        inherited_ctes,
72    )
73}
74
75/// A single VALUES row runs as a target list, so its set-returning calls insert one row per result; the INSERT then takes its `INSERT ... SELECT` form. The target's own rewrite rules decide whether they read such an entry.
76fn set_returning_values_query<S: Clone + Send + Sync + 'static>(
77    context: &MutationStatementContext<'_, S>,
78    stmt: &InsertPlan,
79) -> Result<Option<InsertPlan>, SQLError> {
80    uqa_sql::semantics::insert_values::single_row_values_query(
81        context.query.source.ctes.routines,
82        stmt,
83        || {
84            uqa_sql::semantics::rules::analysis::relation_rule_row_columns(
85                context.mutation.rules.rules.analysis,
86                &stmt.table,
87                uqa_sql::ast::RuleEvent::Insert,
88            )
89        },
90        || {
91            uqa_sql::semantics::insert_values::implicit_target_columns(
92                context.mutation.rules.views.rewrite,
93                &stmt.table,
94            )
95        },
96    )
97}
98
99pub fn run_update<S: Clone + Send + Sync + 'static>(
100    context: &MutationStatementContext<'_, S>,
101    prune: SourceOutputPruning,
102    stmt: &UpdatePlan,
103    params: &[SQLParam],
104    inherited_ctes: Option<&CteScope<S>>,
105) -> Result<MutationOutput, SQLError> {
106    let rewrite = context.mutation.rules.views.rewrite;
107    if let Some(kind) = rewrite.catalog.target_view_kind(&stmt.table)? {
108        if kind == uqa_sql::catalog::view::StoredViewKind::Materialized {
109            let _ = view_privileges::ensure_update(rewrite.authorization, stmt)?;
110            let relation = uqa_core::RelationIdentity::from_legacy_name(&stmt.table)
111                .map_err(SQLError::Internal)?;
112            return Err(SQLError::Routine {
113                sqlstate: "42809".into(),
114                message: format!("cannot change materialized view \"{}\"", relation.name),
115            });
116        }
117        if view_rewrite::has_instead_of_trigger(
118            rewrite,
119            &stmt.table,
120            uqa_sql::ast::TriggerEvent::Update,
121        )? || uqa_sql::semantics::rules::analysis::relation_suppresses_original_query(
122            context.mutation.rules.rules.analysis,
123            &stmt.table,
124            uqa_sql::ast::RuleEvent::Update,
125        )? {
126            let _ = view_privileges::ensure_update(rewrite.authorization, stmt)?;
127            super::routine_calls::update(context, stmt, params, inherited_ctes)?;
128            return super::views::commands::run_view_update_inner(
129                context,
130                prune,
131                stmt,
132                params,
133                inherited_ctes,
134            );
135        }
136        let bindings = inherited_ctes
137            .map(crate::query::binding::binding_context)
138            .transpose()?
139            .map(uqa_sql::binding::snapshot::BindingSnapshot::from);
140        let rewritten =
141            view_rewrite::rewrite_update_to_base(rewrite, stmt, params, bindings.as_ref())?;
142        return run_update(context, prune, &rewritten, params, inherited_ctes);
143    }
144    crate::mutation::update::table::run_table_update(context, stmt, params, inherited_ctes)
145}
146
147pub fn run_delete<S: Clone + Send + Sync + 'static>(
148    context: &MutationStatementContext<'_, S>,
149    prune: SourceOutputPruning,
150    stmt: &DeletePlan,
151    params: &[SQLParam],
152    inherited_ctes: Option<&CteScope<S>>,
153) -> Result<MutationOutput, SQLError> {
154    let rewrite = context.mutation.rules.views.rewrite;
155    if let Some(kind) = rewrite.catalog.target_view_kind(&stmt.table)? {
156        if kind == uqa_sql::catalog::view::StoredViewKind::Materialized {
157            let _ = view_privileges::ensure_delete(rewrite.authorization, stmt)?;
158            let relation = uqa_core::RelationIdentity::from_legacy_name(&stmt.table)
159                .map_err(SQLError::Internal)?;
160            return Err(SQLError::Routine {
161                sqlstate: "42809".into(),
162                message: format!("cannot change materialized view \"{}\"", relation.name),
163            });
164        }
165        if view_rewrite::has_instead_of_trigger(
166            rewrite,
167            &stmt.table,
168            uqa_sql::ast::TriggerEvent::Delete,
169        )? || uqa_sql::semantics::rules::analysis::relation_suppresses_original_query(
170            context.mutation.rules.rules.analysis,
171            &stmt.table,
172            uqa_sql::ast::RuleEvent::Delete,
173        )? {
174            let _ = view_privileges::ensure_delete(rewrite.authorization, stmt)?;
175            super::routine_calls::delete(context, stmt, params, inherited_ctes)?;
176            return super::views::commands::run_view_delete_inner(
177                context,
178                prune,
179                stmt,
180                params,
181                inherited_ctes,
182            );
183        }
184        let bindings = inherited_ctes
185            .map(crate::query::binding::binding_context)
186            .transpose()?
187            .map(uqa_sql::binding::snapshot::BindingSnapshot::from);
188        let rewritten =
189            view_rewrite::rewrite_delete_to_base(rewrite, stmt, params, bindings.as_ref())?;
190        return run_delete(context, prune, &rewritten, params, inherited_ctes);
191    }
192    crate::mutation::delete::run_table_delete(context, stmt, params, inherited_ctes)
193}
194
195pub fn run_merge<S: Clone + Send + Sync + 'static>(
196    context: &MutationStatementContext<'_, S>,
197    prune: SourceOutputPruning,
198    stmt: &MergePlan,
199    params: &[SQLParam],
200    inherited_ctes: Option<&CteScope<S>>,
201) -> Result<MutationOutput, SQLError> {
202    let rewrite = context.mutation.rules.views.rewrite;
203    if rewrite.catalog.target_view_kind(&stmt.target)?.is_some() {
204        let scope = super::merge::analysis::merge_analysis_scope(
205            context.mutation.scopes,
206            stmt,
207            inherited_ctes,
208        )?;
209        let bindings = crate::query::binding::binding_context(&scope)?;
210        let source = uqa_sql::binding::analyze_source_plan_schema(
211            rewrite.routines,
212            &stmt.source,
213            params,
214            &bindings,
215            None,
216        )?;
217        view_rewrite::validate_public_merge_targets(rewrite, stmt)?;
218        view_rewrite::validate_public_merge_contract(rewrite, stmt, &source)?;
219        return match view_rewrite::merge_view_target_path(rewrite, stmt)? {
220            view_rewrite::MergeViewTargetPath::AutomaticRewrite => {
221                let inherited = inherited_ctes
222                    .map(crate::query::binding::binding_context)
223                    .transpose()?
224                    .map(uqa_sql::binding::snapshot::BindingSnapshot::from);
225                let rewritten =
226                    view_rewrite::rewrite_merge_to_base(rewrite, stmt, params, inherited.as_ref())?;
227                run_merge(context, prune, &rewritten, params, inherited_ctes)
228            }
229            view_rewrite::MergeViewTargetPath::ViewTriggers => {
230                let _ = view_privileges::ensure_merge(rewrite.authorization, stmt)?;
231                super::routine_calls::merge(context, stmt, params, inherited_ctes)?;
232                super::merge::views::run_view_merge(context, prune, stmt, params, inherited_ctes)
233            }
234        };
235    }
236    super::merge::table::run_table_merge(context, stmt, params, inherited_ctes)
237}