1use 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
75fn 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}