uqa_sql/plan/mutable/nodes/
transformation.rs1use 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}