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;
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,
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    super::rules::schedule::run_update(context, prune, stmt, params, inherited_ctes)
107}
108
109pub fn run_delete<S: Clone + Send + Sync + 'static>(
110    context: &MutationStatementContext<'_, S>,
111    prune: SourceOutputPruning,
112    stmt: &DeletePlan,
113    params: &[SQLParam],
114    inherited_ctes: Option<&CteScope<S>>,
115) -> Result<MutationOutput, SQLError> {
116    super::rules::schedule::run_delete(context, prune, stmt, params, inherited_ctes)
117}
118
119pub fn run_merge<S: Clone + Send + Sync + 'static>(
120    context: &MutationStatementContext<'_, S>,
121    prune: SourceOutputPruning,
122    stmt: &MergePlan,
123    params: &[SQLParam],
124    inherited_ctes: Option<&CteScope<S>>,
125) -> Result<MutationOutput, SQLError> {
126    let rewrite = context.mutation.rules.views;
127    if rewrite.catalog.target_view_kind(&stmt.target)?.is_some() {
128        let scope = super::merge::analysis::merge_analysis_scope(
129            context.mutation.scopes,
130            stmt,
131            inherited_ctes,
132        )?;
133        let bindings = crate::query::binding::binding_context(&scope)?;
134        let source = uqa_sql::binding::analyze_source_plan_schema(
135            rewrite.routines,
136            &stmt.source,
137            params,
138            &bindings,
139            None,
140        )?;
141        view_rewrite::validate_public_merge_targets(rewrite, stmt)?;
142        view_rewrite::validate_public_merge_contract(rewrite, stmt, &source)?;
143        return match view_rewrite::merge_view_target_path(rewrite, stmt)? {
144            view_rewrite::MergeViewTargetPath::AutomaticRewrite => {
145                let inherited = inherited_ctes
146                    .map(crate::query::binding::binding_context)
147                    .transpose()?
148                    .map(uqa_sql::binding::snapshot::BindingSnapshot::from);
149                let rewritten =
150                    view_rewrite::rewrite_merge_to_base(rewrite, stmt, params, inherited.as_ref())?;
151                run_merge(context, prune, &rewritten, params, inherited_ctes)
152            }
153            view_rewrite::MergeViewTargetPath::ViewTriggers => {
154                let _ = view_privileges::ensure_merge(rewrite.authorization, stmt)?;
155                super::routine_calls::merge(context, stmt, params, inherited_ctes)?;
156                super::merge::views::run_view_merge(context, prune, stmt, params, inherited_ctes)
157            }
158        };
159    }
160    super::merge::table::run_table_merge(context, stmt, params, inherited_ctes)
161}