1use super::super::analysis::QueryObserver;
10use super::super::{
11 nodes, CommandQuerySlot, MutableExecutablePlan, MutableQueryPlan, OwnedScalarExpr,
12 QueryChildSlot, RewriteMemory, SourceChildSlot,
13};
14use super::owner::ScalarQueryArena;
15use crate::{
16 plan::{
17 CommandPlan, CtePlan, CtePlanBody, ExpressionPlan, QueryPlan, RelationalPlan, SourcePlan,
18 UnifiedPlan,
19 },
20 SQLError, ScalarExpr,
21};
22use std::ptr::NonNull;
23use uqa_core::memory::ProductionControl;
24
25pub type ScalarArenaTransform<'a> = dyn FnMut(
26 NonNull<ScalarExpr>,
27 OwnedScalarExpr,
28 &mut ScalarQueryArena,
29 ) -> Result<OwnedScalarExpr, SQLError>
30 + 'a;
31
32impl MutableExecutablePlan {
33 pub fn transform_scalar_arenas(
35 mut self,
36 control: &ProductionControl<'_>,
37 transform: &mut ScalarArenaTransform<'_>,
38 ) -> Result<Self, SQLError> {
39 self.transform_scalar_arenas_in_place(control, transform)?;
40 Ok(self)
41 }
42
43 pub(crate) fn transform_scalar_arenas_in_place(
44 &mut self,
45 control: &ProductionControl<'_>,
46 transform: &mut ScalarArenaTransform<'_>,
47 ) -> Result<(), SQLError> {
48 self.transform_scalar_arenas_with_metadata(control, transform, &mut |_| {
49 Ok(crate::plan::QueryMetadataUpdate::default())
50 })
51 }
52
53 pub(crate) fn transform_scalar_arenas_with_metadata(
55 &mut self,
56 control: &ProductionControl<'_>,
57 transform: &mut ScalarArenaTransform<'_>,
58 complete: &mut QueryObserver<'_>,
59 ) -> Result<(), SQLError> {
60 let mut walker = Walker {
61 control,
62 transform,
63 complete,
64 };
65 match self {
66 Self::Query(query) => {
67 query.assert_owner(control);
68 walker.query(&mut query.query, query.memory.as_mut())
69 }
70 Self::Command(command) => {
71 command.assert_owner(control);
72 walker.command(&mut command.command, command.memory.as_mut())
73 }
74 }
75 }
76}
77
78impl MutableQueryPlan {
79 pub fn transform_scalar_arenas(
80 self,
81 control: &ProductionControl<'_>,
82 transform: &mut ScalarArenaTransform<'_>,
83 ) -> Result<Self, SQLError> {
84 let MutableExecutablePlan::Query(query) =
85 MutableExecutablePlan::Query(self).transform_scalar_arenas(control, transform)?
86 else {
87 unreachable!()
88 };
89 Ok(query)
90 }
91}
92
93struct Walker<'a, 'c, 't, 'q> {
94 control: &'a ProductionControl<'c>,
95 transform: &'a mut ScalarArenaTransform<'t>,
96 complete: &'a mut QueryObserver<'q>,
97}
98
99fn field<'a>(memory: Option<&'a mut RewriteMemory>, name: &str) -> Option<&'a mut RewriteMemory> {
100 memory.map(|memory| {
101 memory
102 .field_mut(name)
103 .as_mut()
104 .expect("arena constructor field")
105 })
106}
107
108fn item(memory: Option<&mut RewriteMemory>, index: usize) -> Option<&mut RewriteMemory> {
109 memory.map(|memory| {
110 memory
111 .item_mut(index)
112 .as_mut()
113 .expect("arena constructor item")
114 })
115}
116
117impl Walker<'_, '_, '_, '_> {
118 fn executable(
119 &mut self,
120 plan: &mut UnifiedPlan,
121 memory: Option<&mut RewriteMemory>,
122 ) -> Result<(), SQLError> {
123 match plan {
124 UnifiedPlan::Query(query) => self.query(query, field(memory, "query")),
125 UnifiedPlan::Command(command) => self.command(command, field(memory, "command")),
126 }
127 }
128
129 fn query(
130 &mut self,
131 query: &mut QueryPlan,
132 mut memory: Option<&mut RewriteMemory>,
133 ) -> Result<(), SQLError> {
134 self.control.check()?;
135 self.ctes(&mut query.ctes, field(memory.as_deref_mut(), "ctes"))?;
136 match &mut query.root {
137 RelationalPlan::QueryBlock(block) => {
138 if let Some(source) = &mut block.from {
139 let owner = memory.as_deref_mut().map(|memory| {
140 super::super::sources::query_source_memory(memory)
141 .as_mut()
142 .expect("query source")
143 });
144 self.source_children(source, owner)?;
145 }
146 }
147 RelationalPlan::SetOp { .. } => {
148 for slot in [QueryChildSlot::Left, QueryChildSlot::Right] {
149 let owner = memory
150 .as_deref_mut()
151 .map(|memory| slot.memory_mut(memory).as_mut().expect("set query"));
152 self.query(slot.query_mut(query), owner)?;
153 }
154 }
155 RelationalPlan::Values { .. } => {}
156 }
157 let count = query_arena(&mut query.root).len();
158 for index in 0..count {
159 let slot = QueryChildSlot::Subquery(index);
160 let owner = memory
161 .as_deref_mut()
162 .map(|memory| slot.memory_mut(memory).as_mut().expect("scalar query"));
163 self.query(slot.query_mut(query), owner)?;
164 }
165 let mut arena = ScalarQueryArena {
166 queries: std::mem::take(query_arena(&mut query.root)),
167 memory: memory
168 .as_deref_mut()
169 .and_then(|memory| query_memory(memory).take()),
170 };
171 let control = self.control;
172 let transform = &mut self.transform;
173 let mut action = |expression: &mut ScalarExpr,
174 memory: Option<&mut nodes::ScalarMemory>,
175 control: &ProductionControl<'_>| {
176 OwnedScalarExpr::transform_nodes_in_place(
177 expression,
178 memory,
179 control,
180 &mut |identity, expression| transform(identity, expression, &mut arena),
181 )
182 };
183 if let RelationalPlan::QueryBlock(block) = &mut query.root {
184 if let Some(source) = &mut block.from {
185 let owner = memory.as_deref_mut().map(|memory| {
186 super::super::sources::query_source_memory(memory)
187 .as_mut()
188 .expect("query source")
189 });
190 nodes::local_source(source, owner, control, &mut action)?;
191 }
192 }
193 nodes::query_scalars(query, memory.as_deref_mut(), false, control, &mut action)?;
194 *query_arena(&mut query.root) = arena.queries;
195 if let Some(memory) = memory.as_deref_mut() {
196 *query_memory(memory) = arena.memory;
197 }
198 (self.complete)(query)?.install(query, memory, control)
199 }
200
201 fn source_children(
202 &mut self,
203 source: &mut SourcePlan,
204 mut memory: Option<&mut RewriteMemory>,
205 ) -> Result<(), SQLError> {
206 self.control.check()?;
207 match source {
208 SourcePlan::Join { left, right, .. } => {
209 self.source_children(
210 left,
211 memory.as_deref_mut().map(|memory| {
212 SourceChildSlot::Left
213 .memory_mut(memory)
214 .as_mut()
215 .expect("left source")
216 }),
217 )?;
218 self.source_children(
219 right,
220 memory.map(|memory| {
221 SourceChildSlot::Right
222 .memory_mut(memory)
223 .as_mut()
224 .expect("right source")
225 }),
226 )?;
227 }
228 SourcePlan::Subquery { body, .. } => {
229 self.query(body, field(field(memory, "body"), "query"))?;
230 }
231 _ => {}
232 }
233 Ok(())
234 }
235
236 fn ctes(
237 &mut self,
238 ctes: &mut [CtePlan],
239 mut memory: Option<&mut RewriteMemory>,
240 ) -> Result<(), SQLError> {
241 for (index, cte) in ctes.iter_mut().enumerate() {
242 self.control.check()?;
243 let mut owner = item(memory.as_deref_mut(), index);
244 let body = field(owner.as_deref_mut(), "body");
245 match &mut cte.body {
246 CtePlanBody::Query(query) => self.query(query, field(body, "query"))?,
247 CtePlanBody::Command(command) => self.command(command, field(body, "command"))?,
248 }
249 if let Some(cycle) = &mut cte.cycle {
250 let mut owner = field(owner, "cycle");
251 self.scalar_without_arena(
252 &mut cycle.mark_value,
253 field(owner.as_deref_mut(), "mark_value"),
254 )?;
255 self.scalar_without_arena(&mut cycle.mark_default, field(owner, "mark_default"))?;
256 }
257 }
258 Ok(())
259 }
260
261 fn scalar_without_arena(
262 &mut self,
263 expression: &mut ScalarExpr,
264 memory: Option<&mut RewriteMemory>,
265 ) -> Result<(), SQLError> {
266 let mut arena = ScalarQueryArena {
267 queries: Vec::new(),
268 memory: None,
269 };
270 let memory = memory.map(|memory| nodes::scalar_memory(memory.scalar_mut()));
271 OwnedScalarExpr::transform_nodes_in_place(
272 expression,
273 memory,
274 self.control,
275 &mut |identity, expression| (self.transform)(identity, expression, &mut arena),
276 )
277 }
278
279 fn expression(
280 &mut self,
281 expression: &mut ExpressionPlan,
282 mut memory: Option<&mut RewriteMemory>,
283 ) -> Result<(), SQLError> {
284 for (index, query) in expression.subqueries.iter_mut().enumerate() {
285 let owner = field(
286 item(field(memory.as_deref_mut(), "subqueries"), index),
287 "query",
288 );
289 self.query(query, owner)?;
290 }
291 let mut arena = ScalarQueryArena {
292 queries: std::mem::take(&mut expression.subqueries),
293 memory: memory
294 .as_deref_mut()
295 .and_then(|memory| memory.field_mut("subqueries").take()),
296 };
297 let owner = memory
298 .as_deref_mut()
299 .map(|memory| nodes::scalar_memory(memory.scalar_mut()));
300 OwnedScalarExpr::transform_nodes_in_place(
301 &mut expression.scalar,
302 owner,
303 self.control,
304 &mut |identity, expression| (self.transform)(identity, expression, &mut arena),
305 )?;
306 expression.subqueries = arena.queries;
307 if let Some(memory) = memory {
308 *memory.field_mut("subqueries") = arena.memory;
309 }
310 Ok(())
311 }
312
313 fn command(
314 &mut self,
315 command: &mut CommandPlan,
316 mut memory: Option<&mut RewriteMemory>,
317 ) -> Result<(), SQLError> {
318 self.control.check()?;
319 if let Some(ctes) = command.ctes_mut() {
320 self.ctes(ctes, field(field(memory.as_deref_mut(), "value0"), "ctes"))?;
321 }
322 if let Some(source) = command.source_input_mut() {
323 let owner = memory.as_deref_mut().map(|memory| {
324 super::super::commands::children::source_memory(memory)
325 .as_mut()
326 .expect("command source")
327 });
328 self.source_children(source, owner)?;
329 }
330 if matches!(command, CommandPlan::Insert(_)) {
331 self.command_query(
332 command,
333 memory.as_deref_mut(),
334 CommandQuerySlot::InsertSource,
335 )?;
336 }
337 for index in 0..command.scalar_subqueries().len() {
338 self.command_query(
339 command,
340 memory.as_deref_mut(),
341 CommandQuerySlot::Subquery(index),
342 )?;
343 }
344 if let Some(queries) = command_arena(command) {
345 let mut arena = ScalarQueryArena {
346 queries: std::mem::take(queries),
347 memory: memory.as_deref_mut().and_then(|memory| {
348 field(Some(memory), "value0")
349 .expect("mutation body")
350 .field_mut("subqueries")
351 .take()
352 }),
353 };
354 let control = self.control;
355 let transform = &mut self.transform;
356 let mut local = |identity, expression| transform(identity, expression, &mut arena);
357 super::super::commands::transformation::transform_local_command(
358 command,
359 memory.as_deref_mut(),
360 control,
361 &mut local,
362 )?;
363 if let Some(source) = command.source_input_mut() {
364 let owner = memory.as_deref_mut().map(|memory| {
365 super::super::commands::children::source_memory(memory)
366 .as_mut()
367 .expect("command source")
368 });
369 nodes::transform_local_source(source, owner, control, &mut local)?;
370 }
371 *command_arena(command).expect("mutation arena") = arena.queries;
372 if let Some(memory) = memory {
373 *field(Some(memory), "value0")
374 .expect("mutation body")
375 .field_mut("subqueries") = arena.memory;
376 }
377 return Ok(());
378 }
379 match command {
380 CommandPlan::CreateView { query, .. }
381 | CommandPlan::CreateMaterializedView { query, .. }
382 | CommandPlan::CreateTableAs { query, .. }
383 | CommandPlan::DeclareCursor { query, .. } => {
384 self.query(query, field(field(memory, "query"), "query"))?;
385 }
386 CommandPlan::Explain { body, .. } | CommandPlan::Prepare { body, .. } => {
387 self.executable(body, field(memory, "body"))?;
388 }
389 CommandPlan::Call { args, .. } => self.expressions(args, field(memory, "args"))?,
390 CommandPlan::Execute { params, .. } => {
391 self.expressions(params, field(memory, "params"))?;
392 }
393 _ => {}
394 }
395 Ok(())
396 }
397
398 fn command_query(
399 &mut self,
400 command: &mut CommandPlan,
401 memory: Option<&mut RewriteMemory>,
402 slot: CommandQuerySlot,
403 ) -> Result<(), SQLError> {
404 if let Some(query) = slot.query_mut(command) {
405 let owner =
406 memory.map(|memory| slot.memory_mut(memory).as_mut().expect("command query"));
407 self.query(query, owner)?;
408 }
409 Ok(())
410 }
411
412 fn expressions(
413 &mut self,
414 expressions: &mut [ExpressionPlan],
415 mut memory: Option<&mut RewriteMemory>,
416 ) -> Result<(), SQLError> {
417 for (index, expression) in expressions.iter_mut().enumerate() {
418 self.expression(expression, item(memory.as_deref_mut(), index))?;
419 }
420 Ok(())
421 }
422}
423
424fn query_arena(root: &mut RelationalPlan) -> &mut Vec<QueryPlan> {
425 match root {
426 RelationalPlan::QueryBlock(block) => &mut block.subqueries,
427 RelationalPlan::Values { subqueries, .. } | RelationalPlan::SetOp { subqueries, .. } => {
428 subqueries
429 }
430 }
431}
432
433fn query_memory(memory: &mut RewriteMemory) -> &mut Option<RewriteMemory> {
434 let root = memory.field_mut("root").as_mut().expect("query root");
435 let is_block = match root {
436 RewriteMemory::Fields { fields, .. } => fields.iter().any(|field| field.name == "block"),
437 RewriteMemory::Scalar(_) | RewriteMemory::Scalars { .. } => unreachable!(),
438 };
439 let root = if is_block {
440 root.field_mut("block").as_mut().expect("query block")
441 } else {
442 root
443 };
444 root.field_mut("subqueries")
445}
446
447fn command_arena(command: &mut CommandPlan) -> Option<&mut Vec<QueryPlan>> {
448 match command {
449 CommandPlan::Insert(plan) => Some(&mut plan.subqueries),
450 CommandPlan::Update(plan) => Some(&mut plan.subqueries),
451 CommandPlan::Delete(plan) => Some(&mut plan.subqueries),
452 CommandPlan::Merge(plan) => Some(&mut plan.subqueries),
453 _ => None,
454 }
455}