uqa_execution/
project_set.rs1use uqa_sql::ResultRow;
10
11use crate::batch::DEFAULT_BATCH_SIZE;
12use crate::{Batch, ExecResult, OwnedPhysicalRow, PhysicalOperator, PhysicalRow, RowSchema};
13
14pub type ProjectRows = Box<dyn Iterator<Item = ExecResult<ResultRow>> + Send>;
21
22pub trait SetProjector: Send {
24 fn project(&mut self, row: &ResultRow) -> ExecResult<ProjectRows>;
25}
26
27impl<F> SetProjector for F
28where
29 F: FnMut(&ResultRow) -> ExecResult<ProjectRows> + Send,
30{
31 fn project(&mut self, row: &ResultRow) -> ExecResult<ProjectRows> {
32 self(row)
33 }
34}
35
36pub struct ProjectSet<'a> {
38 child: Box<dyn PhysicalOperator + 'a>,
39 projector: Box<dyn SetProjector + 'a>,
40 schema: RowSchema,
41 input: std::vec::IntoIter<ResultRow>,
42 projected: Option<ProjectRows>,
43 exhausted: bool,
44}
45
46impl<'a> ProjectSet<'a> {
47 pub fn new(
48 child: Box<dyn PhysicalOperator + 'a>,
49 output_schema: Vec<String>,
50 projector: Box<dyn SetProjector + 'a>,
51 ) -> Self {
52 Self {
53 child,
54 projector,
55 schema: RowSchema::new(output_schema),
56 input: Vec::new().into_iter(),
57 projected: None,
58 exhausted: false,
59 }
60 }
61
62 fn next_input(&mut self) -> ExecResult<Option<ResultRow>> {
63 loop {
64 if let Some(row) = self.input.next() {
65 return Ok(Some(row));
66 }
67 let Some(batch) = self.child.next()? else {
68 return Ok(None);
69 };
70 self.input = batch.into_result_rows().into_iter();
71 }
72 }
73}
74
75impl PhysicalOperator for ProjectSet<'_> {
76 fn row_schema(&self) -> &RowSchema {
77 &self.schema
78 }
79
80 fn open(&mut self) -> ExecResult<()> {
81 self.input = Vec::new().into_iter();
82 self.projected = None;
83 self.exhausted = false;
84 self.child.open()
85 }
86
87 fn next(&mut self) -> ExecResult<Option<Batch>> {
88 if self.exhausted && self.projected.is_none() {
89 return Ok(None);
90 }
91
92 let mut rows = Vec::with_capacity(DEFAULT_BATCH_SIZE);
93 while rows.len() < DEFAULT_BATCH_SIZE {
94 if let Some(projected) = self.projected.as_mut() {
95 match projected.next() {
96 Some(row) => {
97 rows.push(row?);
98 continue;
99 }
100 None => self.projected = None,
101 }
102 }
103
104 match self.next_input()? {
105 Some(row) => self.projected = Some(self.projector.project(&row)?),
106 None => {
107 self.exhausted = true;
108 break;
109 }
110 }
111 }
112 if rows.is_empty() {
113 return Ok(None);
114 }
115 Ok(Some(Batch::new(self.schema.clone(), rows)))
116 }
117
118 fn close(&mut self) -> ExecResult<()> {
119 self.input = Vec::new().into_iter();
120 self.projected = None;
121 self.exhausted = true;
122 self.child.close()
123 }
124}
125
126pub type PhysicalProjectRows = Box<dyn Iterator<Item = ExecResult<PhysicalRow>> + Send>;
128
129pub trait PhysicalSetProjector: Send {
131 fn project(&mut self, row: OwnedPhysicalRow) -> ExecResult<PhysicalProjectRows>;
132}
133
134impl<F> PhysicalSetProjector for F
135where
136 F: FnMut(OwnedPhysicalRow) -> ExecResult<PhysicalProjectRows> + Send,
137{
138 fn project(&mut self, row: OwnedPhysicalRow) -> ExecResult<PhysicalProjectRows> {
139 self(row)
140 }
141}
142
143pub struct PhysicalProjectSet<'a> {
145 child: Box<dyn PhysicalOperator + 'a>,
146 projector: Box<dyn PhysicalSetProjector + 'a>,
147 schema: RowSchema,
148 input: std::vec::IntoIter<OwnedPhysicalRow>,
149 projected: Option<PhysicalProjectRows>,
150 exhausted: bool,
151}
152
153impl<'a> PhysicalProjectSet<'a> {
154 pub fn new(
155 child: Box<dyn PhysicalOperator + 'a>,
156 schema: RowSchema,
157 projector: Box<dyn PhysicalSetProjector + 'a>,
158 ) -> Self {
159 Self {
160 child,
161 projector,
162 schema,
163 input: Vec::new().into_iter(),
164 projected: None,
165 exhausted: false,
166 }
167 }
168
169 fn next_input(&mut self) -> ExecResult<Option<OwnedPhysicalRow>> {
170 loop {
171 if let Some(row) = self.input.next() {
172 return Ok(Some(row));
173 }
174 let Some(batch) = self.child.next()? else {
175 return Ok(None);
176 };
177 self.input = batch.into_owned_rows().into_iter();
178 }
179 }
180}
181
182impl PhysicalOperator for PhysicalProjectSet<'_> {
183 fn row_schema(&self) -> &RowSchema {
184 &self.schema
185 }
186
187 fn open(&mut self) -> ExecResult<()> {
188 self.input = Vec::new().into_iter();
189 self.projected = None;
190 self.exhausted = false;
191 self.child.open()
192 }
193
194 fn next(&mut self) -> ExecResult<Option<Batch>> {
195 if self.exhausted && self.projected.is_none() {
196 return Ok(None);
197 }
198
199 let mut rows = Vec::with_capacity(DEFAULT_BATCH_SIZE);
200 while rows.len() < DEFAULT_BATCH_SIZE {
201 if let Some(projected) = self.projected.as_mut() {
202 match projected.next() {
203 Some(row) => {
204 rows.push(row?);
205 continue;
206 }
207 None => self.projected = None,
208 }
209 }
210
211 match self.next_input()? {
212 Some(row) => self.projected = Some(self.projector.project(row)?),
213 None => {
214 self.exhausted = true;
215 break;
216 }
217 }
218 }
219 if rows.is_empty() {
220 return Ok(None);
221 }
222 Ok(Some(Batch::from_physical_rows(self.schema.clone(), rows)))
223 }
224
225 fn close(&mut self) -> ExecResult<()> {
226 self.input = Vec::new().into_iter();
227 self.projected = None;
228 self.exhausted = true;
229 self.child.close()
230 }
231}
232
233#[cfg(test)]
234mod tests {
235 use super::*;
236 use crate::physical::run_to_rows;
237 use crate::scan::TableScan;
238 use crate::RowSchemaExecution;
239 use crate::{RowLockOrigin, RowProjectionValue};
240 use uqa_core::Value;
241
242 #[test]
243 fn expands_each_input_row_in_child_order() {
244 let input: ResultRow = [("n".into(), Value::Int(2))].into_iter().collect();
245 let child = TableScan::from_rows(vec!["n".into()], vec![input]);
246 let projector = |row: &ResultRow| -> ExecResult<ProjectRows> {
247 let Value::Int(end) = row.get("n").cloned().unwrap_or(Value::Null) else {
248 return Ok(Box::new(std::iter::empty()));
249 };
250 Ok(Box::new((1..=end).map(|value| {
251 Ok([("value".into(), Value::Int(value))].into_iter().collect())
252 })))
253 };
254 let mut project =
255 ProjectSet::new(Box::new(child), vec!["value".into()], Box::new(projector));
256 let (_, rows) = run_to_rows(&mut project).unwrap();
257 assert_eq!(rows.len(), 2);
258 assert_eq!(rows[0].get("value"), Some(&Value::Int(1)));
259 assert_eq!(rows[1].get("value"), Some(&Value::Int(2)));
260 }
261
262 #[test]
263 fn one_input_with_many_outputs_never_builds_an_unbounded_pending_queue() {
264 let input: ResultRow = [("n".into(), Value::Int(10_000))].into_iter().collect();
265 let child = TableScan::from_rows(vec!["n".into()], vec![input]);
266 let projector = |row: &ResultRow| -> ExecResult<ProjectRows> {
267 let Value::Int(end) = row.get("n").cloned().unwrap_or(Value::Null) else {
268 return Ok(Box::new(std::iter::empty()));
269 };
270 Ok(Box::new((0..end).map(|value| {
271 Ok([("value".into(), Value::Int(value))].into_iter().collect())
272 })))
273 };
274 let mut project =
275 ProjectSet::new(Box::new(child), vec!["value".into()], Box::new(projector));
276 project.open().unwrap();
277 let first = project.next().unwrap().unwrap();
278 assert_eq!(first.len(), DEFAULT_BATCH_SIZE);
279 let second = project.next().unwrap().unwrap();
280 assert_eq!(second.len(), DEFAULT_BATCH_SIZE);
281 project.close().unwrap();
282 }
283
284 #[test]
285 fn late_projector_error_is_not_converted_to_end_of_stream() {
286 let child = TableScan::from_rows(vec!["n".into()], vec![ResultRow::new()]);
287 let projector = |_row: &ResultRow| -> ExecResult<ProjectRows> {
288 Ok(Box::new(
289 vec![
290 Ok([("value".into(), Value::Int(1))].into_iter().collect()),
291 Err(crate::ExecError::Other("injected projector failure".into())),
292 ]
293 .into_iter(),
294 ))
295 };
296 let mut project =
297 ProjectSet::new(Box::new(child), vec!["value".into()], Box::new(projector));
298 project.open().unwrap();
299 let error = project.next().unwrap_err();
300 assert!(error.to_string().contains("injected projector failure"));
301 }
302
303 #[test]
304 fn physical_projection_preserves_row_lineage_without_named_materialization() {
305 let input_schema = RowSchema::new(vec!["unused".into(), "value".into()]);
306 let input_row = PhysicalRow::from_values(vec![
307 Value::Str("unused payload".repeat(64)),
308 Value::Str("shared value".repeat(64)),
309 ])
310 .with_lock_origin(RowLockOrigin::new("source", "public.source", 7));
311 let child = TableScan::from_physical_rows(input_schema, vec![input_row]);
312 let projector = |row: OwnedPhysicalRow| -> ExecResult<PhysicalProjectRows> {
313 let slot = row.schema.physical_slot(1).unwrap();
314 Ok(Box::new(std::iter::once(Ok(row.row.project_with_values(
315 [RowProjectionValue::InputSlot(slot)],
316 )))))
317 };
318 let output_schema = RowSchema::new(vec!["value".into()]);
319 let mut project =
320 PhysicalProjectSet::new(Box::new(child), output_schema.clone(), Box::new(projector));
321
322 project.open().unwrap();
323 let output = project.next().unwrap().unwrap();
324 assert_eq!(output.rows.len(), 1);
325 assert_eq!(
326 output_schema.view(&output.rows[0]).value_at(0),
327 Some(&Value::Str("shared value".repeat(64)))
328 );
329 assert_eq!(output.rows[0].lock_origins()[0].doc_id, 7);
330 assert!(project.next().unwrap().is_none());
331 project.close().unwrap();
332 }
333}