Skip to main content

uqa_sql/semantics/sets/
validation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Set-returning expression detection and SQL context validation.
8
9use 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    // An unbound call of a set-returning built-in's name returns a set unless overload resolution selects a SQL routine of that name.
78    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        // No SQL routine of a set-returning built-in's name accepts the arguments, so the built-in does.
132        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        // A call keeps its recorded built-in binding. A stored call analyzed before its built-in had catalog signatures takes the selected declaration, which EXECUTE authorization identifies.
174        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        // A window call returns one value per row: its arguments, FILTER and frame admit no set-returning call, and its partition and ordering keys expand the rows below the window, as `expression_returns_set` treats `WindowFunc`.
283        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
352/// Reject `expressions` when any contains a set-returning call outside its subqueries.
353fn 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
367/// Reject a set-returning call in a clause whose expression kind admits none.
368fn 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/// Check a target-list expression in `PostgreSQL`'s transformation order: each construct's inputs first, then the construct.
383#[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                // A searched WHEN is coerced to boolean; a simple CASE compares a placeholder for its base with the WHEN value.
491                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
623/// Check a query block's clauses in `PostgreSQL`'s transformation order: the target list, WHERE, HAVING, ORDER BY, GROUP BY, DISTINCT ON, OFFSET, LIMIT and FROM, then the row-locking clause. A block of a stored definition is not checked again.
624pub 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;