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