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::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
353/// Reject `expressions` when any contains a set-returning call outside its subqueries.
354fn 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
368/// Reject a set-returning call in a clause whose expression kind admits none.
369fn 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/// Check a target-list expression in `PostgreSQL`'s transformation order: each construct's inputs first, then the construct.
384#[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                // A searched WHEN is coerced to boolean; a simple CASE compares a placeholder for its base with the WHEN value.
492                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
625/// 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.
626pub 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;