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