1mod expressions;
10mod helpers;
11mod joins;
12mod lifecycle;
13mod sources;
14mod statements;
15#[cfg(test)]
16mod tests;
17
18pub use lifecycle::{
19 bind_rule_action_column_dependencies, bind_rule_condition_column_dependencies,
20 bind_stored_statement_source_columns, remove_rule_source_column_aliases,
21 remove_stored_statement_source_column_aliases, rewrite_rule_column_references,
22 stored_statement_column_dependencies, stored_statement_references, StoredStatementColumns,
23};
24pub use statements::rewrite_stored_statement_column;
25
26pub trait StoredColumnCatalog {
28 fn stored_relation_column_names(&self, name: &str) -> Result<Option<Vec<String>>, SQLError>;
29}
30
31pub struct StoredSourceColumns {
33 pub catalog: crate::catalog::analysis::CatalogReadView,
34 pub resolution: crate::catalog::resolution::RelationNameResolution,
35}
36pub trait StoredSourceCatalog {
37 fn stored_source_columns(&self) -> StoredSourceColumns;
38}
39impl StoredSourceColumns {
40 pub fn bind_statement(&self, statement: &mut Statement) -> Result<bool, SQLError> {
41 bind_stored_statement_source_columns(statement, |name| {
42 Ok(
43 if let Some(table) = self.catalog.table_resolved(&self.resolution, name)? {
44 Some(
45 table
46 .columns
47 .iter()
48 .map(|column| column.name.clone())
49 .collect(),
50 )
51 } else {
52 self.catalog
53 .foreign_table_resolved(&self.resolution, name)?
54 .map(|table| {
55 table
56 .columns
57 .iter()
58 .map(|column| column.name.clone())
59 .collect()
60 })
61 },
62 )
63 })
64 }
65}
66
67#[derive(Clone, Copy)]
68pub struct StoredColumnBindingContext<'a> {
69 pub sources: &'a dyn StoredColumnCatalog,
70 pub merge: &'a dyn crate::routines::merge_columns::StoredMergeColumnCatalog,
71}
72
73use std::collections::{BTreeMap, BTreeSet};
74
75use crate::ast::{
76 DeleteStmt, Expr, FromClause, InsertStmt, OnConflictAction, Projection, SelectStmt, Statement,
77 UpdateStmt, CTE,
78};
79use crate::SQLError;
80
81use uqa_core::RelationIdentity;
82
83use crate::catalog::events::RuleColumnDependency;
84use helpers::{
85 action_returning_scope, apply_positional_aliases, is_default_values_insert, is_output_alias,
86 opaque_scope, same_identifier, select_output_names, table_alias_count_error,
87};
88
89fn cte_output_names(body: &crate::ast::CteBody) -> Vec<String> {
90 if let Some(query) = body.query() {
91 return select_output_names(query);
92 }
93 helpers::projection_output_names(body.returning().unwrap_or_default())
94}
95
96#[derive(Clone, Copy)]
97enum ColumnBindingMode<'a> {
98 Bind,
99 Rename {
100 relation: &'a RelationIdentity,
101 from: &'a str,
102 to: &'a str,
103 },
104 Drop {
105 dependencies: &'a BTreeSet<RuleColumnDependency>,
106 },
107}
108
109impl<'a> ColumnBindingMode<'a> {
110 fn column_names(self, relation: &RelationIdentity, current: &str) -> (String, String) {
111 match self {
112 Self::Rename {
113 relation: target,
114 from,
115 to,
116 } if relation == target && current == to => (from.to_string(), to.to_string()),
117 Self::Bind | Self::Rename { .. } | Self::Drop { .. } => {
118 (current.to_string(), current.to_string())
119 }
120 }
121 }
122
123 const fn is_rename(self) -> bool {
124 matches!(self, Self::Rename { .. })
125 }
126
127 const fn dropped_dependencies(self) -> Option<&'a BTreeSet<RuleColumnDependency>> {
128 match self {
129 Self::Drop { dependencies } => Some(dependencies),
130 Self::Bind | Self::Rename { .. } => None,
131 }
132 }
133}
134
135#[derive(Clone)]
136struct ScopeColumn {
137 name: String,
139 current_name: String,
141 reference: Expr,
143 dependencies: BTreeSet<RuleColumnDependency>,
144}
145
146#[derive(Clone, Default)]
147struct ColumnScope {
148 output: Vec<ScopeColumn>,
149 qualifiers: BTreeMap<String, Vec<ScopeColumn>>,
150}
151
152impl ColumnScope {
153 fn insert_qualifier(&mut self, qualifier: &str, columns: &[ScopeColumn]) {
154 self.qualifiers
155 .insert(qualifier.to_ascii_lowercase(), columns.to_vec());
156 }
157
158 fn qualified(&self, qualifier: &str) -> Option<&[ScopeColumn]> {
159 self.qualifiers
160 .get(&qualifier.to_ascii_lowercase())
161 .map(Vec::as_slice)
162 }
163
164 fn unqualified(&self, name: &str) -> Vec<&ScopeColumn> {
165 self.output
166 .iter()
167 .filter(|column| same_identifier(&column.name, name))
168 .collect()
169 }
170
171 fn combined(left: &Self, right: &Self) -> Self {
172 let mut output = left.output.clone();
173 output.extend(right.output.iter().cloned());
174 let mut qualifiers = left.qualifiers.clone();
175 qualifiers.extend(right.qualifiers.clone());
176 Self { output, qualifiers }
177 }
178}
179
180#[derive(Clone, Default)]
181struct ColumnBindingContext {
182 ctes: BTreeMap<String, Vec<String>>,
183}
184
185struct StoredColumnBinder<'a> {
186 catalog: StoredColumnBindingContext<'a>,
187 mode: ColumnBindingMode<'a>,
188 dependencies: BTreeSet<RuleColumnDependency>,
189 unresolved: Vec<(Option<String>, String)>,
191 alias_shape_changed: bool,
192}
193
194impl<'a> StoredColumnBinder<'a> {
195 fn new(catalog: StoredColumnBindingContext<'a>, mode: ColumnBindingMode<'a>) -> Self {
196 Self {
197 catalog,
198 mode,
199 dependencies: BTreeSet::new(),
200 unresolved: Vec::new(),
201 alias_shape_changed: false,
202 }
203 }
204
205 fn finish(self) -> BTreeSet<RuleColumnDependency> {
206 self.dependencies
207 }
208
209 const fn alias_shape_changed(&self) -> bool {
210 self.alias_shape_changed
211 }
212
213 fn remove_dropped_column_aliases(
214 &mut self,
215 column_aliases: &mut Vec<String>,
216 scope: &ColumnScope,
217 ) {
218 let Some(dependencies) = self.mode.dropped_dependencies() else {
219 return;
220 };
221 let positions = scope
222 .output
223 .iter()
224 .enumerate()
225 .filter_map(|(position, column)| {
226 (!column.dependencies.is_disjoint(dependencies)).then_some(position)
227 })
228 .collect::<Vec<_>>();
229 for position in positions.into_iter().rev() {
230 if position < column_aliases.len() {
231 column_aliases.remove(position);
232 self.alias_shape_changed = true;
233 }
234 }
235 }
236
237 fn table_scope(
238 &self,
239 name: &str,
240 qualifier: &str,
241 alias: Option<&str>,
242 column_aliases: &[String],
243 bound_columns: Option<&[String]>,
244 context: &ColumnBindingContext,
245 ) -> Result<ColumnScope, SQLError> {
246 if let Some(columns) = context.ctes.get(&name.to_ascii_lowercase()) {
247 if column_aliases.len() > columns.len() {
248 return Err(table_alias_count_error(
249 alias.unwrap_or(qualifier),
250 columns.len(),
251 column_aliases.len(),
252 ));
253 }
254 let mut columns = columns.clone();
255 apply_positional_aliases(&mut columns, column_aliases);
256 return Ok(opaque_scope(&columns, Some(alias.unwrap_or(qualifier))));
257 }
258 let columns = match bound_columns {
259 Some(columns) => columns.to_vec(),
260 None => self
261 .catalog
262 .sources
263 .stored_relation_column_names(name)?
264 .ok_or_else(|| SQLError::UnknownTable(name.to_string()))?,
265 };
266 if column_aliases.len() > columns.len() {
267 return Err(table_alias_count_error(
268 alias.unwrap_or(qualifier),
269 columns.len(),
270 column_aliases.len(),
271 ));
272 }
273 let relation = RelationIdentity::from_legacy_name(name).map_err(|error| {
274 SQLError::Internal(format!("decode bound rule relation `{name}`: {error}"))
275 })?;
276 let visible_qualifier = alias.unwrap_or(qualifier);
277 let output = columns
278 .into_iter()
279 .enumerate()
280 .map(|(position, column)| {
281 let (stored_physical, current_physical) =
282 self.mode.column_names(&relation, &column);
283 let name = column_aliases
284 .get(position)
285 .cloned()
286 .unwrap_or_else(|| stored_physical.clone());
287 let current_name = column_aliases
288 .get(position)
289 .cloned()
290 .unwrap_or(current_physical);
291 ScopeColumn {
292 reference: Expr::qualified_column(visible_qualifier, ¤t_name),
293 dependencies: BTreeSet::from([RuleColumnDependency {
294 relation: relation.clone(),
295 column: stored_physical,
296 }]),
297 name,
298 current_name,
299 }
300 })
301 .collect::<Vec<_>>();
302 let mut scope = ColumnScope {
303 output: output.clone(),
304 ..ColumnScope::default()
305 };
306 if let Some(alias) = alias {
307 scope.insert_qualifier(alias, &output);
308 } else {
309 scope.insert_qualifier(qualifier, &output);
310 scope.insert_qualifier(name, &output);
311 if let Some((_, local)) = name.rsplit_once('.') {
312 scope.insert_qualifier(local.trim_matches('"'), &output);
313 }
314 }
315 Ok(scope)
316 }
317
318 fn bind_statement(
319 &mut self,
320 statement: &mut Statement,
321 outer: &[ColumnScope],
322 context: &ColumnBindingContext,
323 ) -> Result<(), SQLError> {
324 match statement {
325 Statement::Select(select) => self.bind_select(select, outer, context),
326 Statement::Values { rows } => {
327 for expression in rows.iter_mut().flatten() {
328 self.bind_expr(expression, outer, context)?;
329 }
330 Ok(())
331 }
332 Statement::Insert(insert) => self.bind_insert(insert, outer, context),
333 Statement::Update(update) => self.bind_update(update, outer, context),
334 Statement::Delete(delete) => self.bind_delete(delete, outer, context),
335 Statement::Merge(merge) => self.bind_merge(merge, outer, context),
336 Statement::Notify { .. } => Ok(()),
337 _ => Err(SQLError::Internal(
338 "validated rewrite-rule action has an unsupported statement kind".into(),
339 )),
340 }
341 }
342
343 fn bind_insert(
344 &mut self,
345 insert: &mut InsertStmt,
346 outer: &[ColumnScope],
347 context: &ColumnBindingContext,
348 ) -> Result<(), SQLError> {
349 let context = self.bind_ctes(&mut insert.with, outer, context)?;
350 for expression in insert.rows.iter_mut().flatten() {
351 self.bind_expr(expression, outer, &context)?;
352 }
353 if let Some(select) = insert.select_source.as_deref_mut() {
354 self.bind_select(select, outer, &context)?;
355 }
356 let target = self.table_scope(
357 &insert.table,
358 &insert.target_qualifier,
359 Some(&insert.target_qualifier),
360 &[],
361 None,
362 &ColumnBindingContext::default(),
363 )?;
364 if insert.columns.is_empty() && !is_default_values_insert(&insert.rows) {
365 let width = insert.rows.first().map(Vec::len).or_else(|| {
366 insert
367 .select_source
368 .as_deref()
369 .map(select_output_names)
370 .map(|columns| columns.len())
371 });
372 if let Some(width) = width {
373 insert.columns = target
374 .output
375 .iter()
376 .take(width)
377 .map(|column| column.current_name.clone().into())
378 .collect();
379 }
380 }
381 for assignment in &mut insert.columns {
382 self.bind_target_name(&mut assignment.column, &target);
383 for expression in assignment.expressions_mut() {
384 self.bind_expr(expression, outer, &context)?;
385 }
386 }
387 let mut conflict_scope = target.clone();
388 conflict_scope.insert_qualifier("excluded", &target.output);
389 let mut target_scopes = vec![conflict_scope];
390 target_scopes.extend_from_slice(outer);
391 if let Some(conflict) = &mut insert.on_conflict {
392 self.bind_target_names(&mut conflict.conflict_columns, &target);
393 for expression in &mut conflict.expressions {
394 self.bind_expr(expression, &target_scopes, &context)?;
395 }
396 if let Some(predicate) = conflict.predicate.as_deref_mut() {
397 self.bind_expr(predicate, &target_scopes, &context)?;
398 }
399 if let OnConflictAction::Update {
400 assignments,
401 r#where,
402 } = &mut conflict.action
403 {
404 for (column, expression) in assignments {
405 for target_column in column.targets_mut() {
406 self.bind_target_name(&mut target_column.column, &target);
407 }
408 for expression in column.expressions_mut() {
409 self.bind_expr(expression, &target_scopes, &context)?;
410 }
411 self.bind_expr(expression, &target_scopes, &context)?;
412 }
413 if let Some(expression) = r#where {
414 self.bind_expr(expression, &target_scopes, &context)?;
415 }
416 }
417 }
418 let returning = action_returning_scope(
419 &target,
420 &target,
421 crate::ast::RuleEvent::Insert,
422 &insert.returning_aliases,
423 );
424 let mut returning_scopes = vec![returning.clone()];
425 returning_scopes.extend_from_slice(outer);
426 self.bind_projections(
427 &mut insert.returning,
428 Some(&returning),
429 &returning_scopes,
430 &context,
431 )
432 }
433
434 fn bind_update(
435 &mut self,
436 update: &mut UpdateStmt,
437 outer: &[ColumnScope],
438 context: &ColumnBindingContext,
439 ) -> Result<(), SQLError> {
440 let context = self.bind_ctes(&mut update.with, outer, context)?;
441 let target = self.table_scope(
442 &update.table,
443 &update.target_qualifier,
444 Some(&update.target_qualifier),
445 &[],
446 None,
447 &ColumnBindingContext::default(),
448 )?;
449 let (local, scopes) =
450 self.bind_dml_source(update.from.as_mut(), &target, outer, &context)?;
451 for (column, expression) in &mut update.assignments {
452 for target_column in column.targets_mut() {
453 self.bind_target_name(&mut target_column.column, &target);
454 }
455 for expression in column.expressions_mut() {
456 self.bind_expr(expression, &scopes, &context)?;
457 }
458 self.bind_expr(expression, &scopes, &context)?;
459 }
460 if let Some(expression) = &mut update.r#where {
461 self.bind_expr(expression, &scopes, &context)?;
462 }
463 let returning = action_returning_scope(
464 &local,
465 &target,
466 crate::ast::RuleEvent::Update,
467 &update.returning_aliases,
468 );
469 let mut returning_scopes = vec![returning.clone()];
470 returning_scopes.extend_from_slice(outer);
471 self.bind_projections(
472 &mut update.returning,
473 Some(&returning),
474 &returning_scopes,
475 &context,
476 )
477 }
478
479 fn bind_delete(
480 &mut self,
481 delete: &mut DeleteStmt,
482 outer: &[ColumnScope],
483 context: &ColumnBindingContext,
484 ) -> Result<(), SQLError> {
485 let context = self.bind_ctes(&mut delete.with, outer, context)?;
486 let target = self.table_scope(
487 &delete.table,
488 &delete.target_qualifier,
489 Some(&delete.target_qualifier),
490 &[],
491 None,
492 &ColumnBindingContext::default(),
493 )?;
494 let (local, scopes) =
495 self.bind_dml_source(delete.using.as_mut(), &target, outer, &context)?;
496 if let Some(expression) = &mut delete.r#where {
497 self.bind_expr(expression, &scopes, &context)?;
498 }
499 let returning = action_returning_scope(
500 &local,
501 &target,
502 crate::ast::RuleEvent::Delete,
503 &delete.returning_aliases,
504 );
505 let mut returning_scopes = vec![returning.clone()];
506 returning_scopes.extend_from_slice(outer);
507 self.bind_projections(
508 &mut delete.returning,
509 Some(&returning),
510 &returning_scopes,
511 &context,
512 )
513 }
514
515 fn bind_dml_source(
516 &mut self,
517 source: Option<&mut FromClause>,
518 target: &ColumnScope,
519 outer: &[ColumnScope],
520 context: &ColumnBindingContext,
521 ) -> Result<(ColumnScope, Vec<ColumnScope>), SQLError> {
522 let mut source_outer = vec![target.clone()];
523 source_outer.extend_from_slice(outer);
524 let source = source
525 .map(|source| self.bind_from(source, &source_outer, context))
526 .transpose()?;
527 let local = source.as_ref().map_or_else(
528 || target.clone(),
529 |source| ColumnScope::combined(target, source),
530 );
531 let mut scopes = vec![local.clone()];
532 scopes.extend_from_slice(outer);
533 Ok((local, scopes))
534 }
535
536 fn bind_target_names(&mut self, names: &mut [String], target: &ColumnScope) {
537 for name in names {
538 self.bind_target_name(name, target);
539 }
540 }
541
542 fn bind_target_name(&mut self, name: &mut String, target: &ColumnScope) {
543 let Some(column) = target
544 .output
545 .iter()
546 .find(|column| same_identifier(&column.name, name))
547 else {
548 return;
549 };
550 self.dependencies
551 .extend(column.dependencies.iter().cloned());
552 name.clone_from(&column.current_name);
553 }
554
555 fn bind_ctes(
556 &mut self,
557 ctes: &mut [CTE],
558 outer: &[ColumnScope],
559 context: &ColumnBindingContext,
560 ) -> Result<ColumnBindingContext, SQLError> {
561 let mut visible = context.clone();
562 let recursive_names = ctes
563 .iter()
564 .filter(|cte| cte.recursive)
565 .map(|cte| {
566 let columns = if cte.columns.is_empty() {
567 cte_output_names(&cte.body)
568 } else {
569 cte.columns.clone()
570 };
571 (cte.name.to_ascii_lowercase(), columns)
572 })
573 .collect::<Vec<_>>();
574 for (name, columns) in recursive_names {
575 visible.ctes.entry(name).or_insert(columns);
576 }
577 for cte in ctes {
578 let mut statement = cte.body.clone().into_statement();
579 self.bind_statement(&mut statement, outer, &visible)?;
580 cte.body = statement.try_into()?;
581 if let Some(cycle) = &mut cte.cycle {
582 self.bind_expr(&mut cycle.mark_value, outer, &visible)?;
583 self.bind_expr(&mut cycle.mark_default, outer, &visible)?;
584 }
585 let mut columns = cte_output_names(&cte.body);
586 apply_positional_aliases(&mut columns, &cte.columns);
587 if let Some(search) = &cte.search {
588 columns.push(search.sequence_column.clone());
589 }
590 if let Some(cycle) = &cte.cycle {
591 columns.push(cycle.mark_column.clone());
592 columns.push(cycle.path_column.clone());
593 }
594 visible.ctes.insert(cte.name.to_ascii_lowercase(), columns);
595 }
596 Ok(visible)
597 }
598
599 fn bind_select(
600 &mut self,
601 select: &mut SelectStmt,
602 outer: &[ColumnScope],
603 context: &ColumnBindingContext,
604 ) -> Result<(), SQLError> {
605 let context = self.bind_ctes(&mut select.with, outer, context)?;
606 let local = select
607 .from
608 .as_mut()
609 .map(|source| self.bind_from(source, outer, &context))
610 .transpose()?;
611 let mut scopes = local.iter().cloned().collect::<Vec<_>>();
612 scopes.extend_from_slice(outer);
613 self.bind_projections(&mut select.projections, local.as_ref(), &scopes, &context)?;
614 for expression in select.values.iter_mut().flatten() {
615 self.bind_expr(expression, &scopes, &context)?;
616 }
617 if let Some(expression) = &mut select.r#where {
618 self.bind_expr(expression, &scopes, &context)?;
619 }
620 for expression in &mut select.group_by {
621 self.bind_expr(expression, &scopes, &context)?;
622 }
623 for expression in select.grouping_sets.iter_mut().flatten() {
624 self.bind_expr(expression, &scopes, &context)?;
625 }
626 if let Some(expression) = &mut select.having {
627 self.bind_expr(expression, &scopes, &context)?;
628 }
629 let output_names = select_output_names(select);
630 for order in &mut select.order_by {
631 if !is_output_alias(&order.expr, &output_names) {
632 self.bind_expr(&mut order.expr, &scopes, &context)?;
633 }
634 }
635 if let Some(expression) = &mut select.limit {
636 self.bind_expr(expression, &scopes, &context)?;
637 }
638 if let Some(expression) = &mut select.offset {
639 self.bind_expr(expression, &scopes, &context)?;
640 }
641 for expression in &mut select.distinct_on {
642 self.bind_expr(expression, &scopes, &context)?;
643 }
644 if let Some(set) = &mut select.set_op {
645 if let Some(left) = &mut set.left {
646 self.bind_select(left, outer, &context)?;
647 }
648 self.bind_select(&mut set.right, outer, &context)?;
649 let set_output = set
650 .left
651 .as_deref()
652 .map_or_else(|| output_names.clone(), select_output_names);
653 for order in &mut set.combined_order_by {
654 if !is_output_alias(&order.expr, &set_output) {
655 self.bind_expr(&mut order.expr, outer, &context)?;
656 }
657 }
658 if let Some(expression) = &mut set.combined_limit {
659 self.bind_expr(expression, outer, &context)?;
660 }
661 if let Some(expression) = &mut set.combined_offset {
662 self.bind_expr(expression, outer, &context)?;
663 }
664 }
665 Ok(())
666 }
667
668 fn bind_from(
669 &mut self,
670 source: &mut FromClause,
671 outer: &[ColumnScope],
672 context: &ColumnBindingContext,
673 ) -> Result<ColumnScope, SQLError> {
674 self.bind_from_in_scope(source, outer, None, false, context)
675 }
676
677 fn bind_from_in_scope(
678 &mut self,
679 source: &mut FromClause,
680 outer: &[ColumnScope],
681 preceding: Option<&ColumnScope>,
682 inherited_lateral: bool,
683 context: &ColumnBindingContext,
684 ) -> Result<ColumnScope, SQLError> {
685 if matches!(source, FromClause::Join { .. }) {
686 return self.bind_join(source, outer, preceding, context);
687 }
688 let active = inherited_lateral
689 || source.is_explicitly_lateral()
690 || matches!(
691 source,
692 FromClause::Function { .. } | FromClause::FunctionGroup { .. }
693 );
694 let mut input = Vec::new();
695 if active {
696 input.extend(preceding.cloned());
697 }
698 input.extend_from_slice(outer);
699 let outer = input.as_slice();
700 match source {
701 crate::ast::FromClause::RetainedRows(_) => Ok(opaque_scope(&[], None)),
702 source @ FromClause::Table { .. } => self.bind_table_source(source, context),
703 FromClause::Join { .. } => unreachable!("joins retain their preceding namespace"),
704 FromClause::Values {
705 rows,
706 alias,
707 column_aliases,
708 ..
709 } => {
710 for expression in rows.iter_mut().flatten() {
711 self.bind_expr(expression, outer, context)?;
712 }
713 let mut columns = if column_aliases.is_empty() {
714 (1..=rows.first().map_or(0, Vec::len))
715 .map(|position| format!("column{position}"))
716 .collect::<Vec<_>>()
717 } else {
718 column_aliases.clone()
719 };
720 apply_positional_aliases(&mut columns, column_aliases);
721 Ok(opaque_scope(&columns, alias.as_deref()))
722 }
723 FromClause::Function {
724 output_name,
725 args,
726 alias,
727 column_aliases,
728 ordinality,
729 ..
730 } => {
731 for expression in args {
732 self.bind_expr(expression, outer, context)?;
733 }
734 let mut columns = vec![output_name.clone()];
735 apply_positional_aliases(&mut columns, column_aliases);
736 if *ordinality {
737 columns.push("ordinality".into());
738 }
739 Ok(opaque_scope(
740 &columns,
741 Some(alias.as_deref().unwrap_or(output_name)),
742 ))
743 }
744 FromClause::FunctionGroup {
745 functions,
746 alias,
747 column_aliases,
748 ordinality,
749 } => {
750 for function in functions.iter_mut() {
751 for expression in &mut function.args {
752 self.bind_expr(expression, outer, context)?;
753 }
754 }
755 let mut columns = functions
756 .iter()
757 .flat_map(|function| {
758 if function.column_aliases.is_empty() {
759 vec![function.output_name.clone()]
760 } else {
761 function.column_aliases.clone()
762 }
763 })
764 .collect::<Vec<_>>();
765 apply_positional_aliases(&mut columns, column_aliases);
766 if *ordinality {
767 columns.push("ordinality".into());
768 }
769 Ok(opaque_scope(&columns, alias.as_deref()))
770 }
771 FromClause::Subquery {
772 body,
773 alias,
774 column_aliases,
775 ..
776 } => {
777 self.bind_select(body, outer, context)?;
778 let mut columns = select_output_names(body);
779 apply_positional_aliases(&mut columns, column_aliases);
780 Ok(opaque_scope(&columns, alias.as_deref()))
781 }
782 }
783 }
784
785 fn bind_projections(
786 &mut self,
787 projections: &mut Vec<Projection>,
788 local: Option<&ColumnScope>,
789 scopes: &[ColumnScope],
790 context: &ColumnBindingContext,
791 ) -> Result<(), SQLError> {
792 let mut bound = Vec::with_capacity(projections.len());
793 for mut projection in projections.drain(..) {
794 let expanded = match &projection.expr {
795 Expr::Star => local.map(|scope| scope.output.as_slice()),
796 Expr::QualifiedStar(qualifier) => {
797 scopes.iter().find_map(|scope| scope.qualified(qualifier))
798 }
799 _ => None,
800 };
801 if let Some(columns) = expanded {
802 for column in columns {
803 self.dependencies
804 .extend(column.dependencies.iter().cloned());
805 bound.push(Projection {
806 expr: column.reference.clone(),
807 alias: Some(column.name.clone()),
808 });
809 }
810 continue;
811 }
812 let implicit_name = match &projection.expr {
813 Expr::Column(name) | Expr::QualifiedColumn { column: name, .. } => {
814 Some(name.to_string())
815 }
816 _ => None,
817 };
818 self.bind_expr(&mut projection.expr, scopes, context)?;
819 if projection.alias.is_none() && self.mode.is_rename() {
820 let current_name = match &projection.expr {
821 Expr::Column(name) | Expr::QualifiedColumn { column: name, .. } => Some(name),
822 _ => None,
823 };
824 if implicit_name
825 .as_ref()
826 .zip(current_name)
827 .is_some_and(|(stored, current)| !same_identifier(stored, current))
828 {
829 projection.alias = implicit_name;
830 }
831 }
832 bound.push(projection);
833 }
834 *projections = bound;
835 Ok(())
836 }
837}