Skip to main content

uqa_sql/plan/mutable/nodes/
transformation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Complete query transformation follows the existing CTE, source, scalar and child-query order without moving selected syntax before its callback.
8
9use super::{
10    query_scalars, scalar_memory, source_scalars, MutableQueryPlan, OwnedScalarExpr, QueryPlan,
11    RelationalPlan, RewriteMemory, SQLError, ScalarMemory, SourceChildSlot, SourcePlan,
12};
13use crate::plan::{CtePlan, CtePlanBody, ScalarNodeTransform};
14use uqa_core::memory::ProductionControl;
15
16impl MutableQueryPlan {
17    pub fn transform_scalar_nodes(
18        mut self,
19        control: &ProductionControl<'_>,
20        transform: &mut ScalarNodeTransform<'_>,
21    ) -> Result<Self, SQLError> {
22        self.assert_owner(control);
23        control.check()?;
24        transform_query(&mut self.query, self.memory.as_mut(), control, transform)?;
25        Ok(self)
26    }
27}
28
29pub(in crate::plan::mutable) fn transform_query(
30    query: &mut QueryPlan,
31    mut memory: Option<&mut RewriteMemory>,
32    control: &ProductionControl<'_>,
33    transform: &mut ScalarNodeTransform<'_>,
34) -> Result<(), SQLError> {
35    control.check()?;
36    transform_ctes(
37        &mut query.ctes,
38        memory
39            .as_mut()
40            .map(|memory| memory.field_mut("ctes").as_mut().expect("CTE vector")),
41        control,
42        transform,
43    )?;
44    match &mut query.root {
45        RelationalPlan::QueryBlock(block) => {
46            for pending in &mut block.deferred_outer_rewrites {
47                pending.transform_scalar_nodes(control, transform)?;
48            }
49            if let Some(source) = &mut block.from {
50                let memory = memory.as_mut().map(|memory| {
51                    super::super::sources::query_source_memory(memory)
52                        .as_mut()
53                        .expect("source owner")
54                });
55                transform_source(source, memory, control, transform)?;
56            }
57        }
58        RelationalPlan::SetOp { left, right, .. } => {
59            transform_query(
60                left,
61                memory.as_mut().map(|memory| query_child(memory, "left")),
62                control,
63                transform,
64            )?;
65            transform_query(
66                right,
67                memory.as_mut().map(|memory| query_child(memory, "right")),
68                control,
69                transform,
70            )?;
71        }
72        RelationalPlan::Values { .. } => {}
73    }
74    let mut action = |expression: &mut crate::ScalarExpr,
75                      memory: Option<&mut ScalarMemory>,
76                      control: &ProductionControl<'_>| {
77        OwnedScalarExpr::transform_nodes_in_place(expression, memory, control, transform)
78    };
79    query_scalars(query, memory.as_deref_mut(), true, control, &mut action)?;
80    let (queries, block) = match &mut query.root {
81        RelationalPlan::QueryBlock(block) => (&mut block.subqueries, true),
82        RelationalPlan::SetOp { subqueries, .. } | RelationalPlan::Values { subqueries, .. } => {
83            (subqueries, false)
84        }
85    };
86    let mut arena = memory.map(|memory| {
87        let root = memory.field_mut("root").as_mut().expect("query root");
88        let root = if block {
89            root.field_mut("block").as_mut().expect("query block")
90        } else {
91            root
92        };
93        root.field_mut("subqueries")
94            .as_mut()
95            .expect("scalar-query arena")
96    });
97    for (index, query) in queries.iter_mut().enumerate() {
98        let memory = arena.as_mut().map(|arena| {
99            arena
100                .item_mut(index)
101                .as_mut()
102                .expect("query item")
103                .field_mut("query")
104                .as_mut()
105                .expect("query child")
106        });
107        transform_query(query, memory, control, transform)?;
108    }
109    control.check()?;
110    Ok(())
111}
112
113fn query_child<'a>(memory: &'a mut RewriteMemory, field: &str) -> &'a mut RewriteMemory {
114    memory
115        .field_mut("root")
116        .as_mut()
117        .expect("query root")
118        .field_mut(field)
119        .as_mut()
120        .expect("query child box")
121        .field_mut("query")
122        .as_mut()
123        .expect("query child")
124}
125
126pub(in crate::plan::mutable) fn transform_source(
127    source: &mut SourcePlan,
128    mut memory: Option<&mut RewriteMemory>,
129    control: &ProductionControl<'_>,
130    transform: &mut ScalarNodeTransform<'_>,
131) -> Result<(), SQLError> {
132    control.check()?;
133    match source {
134        SourcePlan::Join { left, right, .. } => {
135            transform_source(
136                left,
137                memory.as_mut().map(|memory| {
138                    SourceChildSlot::Left
139                        .memory_mut(memory)
140                        .as_mut()
141                        .expect("left source")
142                }),
143                control,
144                transform,
145            )?;
146            transform_source(
147                right,
148                memory.as_mut().map(|memory| {
149                    SourceChildSlot::Right
150                        .memory_mut(memory)
151                        .as_mut()
152                        .expect("right source")
153                }),
154                control,
155                transform,
156            )?;
157        }
158        SourcePlan::Subquery { body, .. } => {
159            let memory = memory.as_mut().map(|memory| {
160                memory
161                    .field_mut("body")
162                    .as_mut()
163                    .expect("source query box")
164                    .field_mut("query")
165                    .as_mut()
166                    .expect("source query")
167            });
168            transform_query(body, memory, control, transform)?;
169        }
170        _ => {}
171    }
172    source_scalars(
173        source,
174        memory,
175        control,
176        &mut |expression, memory, control| {
177            OwnedScalarExpr::transform_nodes_in_place(expression, memory, control, transform)
178        },
179    )
180}
181
182pub(in crate::plan::mutable) fn transform_ctes(
183    ctes: &mut [CtePlan],
184    mut memory: Option<&mut RewriteMemory>,
185    control: &ProductionControl<'_>,
186    transform: &mut ScalarNodeTransform<'_>,
187) -> Result<(), SQLError> {
188    for (index, cte) in ctes.iter_mut().enumerate() {
189        control.check()?;
190        let mut item = memory
191            .as_mut()
192            .map(|memory| memory.item_mut(index).as_mut().expect("CTE item"));
193        let body = item
194            .as_mut()
195            .map(|item| item.field_mut("body").as_mut().expect("CTE body"));
196        match &mut cte.body {
197            CtePlanBody::Query(query) => transform_query(
198                query,
199                body.map(|body| body.field_mut("query").as_mut().expect("CTE query")),
200                control,
201                transform,
202            )?,
203            CtePlanBody::Command(command) => {
204                super::super::commands::transformation::transform_command(
205                    command,
206                    body.map(|body| body.field_mut("command").as_mut().expect("CTE command")),
207                    control,
208                    transform,
209                )?;
210            }
211        }
212        if let Some(cycle) = &mut cte.cycle {
213            let mut cycle_memory =
214                item.map(|item| item.field_mut("cycle").as_mut().expect("CTE cycle"));
215            let mark = cycle_memory.as_mut().map(|memory| {
216                scalar_memory(
217                    memory
218                        .field_mut("mark_value")
219                        .as_mut()
220                        .expect("cycle mark")
221                        .scalar_mut(),
222                )
223            });
224            OwnedScalarExpr::transform_nodes_in_place(
225                &mut cycle.mark_value,
226                mark,
227                control,
228                transform,
229            )?;
230            let default = cycle_memory.as_mut().map(|memory| {
231                scalar_memory(
232                    memory
233                        .field_mut("mark_default")
234                        .as_mut()
235                        .expect("cycle default")
236                        .scalar_mut(),
237                )
238            });
239            OwnedScalarExpr::transform_nodes_in_place(
240                &mut cycle.mark_default,
241                default,
242                control,
243                transform,
244            )?;
245        }
246    }
247    Ok(())
248}