uqa_execution/query/set_projection/
operator.rs1use 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}