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::Param(_)
321 | ScalarExpr::ScalarSubquery(_)
322 | ScalarExpr::Exists { .. } => Ok(false),
323 }
324}
325
326fn expressions_may_return_set<'a>(
327 engine: &dyn crate::routines::RoutineResolution,
328 resolver: &dyn FunctionTypeResolver,
329 expressions: impl IntoIterator<Item = &'a ScalarExpr>,
330 schema: &RowSchema,
331 params: &[SQLParam],
332) -> Result<bool, SQLError> {
333 for expression in expressions {
334 if expression_may_return_set(engine, resolver, expression, schema, params)? {
335 return Ok(true);
336 }
337 }
338 Ok(false)
339}
340
341fn frame_bound_expression(bound: &ScalarFrameBound) -> Option<&ScalarExpr> {
342 match bound {
343 ScalarFrameBound::Preceding(expression) | ScalarFrameBound::Following(expression) => {
344 Some(expression)
345 }
346 ScalarFrameBound::UnboundedPreceding
347 | ScalarFrameBound::UnboundedFollowing
348 | ScalarFrameBound::CurrentRow => None,
349 }
350}
351
352fn reject_set_descendant<'a>(
354 engine: &dyn SetFunctionCatalog,
355 resolver: &dyn FunctionTypeResolver,
356 expressions: impl IntoIterator<Item = &'a ScalarExpr>,
357 schema: &RowSchema,
358 params: &[SQLParam],
359 error: impl FnOnce() -> SQLError,
360) -> Result<(), SQLError> {
361 if expressions_may_return_set(engine, resolver, expressions, schema, params)? {
362 return Err(error());
363 }
364 Ok(())
365}
366
367fn reject_set_placement<'a>(
369 engine: &dyn SetFunctionCatalog,
370 resolver: &dyn FunctionTypeResolver,
371 expressions: impl IntoIterator<Item = &'a ScalarExpr>,
372 schema: &RowSchema,
373 params: &[SQLParam],
374 placement: SetPlacement,
375) -> Result<(), SQLError> {
376 if expressions_may_return_set(engine, resolver, expressions, schema, params)? {
377 placement.admit(true)?;
378 }
379 Ok(())
380}
381
382#[expect(
384 clippy::too_many_lines,
385 reason = "one ordered dispatch covers every scalar expression"
386)]
387fn validate_set_context(
388 engine: &dyn SetFunctionCatalog,
389 resolver: &dyn FunctionTypeResolver,
390 expression: &ScalarExpr,
391 schema: &RowSchema,
392 params: &[SQLParam],
393) -> Result<(), SQLError> {
394 let validate = |expression| validate_set_context(engine, resolver, expression, schema, params);
395 let returns_set =
396 |expression| expression_may_return_set(engine, resolver, expression, schema, params);
397 match expression {
398 ScalarExpr::Func {
399 name,
400 args,
401 order_by,
402 filter,
403 ..
404 } => {
405 for argument in args {
406 validate(argument)?;
407 }
408 if let Some(filter) = filter {
409 reject_set_placement(
410 engine,
411 resolver,
412 [filter.as_ref()],
413 schema,
414 params,
415 SetPlacement::Filter,
416 )?;
417 }
418 for order in order_by {
419 validate(&order.expr)?;
420 }
421 if is_aggregate(engine, expression) {
422 reject_set_descendant(
423 engine,
424 resolver,
425 args.iter().chain(order_by.iter().map(|order| &order.expr)),
426 schema,
427 params,
428 || {
429 conditional_set_error(
430 "aggregate function calls cannot contain set-returning function calls",
431 )
432 },
433 )?;
434 } else if crate::semantics::builtin_function_dispatch_name(name) == "coalesce" {
435 reject_set_descendant(engine, resolver, args, schema, params, || {
436 conditional_set_error("set-returning functions are not allowed in COALESCE")
437 })?;
438 }
439 }
440 ScalarExpr::WindowCall {
441 args, spec, filter, ..
442 } => {
443 for argument in args {
444 validate(argument)?;
445 }
446 if let Some(filter) = filter {
447 reject_set_placement(
448 engine,
449 resolver,
450 [filter.as_ref()],
451 schema,
452 params,
453 SetPlacement::Filter,
454 )?;
455 }
456 reject_set_descendant(engine, resolver, args, schema, params, || {
457 conditional_set_error(
458 "window function calls cannot contain set-returning function calls",
459 )
460 })?;
461 for expression in spec
462 .partition_by
463 .iter()
464 .chain(spec.order_by.iter().map(|order| &order.expr))
465 {
466 validate(expression)?;
467 }
468 reject_set_placement(
469 engine,
470 resolver,
471 spec.frame
472 .iter()
473 .flat_map(|frame| [&frame.start, &frame.end])
474 .filter_map(|bound| frame_bound_expression(bound)),
475 schema,
476 params,
477 SetPlacement::WindowFrame,
478 )?;
479 }
480 ScalarExpr::Case {
481 base,
482 when,
483 else_branch,
484 } => {
485 if let Some(base) = base {
486 validate(base)?;
487 }
488 for (condition, result) in when {
489 validate(condition)?;
490 if returns_set(condition)? {
492 return Err(set_argument_error("CASE/WHEN"));
493 }
494 validate(result)?;
495 }
496 if let Some(branch) = else_branch {
497 validate(branch)?;
498 }
499 let descendants = base
500 .iter()
501 .map(AsRef::as_ref)
502 .chain(
503 when.iter()
504 .flat_map(|(condition, result)| [condition, result]),
505 )
506 .chain(else_branch.iter().map(AsRef::as_ref));
507 reject_set_descendant(engine, resolver, descendants, schema, params, || {
508 conditional_set_error("set-returning functions are not allowed in CASE")
509 })?;
510 }
511 ScalarExpr::Not(inner) => {
512 validate(inner)?;
513 if returns_set(inner)? {
514 return Err(set_argument_error("NOT"));
515 }
516 }
517 ScalarExpr::UnaryMinus(inner)
518 | ScalarExpr::IsNull { expr: inner, .. }
519 | ScalarExpr::Cast { expr: inner, .. }
520 | ScalarExpr::Collated { expr: inner, .. } => validate(inner)?,
521 ScalarExpr::And(items) | ScalarExpr::Or(items) => {
522 let construct = if matches!(expression, ScalarExpr::And(_)) {
523 "AND"
524 } else {
525 "OR"
526 };
527 for item in items {
528 validate(item)?;
529 if returns_set(item)? {
530 return Err(set_argument_error(construct));
531 }
532 }
533 }
534 ScalarExpr::InList { expr, list, .. } => {
535 validate(expr)?;
536 for item in list {
537 validate(item)?;
538 }
539 reject_set_descendant(engine, resolver, list, schema, params, || {
540 set_argument_error("IN")
541 })?;
542 }
543 ScalarExpr::Between { expr, low, high } => {
544 for item in [expr, low, high] {
545 validate(item)?;
546 }
547 reject_set_descendant(
548 engine,
549 resolver,
550 [expr.as_ref(), low.as_ref(), high.as_ref()],
551 schema,
552 params,
553 || set_argument_error("AND"),
554 )?;
555 }
556 ScalarExpr::Array(items)
557 | ScalarExpr::Row(items)
558 | ScalarExpr::CompositeRow { items, .. } => {
559 for item in items {
560 validate(item)?;
561 }
562 }
563 ScalarExpr::Binary { lhs, rhs, .. } => {
564 validate(lhs)?;
565 validate(rhs)?;
566 if matches!(
567 (lhs.as_ref(), rhs.as_ref()),
568 (ScalarExpr::Row(_), ScalarExpr::Row(_))
569 ) {
570 reject_set_descendant(
571 engine,
572 resolver,
573 [lhs.as_ref(), rhs.as_ref()],
574 schema,
575 params,
576 row_comparison_set_error,
577 )?;
578 }
579 }
580 ScalarExpr::InSubquery { expr, .. } => {
581 validate(expr)?;
582 reject_set_descendant(
583 engine,
584 resolver,
585 [expr.as_ref()],
586 schema,
587 params,
588 row_comparison_set_error,
589 )?;
590 }
591 ScalarExpr::Default
592 | ScalarExpr::Star
593 | ScalarExpr::QualifiedStar(_)
594 | ScalarExpr::Column(_)
595 | ScalarExpr::Position(_)
596 | ScalarExpr::InternalColumn(_)
597 | ScalarExpr::QualifiedColumn { .. }
598 | ScalarExpr::Literal(_)
599 | ScalarExpr::TypedLiteral { .. }
600 | ScalarExpr::Param(_)
601 | ScalarExpr::ScalarSubquery(_)
602 | ScalarExpr::Exists { .. } => {}
603 }
604 Ok(())
605}
606
607pub fn validate_projection_set_contexts(
608 engine: &dyn SetFunctionCatalog,
609 resolver: &dyn FunctionTypeResolver,
610 projections: &[ProjectionPlan],
611 schema: &RowSchema,
612 params: &[SQLParam],
613) -> Result<(), SQLError> {
614 if !placing_set_calls() {
615 return Ok(());
616 }
617 for projection in projections {
618 validate_set_context(engine, resolver, &projection.expr, schema, params)?;
619 }
620 Ok(())
621}
622
623pub fn validate_query_set_contexts(
625 engine: &dyn SetFunctionCatalog,
626 resolver: &dyn FunctionTypeResolver,
627 statement: &QueryBlockPlan,
628 schema: &RowSchema,
629 params: &[SQLParam],
630) -> Result<(), SQLError> {
631 if !placing_set_calls() {
632 return Ok(());
633 }
634 validate_projection_set_contexts(engine, resolver, &statement.projections, schema, params)?;
635 for (clause, placement) in [
636 (statement.r#where.as_ref(), SetPlacement::Where),
637 (statement.having.as_ref(), SetPlacement::Having),
638 ] {
639 reject_set_placement(engine, resolver, clause, schema, params, placement)?;
640 }
641 for expression in statement
642 .order_by
643 .iter()
644 .map(|order| &order.expr)
645 .chain(statement.group_by.iter())
646 .chain(statement.grouping_sets.iter().flatten())
647 .chain(statement.distinct_on.iter())
648 {
649 validate_set_context(engine, resolver, expression, schema, params)?;
650 }
651 for (clause, placement) in [
652 (statement.offset.as_ref(), SetPlacement::Offset),
653 (statement.limit.as_ref(), SetPlacement::Limit),
654 ] {
655 reject_set_placement(engine, resolver, clause, schema, params, placement)?;
656 }
657 if let Some(source) = statement.from.as_ref() {
658 validate_source_set_contexts(engine, resolver, source, schema, params)?;
659 }
660 if let Some(locking) = statement.locking.first() {
661 for projection in &statement.projections {
662 if expression_may_return_set(engine, resolver, &projection.expr, schema, params)? {
663 return Err(SQLError::Unsupported(format!(
664 "{} is not allowed with set-returning functions in the target list",
665 locking.strength.sql_name()
666 )));
667 }
668 }
669 }
670 Ok(())
671}
672
673fn validate_source_set_contexts(
674 engine: &dyn SetFunctionCatalog,
675 resolver: &dyn FunctionTypeResolver,
676 source: &SourcePlan,
677 schema: &RowSchema,
678 params: &[SQLParam],
679) -> Result<(), SQLError> {
680 match source {
681 SourcePlan::Join {
682 left, right, on, ..
683 } => {
684 validate_source_set_contexts(engine, resolver, left, schema, params)?;
685 validate_source_set_contexts(engine, resolver, right, schema, params)?;
686 if let Some(condition) = on {
687 reject_set_placement(
688 engine,
689 resolver,
690 [condition],
691 schema,
692 params,
693 SetPlacement::JoinCondition,
694 )?;
695 }
696 }
697 SourcePlan::Values { rows, .. } => {
698 validate_values_set_contexts(engine, resolver, rows, schema, params)?;
699 }
700 SourcePlan::Function { args, .. } => {
701 reject_set_descendant(engine, resolver, args, schema, params, top_level_from)?;
702 }
703 SourcePlan::FunctionGroup { functions, .. } => {
704 for function in functions {
705 reject_set_descendant(
706 engine,
707 resolver,
708 &function.args,
709 schema,
710 params,
711 top_level_from,
712 )?;
713 }
714 }
715 SourcePlan::Subquery { .. } | SourcePlan::Table { .. } => {}
716 }
717 Ok(())
718}
719
720pub fn validate_source_set_contexts_before_build(
721 engine: &dyn SetFunctionCatalog,
722 resolver: &dyn FunctionTypeResolver,
723 source: &SourcePlan,
724 params: &[SQLParam],
725 ctes: &BindingContext<'_>,
726 outer: Option<&RowSchema>,
727) -> Result<(), SQLError> {
728 if !placing_set_calls() {
729 return Ok(());
730 }
731 match source {
732 SourcePlan::Join {
733 left,
734 right,
735 lateral,
736 ..
737 } => {
738 validate_source_set_contexts_before_build(engine, resolver, left, params, ctes, outer)?;
739 let left_schema =
740 crate::binding::bind_source_plan_schema(engine, left, params, ctes, outer)?;
741 let implicit_lateral_function = matches!(
742 right.as_ref(),
743 SourcePlan::Function { .. } | SourcePlan::FunctionGroup { .. }
744 );
745 let right_scope = (*lateral || implicit_lateral_function)
746 .then(|| overlay_set_validation_scope(&left_schema, outer));
747 validate_source_set_contexts_before_build(
748 engine,
749 resolver,
750 right,
751 params,
752 ctes,
753 right_scope.as_ref().or(outer),
754 )
755 }
756 SourcePlan::Values { rows, .. } => {
757 let empty = RowSchema::default();
758 validate_values_set_contexts(engine, resolver, rows, outer.unwrap_or(&empty), params)
759 }
760 SourcePlan::Function { args, .. } => {
761 let empty = RowSchema::default();
762 reject_set_descendant(
763 engine,
764 resolver,
765 args,
766 outer.unwrap_or(&empty),
767 params,
768 top_level_from,
769 )
770 }
771 SourcePlan::FunctionGroup { functions, .. } => {
772 let empty = RowSchema::default();
773 for function in functions {
774 reject_set_descendant(
775 engine,
776 resolver,
777 &function.args,
778 outer.unwrap_or(&empty),
779 params,
780 top_level_from,
781 )?;
782 }
783 Ok(())
784 }
785 SourcePlan::Subquery { .. } | SourcePlan::Table { .. } => Ok(()),
786 }
787}
788
789fn overlay_set_validation_scope(current: &RowSchema, outer: Option<&RowSchema>) -> RowSchema {
790 let Some(outer) = outer else {
791 return current.clone();
792 };
793 let columns = outer
794 .identities()
795 .iter()
796 .enumerate()
797 .map(|(position, identity)| (identity.clone(), outer.column_type(position).cloned()))
798 .collect::<Vec<_>>();
799 RowSchema::with_typed_outer_identities(current, &columns)
800}
801
802pub fn validate_values_set_contexts(
803 engine: &dyn SetFunctionCatalog,
804 resolver: &dyn FunctionTypeResolver,
805 rows: &[Vec<ScalarExpr>],
806 schema: &RowSchema,
807 params: &[SQLParam],
808) -> Result<(), SQLError> {
809 if !placing_set_calls() {
810 return Ok(());
811 }
812 reject_set_placement(
813 engine,
814 resolver,
815 rows.iter().flatten(),
816 schema,
817 params,
818 SetPlacement::Values,
819 )
820}
821
822#[cfg(test)]
823mod tests;