Skip to main content

uqa_sql/binding/
stored_columns.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Stored statement column identities, durable source shapes, and rewrite-rule binding.
8
9mod 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
26/// Current names of a bound row relation, resolved when a binding pass needs them.
27pub trait StoredColumnCatalog {
28    fn stored_relation_column_names(&self, name: &str) -> Result<Option<Vec<String>>, SQLError>;
29}
30
31/// Catalog and namespace snapshots captured before resolving stored source columns.
32pub 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 present in the stored definition before this binding pass.
138    name: String,
139    /// Name present in the live catalog after this binding pass.
140    current_name: String,
141    /// Reference that identifies this output in the enclosing query scope.
142    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    /// Column references, by qualifier and name, that no enclosing scope provides.
190    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, &current_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}