Skip to main content

uqa_sql/binding/
mod.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Static relational row-type binding.
8//!
9//! This module derives source and query output schemas from plans, catalog
10//! declarations, and already-bound CTE schemas. It never executes a query or
11//! samples a result row, so empty, spilled, and correlated relations retain
12//! the same declared `PostgreSQL` type identities as non-empty relations.
13
14mod analysis;
15pub mod catalog_sources;
16mod command_scopes;
17mod commands;
18pub mod composite_dependencies;
19mod composite_inputs;
20pub mod composite_rename;
21mod cte_controls;
22mod ctes;
23mod dependencies;
24pub mod legacy_collations;
25pub mod legacy_patterns;
26mod merge_scopes;
27mod ordered_calls;
28mod preparation;
29mod projection;
30mod record_fields;
31mod routine_binding;
32mod routine_parameters;
33mod scope;
34mod source_schemas;
35mod sources;
36pub mod statements;
37mod type_resolution;
38mod variable_sites;
39
40pub use commands::analyze_prepared_command_schema;
41pub use preparation::{
42    analyze_column_type_transform, assign_stored_query_input_collations,
43    infer_prepared_parameter_types,
44};
45pub(crate) use preparation::{
46    analyze_default_inputs, analyze_routine_body_argument, analyze_routine_body_inputs,
47    prepare_routine_body_inputs,
48};
49pub(crate) use preparation::{
50    analyze_domain_check, analyze_stored_expression_inputs, analyze_table_check,
51    assign_stored_input_collations, read_prepared_inputs,
52};
53
54#[cfg(test)]
55mod tests;
56
57pub use cte_controls::{analyze_recursive_control_step, extend_cte_generated_schema};
58pub use projection::{
59    analyze_projection_output_schema, bind_projection_output_schema,
60    validate_query_block_expression_types, validate_query_block_references,
61};
62pub use routine_binding::{
63    bind_expression_plan_routines_for_storage, bind_query_plan_routines_for_storage,
64    bind_syntax_query_plan_routines,
65};
66pub use routine_parameters::{bind_routine_parameter_references, RoutineParameterScope};
67pub use scope::{
68    analyze_expression_plan_type, analyze_query_plan_schema,
69    analyze_query_plan_schema_with_catalog, bind_expression_plan_type, bind_query_plan_schema,
70};
71pub use scope::{overlay_outer_schema, values_schema_in_scope, values_types_in_scope};
72pub use sources::{
73    analyze_source_plan_schema, bind_source_plan_schema, bind_source_plan_schema_for_execution,
74    with_query_table_pseudo_columns,
75};
76pub use variable_sites::{resolve_variable_sites, VariableSiteResolution};
77
78use catalog_sources::operator_join_relation_schemas;
79use cte_controls::extend_recursive_cte_binding_schema;
80pub use cte_controls::hide_recursive_generated_schema;
81use projection::{projection_star_columns, rename_schema};
82use sources::{alias_table_schema, table_function_member_source, JoinSchemaBinding};
83use type_resolution::QueryFunctionTypeResolver;
84
85use crate::plan::{QueryBlockPlan, QueryPlan, RelationalPlan, SourcePlan};
86use crate::semantics::{cte_references_own_name, expr_contains_subquery, projection_columns};
87use crate::{SQLError, SQLParam, ScalarExpr};
88use catalog_sources::user_function_output_columns;
89pub use context::BindingContext;
90
91pub mod context;
92mod rule_inputs;
93use crate::ast::ColumnType;
94use crate::catalog::analysis::CatalogReadView;
95use crate::catalog::resolution::RelationNameResolution;
96use crate::routines::RoutineResolution;
97use crate::semantics::sets::placement_scope::SetPlacementScope;
98use crate::semantics::{
99    apply_table_function_aliases, table_function_column_types, table_function_empty_schema,
100    validate_table_function_alias_count, validate_table_function_column_definition,
101    TableFunctionTypeRequest,
102};
103use crate::RowSchema;
104use std::collections::{BTreeMap, BTreeSet};
105
106#[derive(Clone, Copy)]
107enum ScalarBindingMode {
108    References,
109    Stored,
110    CompositeInputs,
111}
112
113struct SchemaScope {
114    collations: preparation::PendingCollations,
115    catalog: CatalogReadView,
116    resolution: RelationNameResolution,
117    ctes: BTreeMap<String, RowSchema>,
118    deferred_ctes: BTreeMap<String, crate::plan::CtePlan>,
119    non_returning_ctes: BTreeSet<String>,
120    visiting_views: BTreeSet<String>,
121    validate_references: bool,
122    stored_expression_outer: Option<RowSchema>,
123    rule_condition_event: Option<crate::ast::RuleEvent>,
124    /// Native MERGE action syntax is legal in a RETURNING expression and its descendant queries.
125    merge_returning: bool,
126    /// The kind of expression under analysis at this query level, which decides where a set-returning call may appear, as `PostgreSQL`'s `p_expr_kind` does.
127    set_placement: crate::semantics::sets::placement::SetPlacement,
128    /// The set-returning calls analyzed so far at this query level. Two readings differ exactly when an expression analyzed between them contains one, as `PostgreSQL` compares `p_last_srf`.
129    set_calls: usize,
130    stored_whole_rows: BTreeMap<String, ScalarExpr>,
131    /// The parameters of the SQL routine whose body is bound, as the outermost scope: a reference that resolves into them, because no column of any query level takes its name, becomes the positional parameter it names.
132    routine_parameters: Option<RoutineParameterScope>,
133    /// Select reference resolution, complete stored binding, or prepared composite identity retention.
134    scalar_binding: ScalarBindingMode,
135    /// The names of a `PL/pgSQL` statement that the function's variables take, checked against what the statement can see.
136    variable_sites: Option<variable_sites::VariableSites>,
137    /// Keep `*` projections and `GROUP BY` output-name references as written, so a bound copy of stored syntax still corresponds to that syntax node for node.
138    preserve_syntax_shape: bool,
139    prepared_dependencies: Option<crate::prepared::dependencies::PreparedAnalysisDependencies>,
140    composite_dependencies: Option<Vec<crate::catalog::dependencies::ObjectAddress>>,
141}
142
143fn non_returning_cte_error(name: &str) -> SQLError {
144    SQLError::Unsupported(format!(
145        "WITH query \"{name}\" does not have a RETURNING clause"
146    ))
147}
148
149impl SchemaScope {
150    fn from_context(ctes: &BindingContext) -> Result<Self, SQLError> {
151        Ok(Self {
152            collations: preparation::PendingCollations::default(),
153            catalog: ctes.catalog.clone(),
154            resolution: ctes.resolution.clone(),
155            ctes: ctes.ctes.clone(),
156            deferred_ctes: ctes.deferred_ctes.clone(),
157            non_returning_ctes: ctes.non_returning_ctes.clone(),
158            visiting_views: BTreeSet::new(),
159            validate_references: false,
160            stored_expression_outer: None,
161            rule_condition_event: None,
162            merge_returning: false,
163            set_placement: crate::semantics::sets::placement::SetPlacement::Expanding,
164            set_calls: 0,
165            stored_whole_rows: BTreeMap::new(),
166            routine_parameters: None,
167            scalar_binding: ScalarBindingMode::Stored,
168            variable_sites: None,
169            preserve_syntax_shape: false,
170            prepared_dependencies: None,
171            composite_dependencies: None,
172        })
173    }
174
175    fn for_analysis(ctes: &BindingContext) -> Result<Self, SQLError> {
176        let mut scope = Self::from_context(ctes)?;
177        scope.validate_references = true;
178        Ok(scope)
179    }
180
181    fn for_catalog_analysis(catalog: CatalogReadView, resolution: RelationNameResolution) -> Self {
182        Self {
183            collations: preparation::PendingCollations::default(),
184            catalog,
185            resolution,
186            ctes: BTreeMap::new(),
187            deferred_ctes: BTreeMap::new(),
188            non_returning_ctes: BTreeSet::new(),
189            visiting_views: BTreeSet::new(),
190            validate_references: true,
191            stored_expression_outer: None,
192            rule_condition_event: None,
193            merge_returning: false,
194            set_placement: crate::semantics::sets::placement::SetPlacement::Expanding,
195            set_calls: 0,
196            stored_whole_rows: BTreeMap::new(),
197            routine_parameters: None,
198            scalar_binding: ScalarBindingMode::Stored,
199            variable_sites: None,
200            preserve_syntax_shape: false,
201            prepared_dependencies: None,
202            composite_dependencies: None,
203        }
204    }
205
206    fn bind_query(
207        &mut self,
208        routines: &dyn RoutineResolution,
209        plan: &QueryPlan,
210        params: &[SQLParam],
211        outer: Option<&RowSchema>,
212    ) -> Result<RowSchema, SQLError> {
213        let lookup_mode = if plan.relations_bound {
214            crate::catalog::resolution::RelationLookupMode::Bound
215        } else {
216            crate::catalog::resolution::RelationLookupMode::Dynamic
217        };
218        let previous = self.resolution.set_lookup_mode(lookup_mode);
219        let result = self.bind_query_inner(routines, plan, params, outer);
220        self.resolution.set_lookup_mode(previous);
221        result
222    }
223
224    fn bind_query_inner(
225        &mut self,
226        routines: &dyn RoutineResolution,
227        plan: &QueryPlan,
228        params: &[SQLParam],
229        outer: Option<&RowSchema>,
230    ) -> Result<RowSchema, SQLError> {
231        let previous = self.bind_cte_schemas(routines, &plan.ctes, params, outer)?;
232
233        let result = self.bind_root(routines, &plan.root, params, outer);
234        self.restore_cte_schemas(previous);
235        let output = result?;
236        self.collations.validate_query(plan)?;
237        Ok(output)
238    }
239
240    fn bind_recursive_seed(
241        &mut self,
242        routines: &dyn RoutineResolution,
243        plan: &QueryPlan,
244        params: &[SQLParam],
245        outer: Option<&RowSchema>,
246    ) -> Result<RowSchema, SQLError> {
247        match &plan.root {
248            RelationalPlan::SetOp { left, .. } => self.bind_query(routines, left, params, outer),
249            _ => self.bind_root(routines, &plan.root, params, outer),
250        }
251    }
252
253    fn bind_root(
254        &mut self,
255        routines: &dyn RoutineResolution,
256        root: &RelationalPlan,
257        params: &[SQLParam],
258        outer: Option<&RowSchema>,
259    ) -> Result<RowSchema, SQLError> {
260        match root {
261            RelationalPlan::QueryBlock(block) => {
262                self.bind_query_block(routines, block, params, outer)
263            }
264            RelationalPlan::SetOp { .. } => {
265                preparation::set_metadata(self, routines, root, outer, params)
266            }
267            RelationalPlan::Values { rows, subqueries } => {
268                self.bind_values_schema(routines, rows, subqueries, outer, params)
269            }
270        }
271    }
272
273    fn bind_query_block(
274        &mut self,
275        routines: &dyn RoutineResolution,
276        block: &QueryBlockPlan,
277        params: &[SQLParam],
278        outer: Option<&RowSchema>,
279    ) -> Result<RowSchema, SQLError> {
280        let source = block.from.as_ref().map_or_else(
281            || Ok(RowSchema::default()),
282            |source| self.bind_source(routines, source, &block.subqueries, params, outer),
283        )?;
284        // Query-owned metadata types belong to both analysis and metadata-only binding.
285        let source = analysis::with_query_source_columns(&source, block);
286        let expression_schema = overlay_outer_schema(&source, outer);
287        let output = preparation::block_metadata(self, routines, block, &source, outer, params)?;
288        let output = analysis::with_projected_open_columns(&output, &block.projections, &source);
289        if self.validate_references {
290            self.validate_query_block_clauses(
291                routines,
292                block,
293                &expression_schema,
294                &output,
295                params,
296                outer,
297            )?;
298        }
299        Ok(output)
300    }
301
302    fn bind_expression_type(
303        &mut self,
304        routines: &dyn RoutineResolution,
305        expression: &ScalarExpr,
306        schema: &RowSchema,
307        subqueries: &[QueryPlan],
308        params: &[SQLParam],
309    ) -> Result<Option<ColumnType>, SQLError> {
310        if let ScalarExpr::ScalarSubquery(index) = expression {
311            let plan = subqueries.get(*index).ok_or_else(|| {
312                SQLError::Internal(format!("scalar subquery slot {index} is out of bounds"))
313            })?;
314            // Result typing and validation share the complete lexical row scope.
315            let subquery_outer = Some(schema);
316            let output = self.bind_query(routines, plan, params, subquery_outer)?;
317            return Ok(output.column_type(0).cloned());
318        }
319        let schema = self.with_stored_outer_internal_aliases(schema);
320        let schema = &schema;
321        let resolver =
322            self.query_function_type_resolver(routines, expression, schema, subqueries, params)?;
323        if self.validate_references {
324            Self::validate_expression_references_with_resolver(
325                self.rule_condition_event,
326                routines,
327                expression,
328                schema,
329                None,
330                params,
331                &resolver,
332            )?;
333        }
334        crate::type_resolution::validate_catalog_literals(expression, schema, params, &resolver)?;
335        crate::scalar_type_with_resolver(expression, schema, params, &resolver)
336    }
337
338    fn bind_projection_metadata(
339        &mut self,
340        routines: &dyn RoutineResolution,
341        expression: &ScalarExpr,
342        schema: &RowSchema,
343        subqueries: &[QueryPlan],
344        params: &[SQLParam],
345    ) -> Result<projection::ProjectionMetadata, SQLError> {
346        let schema = self.with_stored_outer_internal_aliases(schema);
347        preparation::projection_metadata(self, routines, expression, &schema, subqueries, params)
348    }
349
350    #[expect(
351        clippy::too_many_lines,
352        reason = "preserves SELECT schema and row identity"
353    )]
354    fn bind_source_inner(
355        &mut self,
356        routines: &dyn RoutineResolution,
357        source: &SourcePlan,
358        subqueries: &[QueryPlan],
359        params: &[SQLParam],
360        outer: Option<&RowSchema>,
361    ) -> Result<RowSchema, SQLError> {
362        match source {
363            SourcePlan::Table {
364                name,
365                qualifier,
366                alias,
367                column_aliases,
368                bound_columns,
369                ..
370            } => {
371                let qualifier = alias.as_deref().unwrap_or(qualifier);
372                let cte_name = crate::semantics::cte_reference_name(name);
373                if let Some(schema) = cte_name.as_ref().and_then(|name| self.ctes.get(name)) {
374                    if let Some(name) = cte_name
375                        .as_ref()
376                        .filter(|name| self.non_returning_ctes.contains(*name))
377                    {
378                        return Err(non_returning_cte_error(name));
379                    }
380                    return alias_table_schema(schema, qualifier, column_aliases);
381                }
382                if let Some(plan) = cte_name
383                    .as_ref()
384                    .and_then(|name| self.deferred_ctes.get(name))
385                {
386                    if !plan.body.returns_rows() {
387                        return Err(non_returning_cte_error(&plan.name));
388                    }
389                }
390                if let Some(plan) = cte_name.and_then(|name| self.deferred_ctes.remove(&name)) {
391                    let result = self
392                        .bind_cte_body(routines, &plan.body, params, outer)
393                        .and_then(|schema| {
394                            let schema = rename_schema(&schema, &plan.columns, Some(qualifier));
395                            alias_table_schema(&schema, qualifier, column_aliases)
396                        });
397                    self.deferred_ctes.insert(plan.name.clone(), plan);
398                    return result;
399                }
400                if self.catalog.sequence_exists(&self.resolution, name)? {
401                    self.record_relation_dependency(name)?;
402                    let schema = RowSchema::with_qualified_types(
403                        qualifier,
404                        vec!["last_value".into(), "log_cnt".into(), "is_called".into()],
405                        vec![
406                            Some(ColumnType::BigInteger),
407                            Some(ColumnType::BigInteger),
408                            Some(ColumnType::Boolean),
409                        ],
410                    );
411                    return self.alias_relation_schema(&schema, name, qualifier, column_aliases);
412                }
413                let view = self.catalog.view_resolved(&self.resolution, name)?;
414                if let Some(view) = view {
415                    self.record_relation_dependency(name)?;
416                    if view.materialized {
417                        let columns = view.output_columns.unwrap_or_default();
418                        if columns.len() != view.materialized_column_types.len() {
419                            return Err(SQLError::Internal(format!(
420                                "materialized view `{name}` has {} columns but {} stored column types",
421                                columns.len(),
422                                view.materialized_column_types.len()
423                            )));
424                        }
425                        let schema = crate::catalog::view::materialized_view_schema(
426                            &columns,
427                            &view.materialized_column_types,
428                            view.materialized_column_collations.as_deref(),
429                        )?;
430                        let schema = RowSchema::with_relation_qualifier(&schema, qualifier);
431                        return self.alias_relation_schema(
432                            &schema,
433                            name,
434                            qualifier,
435                            column_aliases,
436                        );
437                    }
438                    let key = name.to_ascii_lowercase();
439                    if !self.visiting_views.insert(key.clone()) {
440                        return Err(SQLError::Internal(format!(
441                            "view `{name}` has a recursive schema dependency"
442                        )));
443                    }
444                    self.record_stored_query_dependencies(&view.query);
445                    // A view's stored query is bound as it was created; its set-returning calls are not placed again.
446                    let result = {
447                        let _stored = SetPlacementScope::stored_definition();
448                        self.bind_query(routines, &view.query, params, outer)
449                    }
450                    .and_then(|schema| {
451                        let schema = rename_schema(
452                            &schema,
453                            view.output_columns.as_deref().unwrap_or(&[]),
454                            Some(qualifier),
455                        );
456                        self.alias_relation_schema(&schema, name, qualifier, column_aliases)
457                    });
458                    self.visiting_views.remove(&key);
459                    return result;
460                }
461                let table = self.catalog.table_resolved(&self.resolution, name)?;
462                if let Some(table) = table {
463                    self.record_relation_dependency(name)?;
464                    let schema =
465                        RowSchema::with_column_definitions(Some(qualifier), &table.columns);
466                    let schema =
467                        crate::semantics::bound_source_schema(&schema, bound_columns.as_deref())?;
468                    let schema =
469                        self.alias_relation_schema(&schema, name, qualifier, column_aliases)?;
470                    let schema = if table.columns.is_empty() && !table.columns_declared {
471                        RowSchema::with_open_columns(&schema, Some(qualifier))
472                    } else {
473                        schema
474                    };
475                    return Ok(analysis::with_table_pseudo_columns(&schema, qualifier));
476                }
477                let foreign_table = self
478                    .catalog
479                    .foreign_table_resolved(&self.resolution, name)?;
480                if let Some(foreign_table) = foreign_table {
481                    self.record_relation_dependency(name)?;
482                    let schema =
483                        RowSchema::with_column_definitions(Some(qualifier), &foreign_table.columns);
484                    let schema =
485                        crate::semantics::bound_source_schema(&schema, bound_columns.as_deref())?;
486                    return self.alias_relation_schema(&schema, name, qualifier, column_aliases);
487                }
488                if let Some(schema) = self
489                    .catalog
490                    .virtual_relation_schema(&self.resolution, name)?
491                {
492                    self.record_relation_dependency(name)?;
493                    let (columns, types): (Vec<_>, Vec<_>) = schema
494                        .into_iter()
495                        .map(|(column, ty)| (column, Some(ty)))
496                        .unzip();
497                    let schema = RowSchema::with_qualified_types(qualifier, columns, types);
498                    return self.alias_relation_schema(&schema, name, qualifier, column_aliases);
499                }
500                if let Some(relation) = self.catalog.unopenable_relation(&self.resolution, name)? {
501                    return Err(relation.error());
502                }
503                Err(SQLError::UnknownTable(name.clone()))
504            }
505            SourcePlan::Values {
506                rows,
507                alias,
508                column_aliases,
509                internal_relation,
510                internal_column_types,
511                ..
512            } => {
513                if internal_relation.is_some()
514                    && internal_column_types.iter().any(Option::is_none)
515                    && !rows.is_empty()
516                {
517                    let inferred =
518                        self.bind_values_schema(routines, rows, subqueries, outer, params)?;
519                    if let Some(schema) =
520                        source.internal_values_schema_with_inference(Some(&inferred))?
521                    {
522                        return Ok(schema);
523                    }
524                }
525                if let Some(schema) = source.internal_values_schema()? {
526                    return Ok(schema);
527                }
528                let schema = self.bind_values_schema(routines, rows, subqueries, outer, params)?;
529                Ok(rename_schema(&schema, column_aliases, alias.as_deref()))
530            }
531            SourcePlan::Function {
532                name,
533                binding,
534                output_name,
535                relations,
536                args,
537                alias,
538                column_aliases,
539                ordinality,
540                column_types,
541                ..
542            } => {
543                let lower = crate::semantics::builtin_function_dispatch_name(name);
544                let operator_join = crate::registry::is_operator_join_table_function(&lower);
545                let operator_inputs = operator_join
546                    .then(|| {
547                        operator_join_relation_schemas(
548                            &self.catalog,
549                            &self.resolution,
550                            relations.as_ref(),
551                        )
552                    })
553                    .transpose()?;
554                let input = outer.cloned().unwrap_or_default();
555                let type_resolver = self.query_function_type_resolver_for_subqueries(
556                    routines, args, &input, subqueries, params,
557                )?;
558                let user_function = if let Some((left, right)) = operator_inputs.as_ref() {
559                    if self.validate_references {
560                        let constant = RowSchema::default();
561                        for (position, argument) in args.iter().enumerate() {
562                            let schema = match position {
563                                0 => left,
564                                1 => right,
565                                _ => &constant,
566                            };
567                            self.validate_expression_references(
568                                routines, argument, schema, None, subqueries, params,
569                            )?;
570                        }
571                    }
572                    None
573                } else if self.validate_references {
574                    self.validate_table_function_source(
575                        routines,
576                        analysis::TableFunctionSourceValidation {
577                            name,
578                            binding: binding.as_ref(),
579                            args,
580                            subqueries,
581                            input: &input,
582                            params,
583                        },
584                    )?
585                } else {
586                    crate::semantics::resolve_user_table_function(
587                        routines,
588                        name,
589                        binding.as_ref(),
590                        args,
591                        &input,
592                        params,
593                        &type_resolver,
594                    )?
595                };
596                validate_table_function_column_definition(
597                    routines,
598                    crate::semantics::ColumnDefinitionRequest {
599                        name,
600                        binding: binding.as_ref(),
601                        user_function: user_function
602                            .as_ref()
603                            .map(|resolved| resolved.function.as_ref()),
604                        user_invocation: user_function
605                            .as_ref()
606                            .and_then(|resolved| resolved.binding.invocation.as_deref()),
607                        args,
608                        declared_types: column_types,
609                        column_names: column_aliases,
610                    },
611                    &input,
612                    params,
613                    &type_resolver,
614                )?;
615                if let Some(function) = &user_function {
616                    self.record_routine_dependency(&function.binding);
617                }
618                let catalog_columns = if !self.validate_references && user_function.is_none() {
619                    user_function_output_columns(self.catalog.as_ref(), &self.resolution, name)?
620                } else {
621                    None
622                };
623                let columns = if let Some(resolved) = &user_function {
624                    crate::semantics::user_table_function_columns(
625                        routines,
626                        &resolved.function,
627                        resolved.binding.invocation.as_deref(),
628                        output_name,
629                        alias.as_deref(),
630                        column_aliases,
631                        *ordinality,
632                    )?
633                } else {
634                    catalog_columns.map_or_else(
635                        || {
636                            table_function_empty_schema(
637                                name,
638                                output_name,
639                                alias.as_deref(),
640                                column_aliases,
641                                args.len(),
642                                *ordinality,
643                            )
644                        },
645                        |columns| {
646                            apply_table_function_aliases(columns, column_aliases, *ordinality)
647                        },
648                    )
649                };
650                validate_table_function_alias_count(
651                    alias.as_deref().unwrap_or(output_name),
652                    columns.len(),
653                    column_aliases.len(),
654                )?;
655                let types = table_function_column_types(
656                    routines,
657                    TableFunctionTypeRequest {
658                        name,
659                        binding: binding.as_ref(),
660                        args,
661                        user_function: user_function
662                            .as_ref()
663                            .map(|resolved| resolved.function.as_ref()),
664                        user_invocation: user_function
665                            .as_ref()
666                            .and_then(|resolved| resolved.binding.invocation.as_deref()),
667                        declared_types: column_types,
668                        columns: &columns,
669                        ordinality: *ordinality,
670                    },
671                    &input,
672                    params,
673                    &type_resolver,
674                );
675                let qualifier = alias.as_deref().unwrap_or(output_name);
676                let schema = RowSchema::with_qualified_types(qualifier, columns, types);
677                Ok(
678                    if user_function.is_none()
679                        && column_types.is_empty()
680                        && routines.has_registered_table_function(name)
681                    {
682                        RowSchema::with_open_columns(&schema, Some(qualifier))
683                    } else {
684                        schema
685                    },
686                )
687            }
688            SourcePlan::FunctionGroup {
689                functions,
690                alias,
691                column_aliases,
692                ordinality,
693            } => {
694                let first = functions
695                    .first()
696                    .ok_or_else(|| SQLError::Internal("ROWS FROM group has no functions".into()))?;
697                let mut columns = Vec::new();
698                let mut types = Vec::new();
699                let mut open = false;
700                for function in functions {
701                    let member = table_function_member_source(function);
702                    let schema = self.bind_source(routines, &member, subqueries, params, outer)?;
703                    open |= schema.columns_are_open(None);
704                    columns.extend(schema.iter().enumerate().map(|(position, column)| {
705                        schema.public_name(position).unwrap_or(column).to_string()
706                    }));
707                    types.extend(schema.column_types().iter().cloned());
708                }
709                if *ordinality {
710                    columns.push("ordinality".into());
711                    types.push(Some(ColumnType::BigInteger));
712                }
713                let qualifier = alias.as_deref().unwrap_or(&first.output_name);
714                validate_table_function_alias_count(
715                    qualifier,
716                    columns.len(),
717                    column_aliases.len(),
718                )?;
719                for (column, alias) in columns.iter_mut().zip(column_aliases) {
720                    column.clone_from(alias);
721                }
722                let schema = RowSchema::with_qualified_types(qualifier, columns, types);
723                Ok(if open {
724                    RowSchema::with_open_columns(&schema, Some(qualifier))
725                } else {
726                    schema
727                })
728            }
729            SourcePlan::Subquery {
730                body,
731                alias,
732                column_aliases,
733            } => {
734                let schema = self.bind_query(routines, body, params, outer)?;
735                Ok(rename_schema(&schema, column_aliases, alias.as_deref()))
736            }
737            SourcePlan::Join {
738                left,
739                right,
740                kind,
741                on,
742                using,
743                natural,
744                alias,
745                column_aliases,
746                lateral,
747                ..
748            } => {
749                let left_schema = self.bind_source(routines, left, subqueries, params, outer)?;
750                let implicit_lateral_function = matches!(
751                    right.as_ref(),
752                    SourcePlan::Function { .. } | SourcePlan::FunctionGroup { .. }
753                );
754                let right_scope = (*lateral || implicit_lateral_function)
755                    .then(|| overlay_outer_schema(&left_schema, outer));
756                let right_schema = self.bind_source(
757                    routines,
758                    right,
759                    subqueries,
760                    params,
761                    right_scope.as_ref().or(outer),
762                )?;
763                self.bind_join_output_schema(JoinSchemaBinding {
764                    routines,
765                    kind: *kind,
766                    on: on.as_ref(),
767                    using: using.as_ref(),
768                    natural: *natural,
769                    alias: alias.as_deref(),
770                    column_aliases,
771                    left: &left_schema,
772                    right: &right_schema,
773                    subqueries,
774                    params,
775                    outer,
776                })
777            }
778        }
779    }
780}
781
782#[cfg(test)]
783pub(crate) mod fixture;
784
785pub mod correlation;
786
787pub mod stored_columns;
788pub mod stored_relations;
789pub mod stored_routines;
790pub mod stored_types;
791pub mod syntax_sites;
792
793pub mod scoped_types;
794pub mod snapshot;
795
796pub mod view_dependencies;
797
798pub mod portals;