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