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