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;
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 merge_returning: bool,
129 set_placement: crate::semantics::sets::placement::SetPlacement,
131 set_calls: usize,
133 stored_whole_rows: BTreeMap<String, ScalarExpr>,
134 routine_parameters: Option<RoutineParameterScope>,
136 scalar_binding: ScalarBindingMode,
138 variable_sites: Option<variable_sites::VariableSites>,
140 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 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 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 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;