Skip to main content

uqa_execution/query/set_projection/
operator.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Physical set-returning projection operator.
8
9use crate::RowProjectionValue;
10
11use super::{
12    eval_call_arguments, Arc, Batch, ColumnType, ExecResult, OwnedPhysicalRow, PhysicalOperator,
13    PhysicalRow, PlanSubqueryArena, ProjectionTarget, RowSchema, SQLError, SQLParam,
14    ScalarEvalContext, ScalarExpr, SetExpansion, SetFunctionCall, SetFunctionRuntime,
15    SetFunctionState, SetProjectionPlan, SharedExpressionEvaluator, Value,
16};
17
18pub struct SetProjection<'a> {
19    child: Box<dyn PhysicalOperator + 'a>,
20    runtime: Arc<dyn SetFunctionRuntime + 'a>,
21    params: &'a [SQLParam],
22    evaluator: SharedExpressionEvaluator<'a>,
23    plan: crate::scalar::PreparedExpressions<SetProjectionPlan>,
24    schema: RowSchema,
25    evaluation_schema: RowSchema,
26    pass_through: bool,
27    output_batch_size: usize,
28    input: std::vec::IntoIter<OwnedPhysicalRow>,
29    expansion: Option<SetExpansion>,
30    exhausted: bool,
31}
32
33fn set_call_output_type(
34    resolver: &dyn crate::FunctionTypeResolver,
35    call: &SetFunctionCall,
36    input_schema: &RowSchema,
37    params: &[SQLParam],
38) -> Option<ColumnType> {
39    let expression = ScalarExpr::Func {
40        order_syntax: uqa_sql::ast::FunctionOrderSyntax::Ordinary,
41        name: call.name.clone(),
42        binding: call.binding.clone(),
43        args: call.args.clone(),
44        distinct: false,
45        order_by: Vec::new(),
46        filter: None,
47    };
48    crate::scalar_type_with_resolver(&expression, input_schema, params, resolver)
49        .ok()
50        .flatten()
51}
52
53impl<'a> SetProjection<'a> {
54    pub fn from_plan(
55        child: Box<dyn PhysicalOperator + 'a>,
56        runtime: Arc<dyn SetFunctionRuntime + 'a>,
57        params: &'a [SQLParam],
58        evaluator: SharedExpressionEvaluator<'a>,
59        mut plan: SetProjectionPlan,
60        pass_through: bool,
61        output_batch_size: usize,
62    ) -> Self {
63        for call in &mut plan.calls {
64            for argument in &mut call.args {
65                *argument = evaluator.bind_type_introspection(argument.clone(), child.row_schema());
66            }
67        }
68        let projections = &plan.projections;
69        let resolver = runtime.as_ref();
70        let call_types = plan
71            .calls
72            .iter()
73            .map(|call| set_call_output_type(resolver, call, child.row_schema(), params))
74            .collect::<Vec<_>>();
75        let appended = projections
76            .iter()
77            .zip(&call_types)
78            .filter(|((_, expression), _)| !matches!(expression, ScalarExpr::Star))
79            .map(|((target, _), ty)| {
80                let ProjectionTarget::Internal(column) = target else {
81                    unreachable!("set-call expansion target must be an internal attribute");
82                };
83                (*column, ty.clone())
84            })
85            .collect::<Vec<_>>();
86        let schema = if pass_through {
87            RowSchema::append_internal_typed(child.row_schema(), &appended)
88        } else {
89            unreachable!("set-call expansion always preserves its input")
90        };
91        let evaluation_columns = plan
92            .calls
93            .iter()
94            .zip(call_types)
95            .map(|(call, ty)| (call.placeholder, ty))
96            .collect::<Vec<_>>();
97        let evaluation_schema =
98            RowSchema::append_internal_typed(child.row_schema(), &evaluation_columns);
99        let output_batch_size = output_batch_size.max(1);
100        Self {
101            child,
102            runtime,
103            params,
104            evaluator,
105            plan: crate::scalar::PreparedExpressions::new(plan, |plan, visit| {
106                for call in &plan.calls {
107                    for argument in &call.args {
108                        visit(argument);
109                    }
110                }
111                for (_, expression) in &plan.projections {
112                    visit(expression);
113                }
114            }),
115            schema,
116            evaluation_schema,
117            pass_through,
118            output_batch_size,
119            input: Vec::new().into_iter(),
120            expansion: None,
121            exhausted: false,
122        }
123    }
124
125    fn next_input(&mut self) -> ExecResult<Option<OwnedPhysicalRow>> {
126        loop {
127            if let Some(row) = self.input.next() {
128                return Ok(Some(row));
129            }
130            let Some(batch) = self.child.next()? else {
131                return Ok(None);
132            };
133            self.input = batch.into_owned_rows().into_iter();
134        }
135    }
136
137    fn call_state(
138        &self,
139        call: &SetFunctionCall,
140        row: &OwnedPhysicalRow,
141    ) -> ExecResult<SetFunctionState> {
142        let identity = call.name.to_ascii_lowercase();
143        if uqa_sql::semantics::builtin_function_dispatch_name(&identity) == "unnest"
144            && call.args.len() != 1
145            && call.binding.as_ref().is_none_or(|binding| binding.builtin)
146        {
147            return Err(SQLError::UnknownFunction(
148                "unnest with multiple arrays is only valid in FROM".into(),
149            )
150            .into());
151        }
152        let runtime = self.runtime.as_ref();
153        let binding = call.binding.as_ref();
154        let has_sql_function = runtime.has_user_function(&call.name, binding)?;
155        if !runtime.has_registered_table_function(&identity) && has_sql_function {
156            let subqueries = PlanSubqueryArena::new(runtime.subquery_plans(), Some(runtime));
157            let context = ScalarEvalContext::from_row_lookup(row, self.params)
158                .with_function_hook(runtime)
159                .with_function_states(self.plan.calls())
160                .with_subquery_runner(&subqueries)
161                .with_physical_outer_row(&row.schema, &row.row);
162            let arguments = eval_call_arguments(&call.args, &context)?;
163            let returns_set = runtime
164                .user_function_returns_set(&call.name, binding, &arguments)
165                .ok_or_else(|| {
166                    crate::ExecError::Other(format!(
167                        "user function `{}` disappeared during projection",
168                        call.name
169                    ))
170                })??;
171            if !returns_set {
172                let value = runtime
173                    .call_user_scalar_function(&call.name, binding, &arguments)
174                    .ok_or_else(|| {
175                        crate::ExecError::Other(format!(
176                            "user function `{}` disappeared during scalar projection",
177                            call.name
178                        ))
179                    })??;
180                return Ok(SetFunctionState::Scalar(value));
181            }
182            let result = runtime
183                .call_user_table_function(&call.name, binding, &arguments)
184                .ok_or_else(|| {
185                    crate::ExecError::Other(format!(
186                        "user function `{}` disappeared during set projection",
187                        call.name
188                    ))
189                })??;
190            let output = super::registered_table_function_rows(&call.name, result, None, &[])?;
191            return Ok(SetFunctionState::Set {
192                columns: output.columns,
193                rows: output.rows,
194                exhausted: false,
195            });
196        }
197        let table_call = super::TableFunctionCall {
198            name: &call.name,
199            binding,
200            output_name: &call.name,
201            relations: None,
202            args: &call.args,
203            function_states: Some(self.plan.calls()),
204            alias: None,
205            column_aliases: &[],
206            ordinality: false,
207            column_types: &[],
208        };
209        let output = runtime.table_function_rows(table_call, self.params, Some(row))?;
210        Ok(SetFunctionState::Set {
211            columns: output.columns,
212            rows: output.rows,
213            exhausted: false,
214        })
215    }
216
217    fn start_expansion(&self, input: OwnedPhysicalRow) -> ExecResult<SetExpansion> {
218        let calls = self
219            .plan
220            .calls
221            .iter()
222            .map(|call| self.call_state(call, &input))
223            .collect::<ExecResult<Vec<_>>>()?;
224        let has_set = calls
225            .iter()
226            .any(|call| matches!(call, SetFunctionState::Set { .. }));
227        Ok(SetExpansion {
228            input,
229            calls,
230            has_set,
231            scalar_emitted: false,
232        })
233    }
234
235    fn next_projected(&mut self) -> ExecResult<Option<PhysicalRow>> {
236        let Some(expansion) = self.expansion.as_mut() else {
237            return Ok(None);
238        };
239        let Some(values) = expansion.next_values()? else {
240            return Ok(None);
241        };
242        let evaluation_row = expansion.input.row.clone().append_values(values);
243        if self.pass_through {
244            let mut output = (0..expansion.input.schema.physical_width())
245                .map(RowProjectionValue::InputSlot)
246                .collect::<Vec<_>>();
247            for (_, expression) in self
248                .plan
249                .projections
250                .iter()
251                .filter(|(_, expression)| !matches!(expression, ScalarExpr::Star))
252            {
253                if let Some(position) =
254                    crate::order_expression_position(&self.evaluation_schema, expression)
255                {
256                    output.push(self.evaluation_schema.physical_slot(position).map_or(
257                        RowProjectionValue::Owned(Value::Null),
258                        RowProjectionValue::InputSlot,
259                    ));
260                } else {
261                    output.push(RowProjectionValue::Owned(
262                        self.evaluator.evaluate_physical_with_function_states(
263                            expression,
264                            &self.evaluation_schema,
265                            &evaluation_row,
266                            self.plan.calls(),
267                        )?,
268                    ));
269                }
270            }
271            return Ok(Some(evaluation_row.project_with_values(output)));
272        }
273
274        let mut output = Vec::with_capacity(self.schema.len());
275        for (_, expression) in &self.plan.projections {
276            if matches!(expression, ScalarExpr::Star) {
277                for position in 0..expansion.input.schema.len() {
278                    if self
279                        .evaluator
280                        .star_position_visible(&expansion.input.schema, position)
281                    {
282                        output.push(expansion.input.schema.physical_slot(position).map_or(
283                            RowProjectionValue::Owned(Value::Null),
284                            RowProjectionValue::InputSlot,
285                        ));
286                    }
287                }
288            } else if let Some(position) =
289                crate::order_expression_position(&self.evaluation_schema, expression)
290            {
291                output.push(self.evaluation_schema.physical_slot(position).map_or(
292                    RowProjectionValue::Owned(Value::Null),
293                    RowProjectionValue::InputSlot,
294                ));
295            } else {
296                output.push(RowProjectionValue::Owned(
297                    self.evaluator.evaluate_physical_with_function_states(
298                        expression,
299                        &self.evaluation_schema,
300                        &evaluation_row,
301                        self.plan.calls(),
302                    )?,
303                ));
304            }
305        }
306        Ok(Some(
307            evaluation_row
308                .project_with_values(output)
309                .without_lock_origins(),
310        ))
311    }
312}
313
314impl PhysicalOperator for SetProjection<'_> {
315    fn row_schema(&self) -> &RowSchema {
316        &self.schema
317    }
318
319    fn open(&mut self) -> ExecResult<()> {
320        self.input = Vec::new().into_iter();
321        self.expansion = None;
322        self.exhausted = false;
323        self.child.open()
324    }
325
326    fn next(&mut self) -> ExecResult<Option<Batch>> {
327        if self.exhausted && self.expansion.is_none() {
328            return Ok(None);
329        }
330        let mut output = Vec::with_capacity(self.output_batch_size);
331        while output.len() < self.output_batch_size {
332            if let Some(row) = self.next_projected()? {
333                output.push(row);
334                continue;
335            }
336            self.expansion = None;
337            if let Some(input) = self.next_input()? {
338                self.expansion = Some(self.start_expansion(input)?);
339            } else {
340                self.exhausted = true;
341                break;
342            }
343        }
344        if output.is_empty() {
345            return Ok(None);
346        }
347        Ok(Some(Batch::from_physical_rows(self.schema.clone(), output)))
348    }
349
350    fn close(&mut self) -> ExecResult<()> {
351        self.input = Vec::new().into_iter();
352        self.expansion = None;
353        self.exhausted = true;
354        self.child.close()
355    }
356}