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