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