uqa_sql/plan/mutable/
deferred.rs1use super::{
10 Copying, MutableQueryPlan, RelationalPlan, RewriteMemory, ScalarArenaTransform,
11 ScalarQueryArena,
12};
13use crate::{semantics::view_rewrite::DeferredOuterRewrite, SQLError};
14use uqa_core::memory::{Budgeted, Produced, ProductionControl};
15
16pub struct OwnedDeferredRewriteIter {
17 values: std::vec::IntoIter<DeferredOuterRewrite>,
18 memory: Option<RewriteMemory>,
19 index: usize,
20}
21impl Iterator for OwnedDeferredRewriteIter {
22 type Item = Produced<DeferredOuterRewrite>;
23 fn next(&mut self) -> Option<Self::Item> {
24 let value = self.values.next()?;
25 let owner = self
26 .memory
27 .as_mut()
28 .and_then(|memory| memory.item_mut(self.index).take())
29 .and_then(RewriteMemory::into_reservation);
30 self.index += 1;
31 Some(match owner {
32 Some(memory) => Produced::from(Budgeted::new(value, memory)),
33 None => ProductionControl::uncontrolled()
34 .finish(value, None)
35 .expect("ordinary deferred substitution"),
36 })
37 }
38 fn size_hint(&self) -> (usize, Option<usize>) {
39 self.values.size_hint()
40 }
41}
42impl ExactSizeIterator for OwnedDeferredRewriteIter {}
43
44impl MutableQueryPlan {
45 pub fn take_deferred_rewrites(
46 mut self,
47 control: &ProductionControl<'_>,
48 ) -> Result<(Self, OwnedDeferredRewriteIter), SQLError> {
49 self.assert_owner(control);
50 control.check()?;
51 let RelationalPlan::QueryBlock(block) = &mut self.query.root else {
52 return Err(SQLError::Internal(
53 "deferred substitutions require a query block".into(),
54 ));
55 };
56 let values = std::mem::take(&mut block.deferred_outer_rewrites);
57 let memory = self.memory.as_mut().and_then(|memory| {
58 block_memory(memory)
59 .field_mut("deferred_outer_rewrites")
60 .take()
61 });
62 Ok((
63 self,
64 OwnedDeferredRewriteIter {
65 values: values.into_iter(),
66 memory,
67 index: 0,
68 },
69 ))
70 }
71
72 pub fn replace_deferred_rewrites(
73 mut self,
74 rewrites: impl ExactSizeIterator<Item = Produced<DeferredOuterRewrite>>,
75 control: &ProductionControl<'_>,
76 ) -> Result<Self, SQLError> {
77 self.assert_owner(control);
78 control.check()?;
79 let (values, owner) = if let Some(mut copying) = Copying::for_rewrite(*control) {
80 let values = copying.map(rewrites, |copying, rewrite| {
81 copying.take_deferred_rewrite(rewrite)
82 })?;
83 (values, Some(copying.into_rewrite_memory()))
84 } else {
85 let mut values = Vec::with_capacity(rewrites.len());
86 for rewrite in rewrites {
87 control.check()?;
88 values.push(
89 rewrite
90 .into_uncontrolled()
91 .expect("ordinary deferred substitution"),
92 );
93 }
94 (values, None)
95 };
96 let RelationalPlan::QueryBlock(block) = &mut self.query.root else {
97 return Err(SQLError::Internal(
98 "deferred substitutions require a query block".into(),
99 ));
100 };
101 block.deferred_outer_rewrites = values;
102 if let Some(memory) = &mut self.memory {
103 *block_memory(memory).field_mut("deferred_outer_rewrites") = owner;
104 }
105 Ok(self)
106 }
107
108 pub fn transform_root_scalar_arenas(
110 mut self,
111 control: &ProductionControl<'_>,
112 transform: &mut ScalarArenaTransform<'_>,
113 ) -> Result<Self, SQLError> {
114 self.assert_owner(control);
115 control.check()?;
116 let mut arena = self.take_arena();
117 super::nodes::query_scalars(
118 &mut self.query,
119 self.memory.as_mut(),
120 false,
121 control,
122 &mut |expression, memory, control| {
123 super::OwnedScalarExpr::transform_nodes_in_place(
124 expression,
125 memory,
126 control,
127 &mut |identity, expression| transform(identity, expression, &mut arena),
128 )
129 },
130 )?;
131 self.restore_arena(arena);
132 Ok(self)
133 }
134
135 pub fn map_source_with_arena(
136 mut self,
137 control: &ProductionControl<'_>,
138 map: impl FnOnce(
139 super::MutableSourcePlan,
140 &mut ScalarQueryArena,
141 ) -> Result<super::MutableSourcePlan, SQLError>,
142 ) -> Result<Self, SQLError> {
143 self.assert_owner(control);
144 control.check()?;
145 let mut arena = self.take_arena();
146 self = self.map_source(control, |source| map(source, &mut arena))?;
147 self.restore_arena(arena);
148 Ok(self)
149 }
150
151 pub(super) fn take_arena(&mut self) -> ScalarQueryArena {
152 let queries = std::mem::take(arena_queries(&mut self.query.root));
153 let memory = self
154 .memory
155 .as_mut()
156 .and_then(|memory| arena_memory(memory).take());
157 ScalarQueryArena { queries, memory }
158 }
159 pub(super) fn restore_arena(&mut self, arena: ScalarQueryArena) {
160 *arena_queries(&mut self.query.root) = arena.queries;
161 if let Some(memory) = &mut self.memory {
162 *arena_memory(memory) = arena.memory;
163 }
164 }
165}
166
167fn block_memory(memory: &mut RewriteMemory) -> &mut RewriteMemory {
168 memory
169 .field_mut("root")
170 .as_mut()
171 .expect("query root")
172 .field_mut("block")
173 .as_mut()
174 .expect("query block")
175}
176fn arena_queries(root: &mut RelationalPlan) -> &mut Vec<crate::plan::QueryPlan> {
177 match root {
178 RelationalPlan::QueryBlock(block) => &mut block.subqueries,
179 RelationalPlan::SetOp { subqueries, .. } | RelationalPlan::Values { subqueries, .. } => {
180 subqueries
181 }
182 }
183}
184fn arena_memory(memory: &mut RewriteMemory) -> &mut Option<RewriteMemory> {
185 let root = memory.field_mut("root").as_mut().expect("query root");
186 let is_block = match root {
187 RewriteMemory::Fields { fields, .. } => fields.iter().any(|field| field.name == "block"),
188 RewriteMemory::Scalar(_) | RewriteMemory::Scalars { .. } => unreachable!(),
189 };
190 let root = if is_block {
191 root.field_mut("block").as_mut().expect("query block")
192 } else {
193 root
194 };
195 root.field_mut("subqueries")
196}