uqa_sql/plan/mutable/commands/
view_metadata.rs1use super::{CommandPlan, MutableCommandPlan, RewriteMemory, SQLError};
10use crate::{
11 plan::mutable::field_vectors::{FieldVector, OwnedFields},
12 plan::{
13 copy::Copying, OwnedScalarExpr, ScalarQueryArena, ViewCheckPlan, ViewRuleInsertPlan,
14 ViewRuleUpdatePlan,
15 },
16};
17use uqa_core::memory::{BudgetedVec, Produced, ProductionControl, ProductionVec};
18
19impl MutableCommandPlan {
20 pub fn prepend_view_check(
21 mut self,
22 view: Produced<String>,
23 control: &ProductionControl<'_>,
24 predicate: impl FnOnce(&mut ScalarQueryArena) -> Result<OwnedScalarExpr, SQLError>,
25 ) -> Result<Self, SQLError> {
26 self.assert_owner(control);
27 control.check()?;
28 let mut arena = self.take_mutation_arena()?;
29 let predicate = predicate(&mut arena)?;
30 self.restore_mutation_arena(arena)?;
31 let incoming = if let Some(mut copying) = Copying::for_rewrite(*control) {
32 let value = copying.owned_view_check(view, predicate)?;
33 OwnedFields {
34 value,
35 memory: Some(copying.into_rewrite_memory()),
36 }
37 } else {
38 OwnedFields {
39 value: ViewCheckPlan {
40 view: view.into_uncontrolled().expect("ordinary check name"),
41 predicate: predicate
42 .finish(control)?
43 .into_uncontrolled()
44 .expect("ordinary check predicate"),
45 },
46 memory: None,
47 }
48 };
49 let values = std::mem::take(checks(&mut self.command)?);
50 let memory = self
51 .memory
52 .as_mut()
53 .and_then(|memory| body(memory).field_mut("view_checks").take());
54 let replacement = FieldVector { values, memory }.insert(0, incoming, control)?;
55 *checks(&mut self.command)? = replacement.values;
56 if let Some(memory) = &mut self.memory {
57 *body(memory).field_mut("view_checks") = replacement.memory;
58 }
59 Ok(self)
60 }
61
62 pub fn record_view_update_inputs(
63 mut self,
64 relation: &str,
65 control: &ProductionControl<'_>,
66 ) -> Result<Self, SQLError> {
67 self.assert_owner(control);
68 control.check()?;
69 let CommandPlan::Update(plan) = &mut self.command else {
70 return Err(SQLError::Internal(
71 "view update inputs require UPDATE".into(),
72 ));
73 };
74 let mut assigned = ProductionVec::new(*control);
75 for name in plan
76 .assignments
77 .iter()
78 .flat_map(|assignment| assignment.target.column_names())
79 {
80 assigned.push_produced(control.copy_text(name)?)?;
81 }
82 let relation = control.copy_text(relation)?;
83 let assigned = assigned.finish()?;
84 let incoming = if let Some(mut copying) = Copying::for_rewrite(*control) {
85 let value = copying.owned_view_update_inputs(relation, assigned)?;
86 OwnedFields {
87 value,
88 memory: Some(copying.into_rewrite_memory()),
89 }
90 } else {
91 OwnedFields {
92 value: ViewRuleUpdatePlan {
93 relation: relation
94 .into_uncontrolled()
95 .expect("ordinary rule relation"),
96 assigned_columns: assigned.into_uncontrolled().expect("ordinary rule columns"),
97 input_columns: Vec::new(),
98 },
99 memory: None,
100 }
101 };
102 let index = plan.view_rule_update_plans.len();
103 let values = std::mem::take(&mut plan.view_rule_update_plans);
104 let memory = self
105 .memory
106 .as_mut()
107 .and_then(|memory| body(memory).field_mut("view_rule_update_plans").take());
108 let replacement = FieldVector { values, memory }.insert(index, incoming, control)?;
109 plan.view_rule_update_plans = replacement.values;
110 if let Some(memory) = &mut self.memory {
111 *body(memory).field_mut("view_rule_update_plans") = replacement.memory;
112 }
113 Ok(self)
114 }
115
116 pub fn finalize_view_update_inputs(
117 mut self,
118 control: &ProductionControl<'_>,
119 ) -> Result<Self, SQLError> {
120 self.assert_owner(control);
121 control.check()?;
122 let CommandPlan::Update(plan) = &mut self.command else {
123 return Err(SQLError::Internal(
124 "view update inputs require UPDATE".into(),
125 ));
126 };
127 for (index, input) in plan.view_rule_update_plans.iter_mut().enumerate() {
128 let mut columns = ProductionVec::new(*control);
129 for name in plan
130 .assignments
131 .iter()
132 .flat_map(|assignment| assignment.target.column_names())
133 {
134 columns.push_produced(control.copy_text(name)?)?;
135 }
136 let (columns, memory) = columns.finish()?.into_parts();
137 input.input_columns = columns;
138 if let Some(owner) = &mut self.memory {
139 *body(owner)
140 .field_mut("view_rule_update_plans")
141 .as_mut()
142 .expect("view rule updates")
143 .item_mut(index)
144 .as_mut()
145 .expect("view rule update")
146 .field_mut("input_columns") = memory.map(|direct| RewriteMemory::Fields {
147 fields: BudgetedVec::new(direct.budget()),
148 direct,
149 });
150 }
151 }
152 Ok(self)
153 }
154 pub fn record_view_insert_inputs(
155 mut self,
156 relation: &str,
157 control: &ProductionControl<'_>,
158 ) -> Result<Self, SQLError> {
159 self.assert_owner(control);
160 control.check()?;
161 let CommandPlan::Insert(plan) = &mut self.command else {
162 return Err(SQLError::Internal(
163 "view insert inputs require INSERT".into(),
164 ));
165 };
166 let mut assigned = ProductionVec::new(*control);
167 for name in plan.columns.iter().map(|target| target.column.as_str()) {
168 assigned.push_produced(control.copy_text(name)?)?;
169 }
170 let relation = control.copy_text(relation)?;
171 let assigned = assigned.finish()?;
172 let incoming = if let Some(mut copying) = Copying::for_rewrite(*control) {
173 let value = copying.owned_view_insert_inputs(relation, assigned)?;
174 OwnedFields {
175 value,
176 memory: Some(copying.into_rewrite_memory()),
177 }
178 } else {
179 OwnedFields {
180 value: ViewRuleInsertPlan {
181 relation: relation
182 .into_uncontrolled()
183 .expect("ordinary rule relation"),
184 supplied_columns: assigned.into_uncontrolled().expect("ordinary rule columns"),
185 input_columns: Vec::new(),
186 },
187 memory: None,
188 }
189 };
190 let index = plan.view_rule_insert_plans.len();
191 let values = std::mem::take(&mut plan.view_rule_insert_plans);
192 let memory = self
193 .memory
194 .as_mut()
195 .and_then(|memory| body(memory).field_mut("view_rule_insert_plans").take());
196 let replacement = FieldVector { values, memory }.insert(index, incoming, control)?;
197 plan.view_rule_insert_plans = replacement.values;
198 if let Some(memory) = &mut self.memory {
199 *body(memory).field_mut("view_rule_insert_plans") = replacement.memory;
200 }
201 Ok(self)
202 }
203
204 pub fn finalize_view_insert_inputs(
205 mut self,
206 control: &ProductionControl<'_>,
207 ) -> Result<Self, SQLError> {
208 self.assert_owner(control);
209 control.check()?;
210 let CommandPlan::Insert(plan) = &mut self.command else {
211 return Err(SQLError::Internal(
212 "view insert inputs require INSERT".into(),
213 ));
214 };
215 for (index, input) in plan.view_rule_insert_plans.iter_mut().enumerate() {
216 let mut columns = ProductionVec::new(*control);
217 for name in plan.columns.iter().map(|target| target.column.as_str()) {
218 columns.push_produced(control.copy_text(name)?)?;
219 }
220 let (columns, memory) = columns.finish()?.into_parts();
221 input.input_columns = columns;
222 if let Some(owner) = &mut self.memory {
223 *body(owner)
224 .field_mut("view_rule_insert_plans")
225 .as_mut()
226 .expect("view rule inserts")
227 .item_mut(index)
228 .as_mut()
229 .expect("view rule insert")
230 .field_mut("input_columns") = memory.map(|direct| RewriteMemory::Fields {
231 fields: BudgetedVec::new(direct.budget()),
232 direct,
233 });
234 }
235 }
236 Ok(self)
237 }
238}
239
240fn body(memory: &mut RewriteMemory) -> &mut RewriteMemory {
241 memory.field_mut("value0").as_mut().expect("mutation body")
242}
243
244fn checks(command: &mut CommandPlan) -> Result<&mut Vec<ViewCheckPlan>, SQLError> {
245 match command {
246 CommandPlan::Insert(plan) => Ok(&mut plan.view_checks),
247 CommandPlan::Update(plan) => Ok(&mut plan.view_checks),
248 CommandPlan::Merge(plan) => Ok(&mut plan.view_checks),
249 _ => Err(SQLError::Internal(
250 "view checks require INSERT, UPDATE or MERGE".into(),
251 )),
252 }
253}