1mod 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 merge_returning: bool,
140 set_placement: crate::semantics::sets::placement::SetPlacement,
142 set_calls: usize,
144 stored_whole_rows: BTreeMap<String, ScalarExpr>,
145 routine_parameters: Option<RoutineParameterScope>,
147 scalar_binding: ScalarBindingMode,
149 variable_sites: Option<variable_sites::VariableSites>,
151 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 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 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 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 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;