1use crate::ast::FunctionBinding;
10use crate::plan::{ProjectionPlan, QueryBlockPlan, SourcePlan};
11use crate::{FunctionTypeResolver, RowSchema, ScalarExpr, ScalarFrameBound};
12use crate::{SQLError, SQLParam};
13
14use super::placement::{
15 conditional_set_error, row_comparison_set_error, set_argument_error, top_level_from,
16 SetPlacement,
17};
18use super::placement_scope::placing_set_calls;
19use super::{PhysicalProjection, SetFunctionCatalog};
20use crate::binding::context::BindingContext;
21use crate::semantics::aggregates::is_aggregate;
22
23pub fn builtin_returns_set(name: &str) -> bool {
24 matches!(
25 name,
26 "generate_series"
27 | "pg_listening_channels"
28 | "unnest"
29 | "regexp_matches"
30 | "regexp_split_to_table"
31 | "string_to_table"
32 | "json_array_elements"
33 | "jsonb_array_elements"
34 | "json_array_elements_text"
35 | "jsonb_array_elements_text"
36 | "json_each"
37 | "jsonb_each"
38 | "json_each_text"
39 | "jsonb_each_text"
40 | "json_object_keys"
41 | "jsonb_object_keys"
42 | "aclexplode"
43 )
44}
45
46pub fn function_may_return_set(
47 engine: &dyn crate::routines::RoutineResolution,
48 resolver: &dyn FunctionTypeResolver,
49 name: &str,
50 binding: Option<&FunctionBinding>,
51 args: &[ScalarExpr],
52 schema: &RowSchema,
53 params: &[SQLParam],
54) -> Result<bool, SQLError> {
55 if binding.and_then(|binding| binding.dispatch).is_some() {
56 return Ok(false);
57 }
58 if binding.is_some_and(FunctionBinding::is_polymorphic_builtin_syntax) {
59 return Ok(false);
60 }
61 if binding.is_some_and(|binding| !binding.builtin) {
62 let (argument_names, argument_types, explicit_variadic) =
63 crate::function_call_argument_signature(args, schema, params, Some(resolver))?;
64 let function = engine.resolve_static_sql_function(
65 name,
66 binding,
67 &argument_names,
68 &argument_types,
69 explicit_variadic,
70 )?;
71 return Ok(function.is_some_and(|function| function.def.returns_set()));
72 }
73 let identity = name.to_ascii_lowercase();
74 let builtin = crate::semantics::builtin_function_dispatch_name(&identity);
75 let builtin_returns_set =
76 builtin_returns_set(&builtin) || engine.has_registered_table_function(&identity);
77 if builtin_returns_set
79 && (binding.is_some()
80 || engine
81 .lookup_visible_sql_functions_for_analysis(name)?
82 .is_none())
83 {
84 return Ok(true);
85 }
86 let (argument_names, argument_types, explicit_variadic) =
87 crate::function_call_argument_signature(args, schema, params, Some(resolver))?;
88 let Some(overloads) = engine.lookup_visible_sql_functions_for_analysis(name)? else {
89 return Ok(false);
90 };
91 if !builtin_returns_set && !crate::is_fixed_builtin(name) {
92 let mut setness = overloads
93 .iter()
94 .filter(|function| !function.def.is_procedure)
95 .map(|function| function.def.returns_set());
96 if let Some(first) = setness.next() {
97 if setness.all(|returns_set| returns_set == first) {
98 return Ok(first);
99 }
100 }
101 }
102 if let Some(resolved) = crate::resolve_fixed_builtin_call(
103 name,
104 binding,
105 &argument_names,
106 &argument_types,
107 explicit_variadic,
108 Some(resolver),
109 )? {
110 if resolved.selected.binding.builtin {
111 return Ok(builtin_returns_set);
112 }
113 let function = engine.resolve_static_sql_function(
114 name,
115 Some(&resolved.selected.binding),
116 &argument_names,
117 &argument_types,
118 explicit_variadic,
119 )?;
120 return Ok(function.is_some_and(|function| function.def.returns_set()));
121 }
122 match engine.resolve_static_sql_function(
123 name,
124 binding,
125 &argument_names,
126 &argument_types,
127 explicit_variadic,
128 ) {
129 Ok(Some(function)) => Ok(function.def.returns_set()),
130 Ok(None) => Ok(builtin_returns_set),
131 Err(error) if builtin_returns_set && error.sqlstate() == Some("42883") => Ok(true),
133 Err(error) if binding.is_none() && error.sqlstate() == Some("42883") => {
134 match crate::type_resolution::builtin_function_type_with_resolver(
135 &builtin,
136 args,
137 &[],
138 schema,
139 params,
140 resolver,
141 ) {
142 Ok(Some(_)) => Ok(false),
143 Ok(None) | Err(_) => Err(error),
144 }
145 }
146 Err(error) => Err(error),
147 }
148}
149
150pub fn resolve_set_function_binding(
151 engine: &dyn SetFunctionCatalog,
152 resolver: &dyn FunctionTypeResolver,
153 name: &str,
154 binding: Option<&FunctionBinding>,
155 args: &[ScalarExpr],
156 schema: &RowSchema,
157 params: &[SQLParam],
158) -> Result<Option<FunctionBinding>, SQLError> {
159 let (argument_names, argument_types, explicit_variadic) =
160 crate::function_call_argument_signature(args, schema, params, Some(resolver))?;
161 let unbound_without_routines = binding.is_none()
162 && engine
163 .lookup_visible_sql_functions_for_analysis(name)?
164 .is_none();
165 if let Some(resolved) = crate::resolve_fixed_builtin_call(
166 name,
167 binding,
168 &argument_names,
169 &argument_types,
170 explicit_variadic,
171 Some(resolver),
172 )? {
173 return Ok((binding.is_none() || !resolved.selected.binding.builtin)
175 .then_some(resolved.selected.binding));
176 }
177 if unbound_without_routines {
178 return Ok(None);
179 }
180 let Some(function) = engine.resolve_static_sql_function_match(
181 name,
182 binding,
183 &argument_names,
184 &argument_types,
185 explicit_variadic,
186 )?
187 else {
188 return Ok(binding.cloned());
189 };
190 Ok(Some(function.binding()))
191}
192
193pub fn projections_may_return_set(
194 engine: &dyn SetFunctionCatalog,
195 resolver: &dyn FunctionTypeResolver,
196 projections: &[PhysicalProjection],
197 schema: &RowSchema,
198 params: &[SQLParam],
199) -> Result<bool, SQLError> {
200 for (_, expression) in projections {
201 if expression_may_return_set(engine, resolver, expression, schema, params)? {
202 return Ok(true);
203 }
204 }
205 Ok(false)
206}
207
208#[expect(
209 clippy::too_many_lines,
210 reason = "preserves SELECT schema and row identity"
211)]
212pub fn expression_may_return_set(
213 engine: &dyn crate::routines::RoutineResolution,
214 resolver: &dyn FunctionTypeResolver,
215 expression: &ScalarExpr,
216 schema: &RowSchema,
217 params: &[SQLParam],
218) -> Result<bool, SQLError> {
219 match expression {
220 ScalarExpr::Func {
221 name,
222 binding,
223 args,
224 order_by,
225 filter,
226 ..
227 } => {
228 if function_may_return_set(
229 engine,
230 resolver,
231 name,
232 binding.as_ref(),
233 args,
234 schema,
235 params,
236 )? || expressions_may_return_set(engine, resolver, args, schema, params)?
237 || expressions_may_return_set(
238 engine,
239 resolver,
240 order_by.iter().map(|order| &order.expr),
241 schema,
242 params,
243 )?
244 {
245 return Ok(true);
246 }
247 filter.as_deref().map_or(Ok(false), |filter| {
248 expression_may_return_set(engine, resolver, filter, schema, params)
249 })
250 }
251 ScalarExpr::Array(items)
252 | ScalarExpr::Row(items)
253 | ScalarExpr::CompositeRow { items, .. }
254 | ScalarExpr::And(items)
255 | ScalarExpr::Or(items) => {
256 expressions_may_return_set(engine, resolver, items, schema, params)
257 }
258 ScalarExpr::Binary { lhs, rhs, .. } => Ok(expression_may_return_set(
259 engine, resolver, lhs, schema, params,
260 )? || expression_may_return_set(
261 engine, resolver, rhs, schema, params,
262 )?),
263 ScalarExpr::Not(inner)
264 | ScalarExpr::UnaryMinus(inner)
265 | ScalarExpr::IsNull { expr: inner, .. }
266 | ScalarExpr::Cast { expr: inner, .. }
267 | ScalarExpr::Collated { expr: inner, .. } => {
268 expression_may_return_set(engine, resolver, inner, schema, params)
269 }
270 ScalarExpr::Between { expr, low, high } => {
271 Ok(
272 expression_may_return_set(engine, resolver, expr, schema, params)?
273 || expression_may_return_set(engine, resolver, low, schema, params)?
274 || expression_may_return_set(engine, resolver, high, schema, params)?,
275 )
276 }
277 ScalarExpr::InList { expr, list, .. } => Ok(expression_may_return_set(
278 engine, resolver, expr, schema, params,
279 )? || expressions_may_return_set(
280 engine, resolver, list, schema, params,
281 )?),
282 ScalarExpr::WindowCall { .. } => Ok(false),
284 ScalarExpr::Case {
285 base,
286 when,
287 else_branch,
288 } => {
289 if let Some(base) = base {
290 if expression_may_return_set(engine, resolver, base, schema, params)? {
291 return Ok(true);
292 }
293 }
294 for (condition, result) in when {
295 if expression_may_return_set(engine, resolver, condition, schema, params)?
296 || expression_may_return_set(engine, resolver, result, schema, params)?
297 {
298 return Ok(true);
299 }
300 }
301 if let Some(branch) = else_branch {
302 if expression_may_return_set(engine, resolver, branch, schema, params)? {
303 return Ok(true);
304 }
305 }
306 Ok(false)
307 }
308 ScalarExpr::InSubquery { expr, .. } => {
309 expression_may_return_set(engine, resolver, expr, schema, params)
310 }
311 ScalarExpr::Default
312 | ScalarExpr::Star
313 | ScalarExpr::QualifiedStar(_)
314 | ScalarExpr::Column(_)
315 | ScalarExpr::Position(_)
316 | ScalarExpr::InternalColumn(_)
317 | ScalarExpr::QualifiedColumn { .. }
318 | ScalarExpr::Literal(_)
319 | ScalarExpr::TypedLiteral { .. }
320 | ScalarExpr::RetainedLiteral(_)
321 | ScalarExpr::Param(_)
322 | ScalarExpr::ScalarSubquery(_)
323 | ScalarExpr::Exists { .. } => Ok(false),
324 }
325}
326
327fn expressions_may_return_set<'a>(
328 engine: &dyn crate::routines::RoutineResolution,
329 resolver: &dyn FunctionTypeResolver,
330 expressions: impl IntoIterator<Item = &'a ScalarExpr>,
331 schema: &RowSchema,
332 params: &[SQLParam],
333) -> Result<bool, SQLError> {
334 for expression in expressions {
335 if expression_may_return_set(engine, resolver, expression, schema, params)? {
336 return Ok(true);
337 }
338 }
339 Ok(false)
340}
341
342fn frame_bound_expression(bound: &ScalarFrameBound) -> Option<&ScalarExpr> {
343 match bound {
344 ScalarFrameBound::Preceding(expression) | ScalarFrameBound::Following(expression) => {
345 Some(expression)
346 }
347 ScalarFrameBound::UnboundedPreceding
348 | ScalarFrameBound::UnboundedFollowing
349 | ScalarFrameBound::CurrentRow => None,
350 }
351}
352
353fn reject_set_descendant<'a>(
355 engine: &dyn SetFunctionCatalog,
356 resolver: &dyn FunctionTypeResolver,
357 expressions: impl IntoIterator<Item = &'a ScalarExpr>,
358 schema: &RowSchema,
359 params: &[SQLParam],
360 error: impl FnOnce() -> SQLError,
361) -> Result<(), SQLError> {
362 if expressions_may_return_set(engine, resolver, expressions, schema, params)? {
363 return Err(error());
364 }
365 Ok(())
366}
367
368fn reject_set_placement<'a>(
370 engine: &dyn SetFunctionCatalog,
371 resolver: &dyn FunctionTypeResolver,
372 expressions: impl IntoIterator<Item = &'a ScalarExpr>,
373 schema: &RowSchema,
374 params: &[SQLParam],
375 placement: SetPlacement,
376) -> Result<(), SQLError> {
377 if expressions_may_return_set(engine, resolver, expressions, schema, params)? {
378 placement.admit(true)?;
379 }
380 Ok(())
381}
382
383#[expect(
385 clippy::too_many_lines,
386 reason = "one ordered dispatch covers every scalar expression"
387)]
388fn validate_set_context(
389 engine: &dyn SetFunctionCatalog,
390 resolver: &dyn FunctionTypeResolver,
391 expression: &ScalarExpr,
392 schema: &RowSchema,
393 params: &[SQLParam],
394) -> Result<(), SQLError> {
395 let validate = |expression| validate_set_context(engine, resolver, expression, schema, params);
396 let returns_set =
397 |expression| expression_may_return_set(engine, resolver, expression, schema, params);
398 match expression {
399 ScalarExpr::Func {
400 name,
401 args,
402 order_by,
403 filter,
404 ..
405 } => {
406 for argument in args {
407 validate(argument)?;
408 }
409 if let Some(filter) = filter {
410 reject_set_placement(
411 engine,
412 resolver,
413 [filter.as_ref()],
414 schema,
415 params,
416 SetPlacement::Filter,
417 )?;
418 }
419 for order in order_by {
420 validate(&order.expr)?;
421 }
422 if is_aggregate(engine, expression) {
423 reject_set_descendant(
424 engine,
425 resolver,
426 args.iter().chain(order_by.iter().map(|order| &order.expr)),
427 schema,
428 params,
429 || {
430 conditional_set_error(
431 "aggregate function calls cannot contain set-returning function calls",
432 )
433 },
434 )?;
435 } else if crate::semantics::builtin_function_dispatch_name(name) == "coalesce" {
436 reject_set_descendant(engine, resolver, args, schema, params, || {
437 conditional_set_error("set-returning functions are not allowed in COALESCE")
438 })?;
439 }
440 }
441 ScalarExpr::WindowCall {
442 args, spec, filter, ..
443 } => {
444 for argument in args {
445 validate(argument)?;
446 }
447 if let Some(filter) = filter {
448 reject_set_placement(
449 engine,
450 resolver,
451 [filter.as_ref()],
452 schema,
453 params,
454 SetPlacement::Filter,
455 )?;
456 }
457 reject_set_descendant(engine, resolver, args, schema, params, || {
458 conditional_set_error(
459 "window function calls cannot contain set-returning function calls",
460 )
461 })?;
462 for expression in spec
463 .partition_by
464 .iter()
465 .chain(spec.order_by.iter().map(|order| &order.expr))
466 {
467 validate(expression)?;
468 }
469 reject_set_placement(
470 engine,
471 resolver,
472 spec.frame
473 .iter()
474 .flat_map(|frame| [&frame.start, &frame.end])
475 .filter_map(|bound| frame_bound_expression(bound)),
476 schema,
477 params,
478 SetPlacement::WindowFrame,
479 )?;
480 }
481 ScalarExpr::Case {
482 base,
483 when,
484 else_branch,
485 } => {
486 if let Some(base) = base {
487 validate(base)?;
488 }
489 for (condition, result) in when {
490 validate(condition)?;
491 if returns_set(condition)? {
493 return Err(set_argument_error("CASE/WHEN"));
494 }
495 validate(result)?;
496 }
497 if let Some(branch) = else_branch {
498 validate(branch)?;
499 }
500 let descendants = base
501 .iter()
502 .map(AsRef::as_ref)
503 .chain(
504 when.iter()
505 .flat_map(|(condition, result)| [condition, result]),
506 )
507 .chain(else_branch.iter().map(AsRef::as_ref));
508 reject_set_descendant(engine, resolver, descendants, schema, params, || {
509 conditional_set_error("set-returning functions are not allowed in CASE")
510 })?;
511 }
512 ScalarExpr::Not(inner) => {
513 validate(inner)?;
514 if returns_set(inner)? {
515 return Err(set_argument_error("NOT"));
516 }
517 }
518 ScalarExpr::UnaryMinus(inner)
519 | ScalarExpr::IsNull { expr: inner, .. }
520 | ScalarExpr::Cast { expr: inner, .. }
521 | ScalarExpr::Collated { expr: inner, .. } => validate(inner)?,
522 ScalarExpr::And(items) | ScalarExpr::Or(items) => {
523 let construct = if matches!(expression, ScalarExpr::And(_)) {
524 "AND"
525 } else {
526 "OR"
527 };
528 for item in items {
529 validate(item)?;
530 if returns_set(item)? {
531 return Err(set_argument_error(construct));
532 }
533 }
534 }
535 ScalarExpr::InList { expr, list, .. } => {
536 validate(expr)?;
537 for item in list {
538 validate(item)?;
539 }
540 reject_set_descendant(engine, resolver, list, schema, params, || {
541 set_argument_error("IN")
542 })?;
543 }
544 ScalarExpr::Between { expr, low, high } => {
545 for item in [expr, low, high] {
546 validate(item)?;
547 }
548 reject_set_descendant(
549 engine,
550 resolver,
551 [expr.as_ref(), low.as_ref(), high.as_ref()],
552 schema,
553 params,
554 || set_argument_error("AND"),
555 )?;
556 }
557 ScalarExpr::Array(items)
558 | ScalarExpr::Row(items)
559 | ScalarExpr::CompositeRow { items, .. } => {
560 for item in items {
561 validate(item)?;
562 }
563 }
564 ScalarExpr::Binary { lhs, rhs, .. } => {
565 validate(lhs)?;
566 validate(rhs)?;
567 if matches!(
568 (lhs.as_ref(), rhs.as_ref()),
569 (ScalarExpr::Row(_), ScalarExpr::Row(_))
570 ) {
571 reject_set_descendant(
572 engine,
573 resolver,
574 [lhs.as_ref(), rhs.as_ref()],
575 schema,
576 params,
577 row_comparison_set_error,
578 )?;
579 }
580 }
581 ScalarExpr::InSubquery { expr, .. } => {
582 validate(expr)?;
583 reject_set_descendant(
584 engine,
585 resolver,
586 [expr.as_ref()],
587 schema,
588 params,
589 row_comparison_set_error,
590 )?;
591 }
592 ScalarExpr::Default
593 | ScalarExpr::Star
594 | ScalarExpr::QualifiedStar(_)
595 | ScalarExpr::Column(_)
596 | ScalarExpr::Position(_)
597 | ScalarExpr::InternalColumn(_)
598 | ScalarExpr::QualifiedColumn { .. }
599 | ScalarExpr::Literal(_)
600 | ScalarExpr::TypedLiteral { .. }
601 | ScalarExpr::RetainedLiteral(_)
602 | ScalarExpr::Param(_)
603 | ScalarExpr::ScalarSubquery(_)
604 | ScalarExpr::Exists { .. } => {}
605 }
606 Ok(())
607}
608
609pub fn validate_projection_set_contexts(
610 engine: &dyn SetFunctionCatalog,
611 resolver: &dyn FunctionTypeResolver,
612 projections: &[ProjectionPlan],
613 schema: &RowSchema,
614 params: &[SQLParam],
615) -> Result<(), SQLError> {
616 if !placing_set_calls() {
617 return Ok(());
618 }
619 for projection in projections {
620 validate_set_context(engine, resolver, &projection.expr, schema, params)?;
621 }
622 Ok(())
623}
624
625pub fn validate_query_set_contexts(
627 engine: &dyn SetFunctionCatalog,
628 resolver: &dyn FunctionTypeResolver,
629 statement: &QueryBlockPlan,
630 schema: &RowSchema,
631 params: &[SQLParam],
632) -> Result<(), SQLError> {
633 if !placing_set_calls() {
634 return Ok(());
635 }
636 validate_projection_set_contexts(engine, resolver, &statement.projections, schema, params)?;
637 for (clause, placement) in [
638 (statement.r#where.as_ref(), SetPlacement::Where),
639 (statement.having.as_ref(), SetPlacement::Having),
640 ] {
641 reject_set_placement(engine, resolver, clause, schema, params, placement)?;
642 }
643 for expression in statement
644 .order_by
645 .iter()
646 .map(|order| &order.expr)
647 .chain(statement.group_by.iter())
648 .chain(statement.grouping_sets.iter().flatten())
649 .chain(statement.distinct_on.iter())
650 {
651 validate_set_context(engine, resolver, expression, schema, params)?;
652 }
653 for (clause, placement) in [
654 (statement.offset.as_ref(), SetPlacement::Offset),
655 (statement.limit.as_ref(), SetPlacement::Limit),
656 ] {
657 reject_set_placement(engine, resolver, clause, schema, params, placement)?;
658 }
659 if let Some(source) = statement.from.as_ref() {
660 validate_source_set_contexts(engine, resolver, source, schema, params)?;
661 }
662 if let Some(locking) = statement.locking.first() {
663 for projection in &statement.projections {
664 if expression_may_return_set(engine, resolver, &projection.expr, schema, params)? {
665 return Err(SQLError::Unsupported(format!(
666 "{} is not allowed with set-returning functions in the target list",
667 locking.strength.sql_name()
668 )));
669 }
670 }
671 }
672 Ok(())
673}
674
675fn validate_source_set_contexts(
676 engine: &dyn SetFunctionCatalog,
677 resolver: &dyn FunctionTypeResolver,
678 source: &SourcePlan,
679 schema: &RowSchema,
680 params: &[SQLParam],
681) -> Result<(), SQLError> {
682 match source {
683 crate::plan::SourcePlan::RetainedRows(_) => {}
684 SourcePlan::Join {
685 left, right, on, ..
686 } => {
687 validate_source_set_contexts(engine, resolver, left, schema, params)?;
688 validate_source_set_contexts(engine, resolver, right, schema, params)?;
689 if let Some(condition) = on {
690 reject_set_placement(
691 engine,
692 resolver,
693 [condition],
694 schema,
695 params,
696 SetPlacement::JoinCondition,
697 )?;
698 }
699 }
700 SourcePlan::Values { rows, .. } => {
701 validate_values_set_contexts(engine, resolver, rows, schema, params)?;
702 }
703 SourcePlan::Function { args, .. } => {
704 reject_set_descendant(engine, resolver, args, schema, params, top_level_from)?;
705 }
706 SourcePlan::FunctionGroup { functions, .. } => {
707 for function in functions {
708 reject_set_descendant(
709 engine,
710 resolver,
711 &function.args,
712 schema,
713 params,
714 top_level_from,
715 )?;
716 }
717 }
718 SourcePlan::Subquery { .. } | SourcePlan::Table { .. } => {}
719 }
720 Ok(())
721}
722
723pub fn validate_source_set_contexts_before_build(
724 engine: &dyn SetFunctionCatalog,
725 resolver: &dyn FunctionTypeResolver,
726 source: &SourcePlan,
727 params: &[SQLParam],
728 ctes: &BindingContext<'_>,
729 outer: Option<&RowSchema>,
730) -> Result<(), SQLError> {
731 if !placing_set_calls() {
732 return Ok(());
733 }
734 validate_source_set_contexts_in_scope(
735 engine,
736 resolver,
737 source,
738 params,
739 ctes,
740 crate::binding::SourceScope::new(outer),
741 )
742}
743
744fn validate_source_set_contexts_in_scope(
745 engine: &dyn SetFunctionCatalog,
746 resolver: &dyn FunctionTypeResolver,
747 source: &SourcePlan,
748 params: &[SQLParam],
749 ctes: &BindingContext<'_>,
750 scope: crate::binding::SourceScope<'_>,
751) -> Result<(), SQLError> {
752 let input = (!matches!(source, SourcePlan::Join { .. }))
753 .then(|| scope.input(source))
754 .flatten();
755 let outer = input.as_ref();
756 match source {
757 crate::plan::SourcePlan::RetainedRows(_) => Ok(()),
758 SourcePlan::Join {
759 left,
760 right,
761 lateral,
762 kind,
763 ..
764 } => {
765 validate_source_set_contexts_in_scope(
766 engine,
767 resolver,
768 left,
769 params,
770 ctes,
771 scope.with_names(),
772 )?;
773 let left_schema = crate::binding::bind_source_plan_schema_in_scope(
774 engine,
775 left,
776 params,
777 ctes,
778 scope.with_names(),
779 )?;
780 let preceding = scope.right_namespace(left, &left_schema, *kind);
781 validate_source_set_contexts_in_scope(
782 engine,
783 resolver,
784 right,
785 params,
786 ctes,
787 crate::binding::SourceScope {
788 outer: scope.outer,
789 preceding: Some(&preceding),
790 inherited_lateral: *lateral,
791 retain_names: true,
792 },
793 )
794 }
795 SourcePlan::Values { rows, .. } => {
796 let empty = RowSchema::default();
797 validate_values_set_contexts(engine, resolver, rows, outer.unwrap_or(&empty), params)
798 }
799 SourcePlan::Function { args, .. } => {
800 let empty = RowSchema::default();
801 reject_set_descendant(
802 engine,
803 resolver,
804 args,
805 outer.unwrap_or(&empty),
806 params,
807 top_level_from,
808 )
809 }
810 SourcePlan::FunctionGroup { functions, .. } => {
811 let empty = RowSchema::default();
812 for function in functions {
813 reject_set_descendant(
814 engine,
815 resolver,
816 &function.args,
817 outer.unwrap_or(&empty),
818 params,
819 top_level_from,
820 )?;
821 }
822 Ok(())
823 }
824 SourcePlan::Subquery { .. } | SourcePlan::Table { .. } => Ok(()),
825 }
826}
827
828pub fn validate_values_set_contexts(
829 engine: &dyn SetFunctionCatalog,
830 resolver: &dyn FunctionTypeResolver,
831 rows: &[Vec<ScalarExpr>],
832 schema: &RowSchema,
833 params: &[SQLParam],
834) -> Result<(), SQLError> {
835 if !placing_set_calls() {
836 return Ok(());
837 }
838 reject_set_placement(
839 engine,
840 resolver,
841 rows.iter().flatten(),
842 schema,
843 params,
844 SetPlacement::Values,
845 )
846}
847
848#[cfg(test)]
849mod tests;