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.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
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.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}