Skip to main content

uqa_sql/plan/mutable/arenas/
nodes.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Arena-aware edits finish nested query namespaces before copying occurrences into their parent.
8
9use 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    /// Rewrite existing nodes at their analysis addresses while lending the node's own query arena. Every nested arena is completed before its parent, and copies added by a callback are already analyzed occurrences.
34    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    /// Complete query metadata before an enclosing expression can copy the analyzed query into another occurrence.
54    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}