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