Skip to main content

uqa_sql/semantics/rules/
action_binding.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Query-scope-aware binding for rewrite-rule OLD/NEW pseudo-relations.
8
9use std::collections::{BTreeMap, BTreeSet};
10
11use crate::ast::{
12    Expr, FrameBound, FromClause, OrderBy, Projection, RuleEvent, SelectStmt, Statement,
13    UpdateStmt, CTE,
14};
15use crate::plpgsql::{bind_statement, ResolvedVariable, VariableResolver};
16use crate::SQLError;
17
18mod insert;
19use insert::bind_insert;
20mod namespace;
21mod references;
22mod returning;
23mod row_expansion;
24mod scope;
25pub use references::{
26    first_rule_row_reference_in_expr, first_rule_row_reference_in_select,
27    first_rule_row_reference_in_statement, rule_action_has_set_operation,
28    rule_condition_plan_references_whole_row, rule_condition_plan_row_columns,
29    rule_expr_references_row, rule_expr_references_whole_row, rule_expr_row_columns,
30    rule_new_row_columns, rule_statement_references_row, rule_statement_references_whole_row,
31    rule_statement_row_columns,
32};
33pub use returning::expand_rule_action_returning_stars;
34pub use row_expansion::expand_rule_action_row_stars;
35use scope::{
36    apply_positional_aliases, collect_visible_scope, cte_output_columns, RuleBindingScope,
37};
38
39pub fn action_target_qualifier_referenced(
40    catalog: &dyn RuleSourceCatalog,
41    action: &Statement,
42    qualifier: &str,
43) -> bool {
44    namespace::action_target_qualifier_referenced(catalog, action, qualifier)
45}
46
47mod context;
48use context::RuleBindingContext;
49pub use context::{rule_action_target_columns, rule_action_target_row_type, RuleSourceCatalog};
50
51/// Bind an action's event-row OLD/NEW references while preserving the action
52/// row-image aliases visible to its DML RETURNING clause.
53pub fn bind_rule_action(
54    catalog: &dyn RuleSourceCatalog,
55    action: &Statement,
56    action_columns: &BTreeSet<String>,
57    resolver: &mut dyn VariableResolver,
58) -> Result<Statement, SQLError> {
59    let context = RuleBindingContext::with_catalog(catalog, true);
60    let (returning, action_event) = match action {
61        Statement::Insert(statement) => (&statement.returning, RuleEvent::Insert),
62        Statement::Update(statement) => (&statement.returning, RuleEvent::Update),
63        Statement::Delete(statement) => (&statement.returning, RuleEvent::Delete),
64        _ => {
65            return bind_rule_statement_body(
66                action,
67                resolver,
68                &RuleBindingScope::default(),
69                &context,
70            )
71        }
72    };
73    let mut body = action.clone();
74    let aliases = match &mut body {
75        Statement::Insert(statement) => {
76            statement.returning.clear();
77            statement.returning_aliases.clone()
78        }
79        Statement::Update(statement) => {
80            statement.returning.clear();
81            statement.returning_aliases.clone()
82        }
83        Statement::Delete(statement) => {
84            statement.returning.clear();
85            statement.returning_aliases.clone()
86        }
87        _ => unreachable!("DML rule action changed statement kind"),
88    };
89    let mut bound = {
90        let mut body_resolver = RuleActionBodyResolver {
91            action_columns,
92            action_event,
93            event_resolver: resolver,
94        };
95        bind_rule_statement_body(
96            &body,
97            &mut body_resolver,
98            &RuleBindingScope::default(),
99            &context,
100        )?
101    };
102    if returning.is_empty() {
103        return Ok(bound);
104    }
105    let returning = returning::bind_rule_action_returning(
106        returning,
107        action_columns,
108        &aliases,
109        action_event,
110        resolver,
111        &context,
112    )?;
113    match &mut bound {
114        Statement::Insert(statement) => statement.returning = returning,
115        Statement::Update(statement) => statement.returning = returning,
116        Statement::Delete(statement) => statement.returning = returning,
117        _ => unreachable!("bound DML rule action changed statement kind"),
118    }
119    Ok(bound)
120}
121
122struct RuleActionBodyResolver<'a, 'resolver> {
123    action_columns: &'a BTreeSet<String>,
124    action_event: RuleEvent,
125    event_resolver: &'resolver mut dyn VariableResolver,
126}
127
128impl RuleActionBodyResolver<'_, '_> {
129    fn is_action_column(&self, name: &str) -> bool {
130        matches!(self.action_event, RuleEvent::Update | RuleEvent::Delete)
131            && self
132                .action_columns
133                .iter()
134                .any(|column| column.eq_ignore_ascii_case(name))
135    }
136}
137
138impl VariableResolver for RuleActionBodyResolver<'_, '_> {
139    fn resolve_name(&mut self, name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
140        if self.is_action_column(name) {
141            Ok(None)
142        } else {
143            self.event_resolver.resolve_name(name)
144        }
145    }
146
147    fn resolve_qualified(
148        &mut self,
149        qualifier: &str,
150        column: &str,
151    ) -> Result<Option<ResolvedVariable>, SQLError> {
152        self.event_resolver.resolve_qualified(qualifier, column)
153    }
154
155    fn resolve_param(&mut self, index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
156        self.event_resolver.resolve_param(index)
157    }
158
159    fn rewrite_name(&mut self, name: &str) -> Result<Option<Expr>, SQLError> {
160        if self.is_action_column(name) {
161            Ok(None)
162        } else {
163            self.event_resolver.rewrite_name(name)
164        }
165    }
166
167    fn rewrite_qualified(
168        &mut self,
169        qualifier: &str,
170        column: &str,
171    ) -> Result<Option<Expr>, SQLError> {
172        self.event_resolver.rewrite_qualified(qualifier, column)
173    }
174
175    fn rewrite_qualified_star(&mut self, qualifier: &str) -> Result<Option<Vec<Expr>>, SQLError> {
176        self.event_resolver.rewrite_qualified_star(qualifier)
177    }
178
179    fn rewrite_qualified_whole_row(&mut self, qualifier: &str) -> Result<Option<Expr>, SQLError> {
180        self.event_resolver.rewrite_qualified_whole_row(qualifier)
181    }
182
183    fn rewrite_param(&mut self, index: usize) -> Result<Option<Expr>, SQLError> {
184        self.event_resolver.rewrite_param(index)
185    }
186
187    fn rewrite_internal(
188        &mut self,
189        column: crate::ast::InternalColumnRef,
190    ) -> Result<Option<Expr>, SQLError> {
191        self.event_resolver.rewrite_internal(column)
192    }
193}
194
195/// Bind one expression while masking relation qualifiers supplied by the SQL scope around it. Nested query scopes add their own visible aliases.
196pub fn bind_rule_expr_scoped(
197    expr: &Expr,
198    resolver: &mut dyn VariableResolver,
199    shadowed: &BTreeSet<String>,
200) -> Result<Expr, SQLError> {
201    bind_rule_expr_with_scope(
202        expr,
203        resolver,
204        &RuleBindingScope::from_qualifiers(shadowed),
205        &RuleBindingContext::default(),
206    )
207}
208
209fn bind_rule_expr_with_scope(
210    expr: &Expr,
211    resolver: &mut dyn VariableResolver,
212    scope: &RuleBindingScope,
213    context: &RuleBindingContext<'_>,
214) -> Result<Expr, SQLError> {
215    Ok(match expr {
216        Expr::Column(name) => {
217            if scope.qualifier_is_shadowed(name) || scope.column_is_shadowed(name) {
218                expr.clone()
219            } else {
220                resolver.rewrite_name(name)?.unwrap_or_else(|| expr.clone())
221            }
222        }
223        Expr::QualifiedColumn { qualifier, column } => {
224            if scope.qualifier_is_shadowed(qualifier) {
225                expr.clone()
226            } else {
227                resolver
228                    .rewrite_qualified(qualifier, column)?
229                    .unwrap_or_else(|| expr.clone())
230            }
231        }
232        Expr::Param(index) => resolver
233            .rewrite_param(*index)?
234            .unwrap_or_else(|| expr.clone()),
235        Expr::InternalColumn(column) => resolver
236            .rewrite_internal(*column)?
237            .unwrap_or_else(|| expr.clone()),
238        Expr::QualifiedStar(qualifier) => {
239            if scope.qualifier_is_shadowed(qualifier) {
240                expr.clone()
241            } else {
242                resolver
243                    .rewrite_qualified_whole_row(qualifier)?
244                    .unwrap_or_else(|| expr.clone())
245            }
246        }
247        Expr::Default
248        | Expr::Literal(_)
249        | Expr::TypedLiteral { .. }
250        | Expr::RetainedLiteral(_)
251        | Expr::Star => expr.clone(),
252        Expr::Func { .. } => bind_rule_function_expression(expr, resolver, scope, context)?,
253        Expr::Array(items) => Expr::Array(bind_exprs(items, resolver, scope, context)?),
254        Expr::Row(items) => Expr::Row(bind_expanding_exprs(items, resolver, scope, context)?),
255        Expr::CompositeRow { items, binding } => Expr::CompositeRow {
256            items: bind_expanding_exprs(items, resolver, scope, context)?,
257            binding: binding.clone(),
258        },
259        Expr::Binary { op, lhs, rhs } => Expr::Binary {
260            op: *op,
261            lhs: Box::new(bind_rule_expr_with_scope(lhs, resolver, scope, context)?),
262            rhs: Box::new(bind_rule_expr_with_scope(rhs, resolver, scope, context)?),
263        },
264        Expr::UnaryMinus(inner) => Expr::UnaryMinus(Box::new(bind_rule_expr_with_scope(
265            inner, resolver, scope, context,
266        )?)),
267        Expr::Not(inner) => Expr::Not(Box::new(bind_rule_expr_with_scope(
268            inner, resolver, scope, context,
269        )?)),
270        Expr::And(items) => Expr::And(bind_exprs(items, resolver, scope, context)?),
271        Expr::Or(items) => Expr::Or(bind_exprs(items, resolver, scope, context)?),
272        Expr::IsNull { expr, negated } => Expr::IsNull {
273            expr: Box::new(bind_rule_expr_with_scope(expr, resolver, scope, context)?),
274            negated: *negated,
275        },
276        Expr::Between { expr, low, high } => Expr::Between {
277            expr: Box::new(bind_rule_expr_with_scope(expr, resolver, scope, context)?),
278            low: Box::new(bind_rule_expr_with_scope(low, resolver, scope, context)?),
279            high: Box::new(bind_rule_expr_with_scope(high, resolver, scope, context)?),
280        },
281        Expr::InList {
282            expr,
283            list,
284            negated,
285        } => Expr::InList {
286            expr: Box::new(bind_rule_expr_with_scope(expr, resolver, scope, context)?),
287            list: bind_exprs(list, resolver, scope, context)?,
288            negated: *negated,
289        },
290        Expr::WindowCall { .. } => bind_rule_window_expression(expr, resolver, scope, context)?,
291        Expr::Case { .. } => bind_rule_case_expression(expr, resolver, scope, context)?,
292        Expr::Cast { expr, ty, implicit } => Expr::Cast {
293            implicit: *implicit,
294            expr: Box::new(bind_rule_expr_with_scope(expr, resolver, scope, context)?),
295            ty: ty.clone(),
296        },
297        Expr::ScalarSubquery(body) => Expr::ScalarSubquery(Box::new(bind_select_with_scope(
298            body, resolver, scope, context,
299        )?)),
300        Expr::Exists { body, negated } => Expr::Exists {
301            body: Box::new(bind_select_with_scope(body, resolver, scope, context)?),
302            negated: *negated,
303        },
304        Expr::InSubquery {
305            expr,
306            body,
307            negated,
308        } => Expr::InSubquery {
309            expr: Box::new(bind_rule_expr_with_scope(expr, resolver, scope, context)?),
310            body: Box::new(bind_select_with_scope(body, resolver, scope, context)?),
311            negated: *negated,
312        },
313    })
314}
315
316fn bind_rule_function_expression(
317    expr: &Expr,
318    resolver: &mut dyn VariableResolver,
319    scope: &RuleBindingScope,
320    context: &RuleBindingContext<'_>,
321) -> Result<Expr, SQLError> {
322    if let Some((qualifier, column)) = namespace::event_field_reference(expr, scope) {
323        return Ok(resolver
324            .rewrite_qualified(qualifier, column)?
325            .unwrap_or_else(|| Expr::qualified_column(qualifier, column)));
326    }
327    let Expr::Func {
328        order_syntax,
329        name,
330        binding,
331        args,
332        distinct,
333        order_by,
334        filter,
335    } = expr
336    else {
337        unreachable!("function binder received a non-function expression")
338    };
339    Ok(Expr::Func {
340        order_syntax: *order_syntax,
341        name: name.clone(),
342        binding: binding.clone(),
343        args: bind_exprs(args, resolver, scope, context)?,
344        distinct: *distinct,
345        order_by: bind_orders(order_by, resolver, scope, context)?,
346        filter: filter
347            .as_deref()
348            .map(|expr| bind_rule_expr_with_scope(expr, resolver, scope, context).map(Box::new))
349            .transpose()?,
350    })
351}
352
353fn bind_window_spec(
354    spec: &crate::ast::WindowSpec,
355    resolver: &mut dyn VariableResolver,
356    scope: &RuleBindingScope,
357    context: &RuleBindingContext<'_>,
358) -> Result<crate::ast::WindowSpec, SQLError> {
359    Ok(crate::ast::WindowSpec {
360        definition: spec.definition,
361        raw_definition: None,
362        reference: spec.reference.clone(),
363        partition_by: bind_exprs(&spec.partition_by, resolver, scope, context)?,
364        order_by: bind_orders(&spec.order_by, resolver, scope, context)?,
365        frame: spec
366            .frame
367            .as_ref()
368            .map(|frame| -> Result<crate::ast::WindowFrame, SQLError> {
369                Ok(crate::ast::WindowFrame {
370                    mode: frame.mode,
371                    start: bind_frame_bound(&frame.start, resolver, scope, context)?,
372                    end: bind_frame_bound(&frame.end, resolver, scope, context)?,
373                    between: frame.between,
374                    exclusion: frame.exclusion,
375                })
376            })
377            .transpose()?,
378    })
379}
380
381fn bind_rule_window_expression(
382    expr: &Expr,
383    resolver: &mut dyn VariableResolver,
384    scope: &RuleBindingScope,
385    context: &RuleBindingContext<'_>,
386) -> Result<Expr, SQLError> {
387    let Expr::WindowCall {
388        name,
389        args,
390        spec,
391        filter,
392        modifiers,
393    } = expr
394    else {
395        unreachable!("window binder received a non-window expression")
396    };
397    Ok(Expr::WindowCall {
398        modifiers: *modifiers,
399        name: name.clone(),
400        args: bind_exprs(args, resolver, scope, context)?,
401        filter: filter
402            .as_deref()
403            .map(|filter| bind_rule_expr_with_scope(filter, resolver, scope, context).map(Box::new))
404            .transpose()?,
405        spec: Box::new(bind_window_spec(spec, resolver, scope, context)?),
406    })
407}
408
409fn bind_rule_case_expression(
410    expr: &Expr,
411    resolver: &mut dyn VariableResolver,
412    scope: &RuleBindingScope,
413    context: &RuleBindingContext<'_>,
414) -> Result<Expr, SQLError> {
415    let Expr::Case {
416        base,
417        when,
418        else_branch,
419    } = expr
420    else {
421        unreachable!("CASE binder received a non-CASE expression")
422    };
423    Ok(Expr::Case {
424        base: base
425            .as_deref()
426            .map(|expr| bind_rule_expr_with_scope(expr, resolver, scope, context).map(Box::new))
427            .transpose()?,
428        when: when
429            .iter()
430            .map(|(condition, result)| {
431                Ok((
432                    bind_rule_expr_with_scope(condition, resolver, scope, context)?,
433                    bind_rule_expr_with_scope(result, resolver, scope, context)?,
434                ))
435            })
436            .collect::<Result<Vec<_>, SQLError>>()?,
437        else_branch: else_branch
438            .as_deref()
439            .map(|expr| bind_rule_expr_with_scope(expr, resolver, scope, context).map(Box::new))
440            .transpose()?,
441    })
442}
443
444fn bind_rule_select_scoped(
445    catalog: &dyn RuleSourceCatalog,
446    select: &SelectStmt,
447    resolver: &mut dyn VariableResolver,
448) -> Result<SelectStmt, SQLError> {
449    bind_select_with_scope(
450        select,
451        resolver,
452        &RuleBindingScope::default(),
453        &RuleBindingContext::with_catalog(catalog, false),
454    )
455}
456
457fn bind_rule_statement_body(
458    statement: &Statement,
459    resolver: &mut dyn VariableResolver,
460    inherited: &RuleBindingScope,
461    context: &RuleBindingContext<'_>,
462) -> Result<Statement, SQLError> {
463    Ok(match statement {
464        Statement::Select(select) => Statement::Select(Box::new(bind_select_with_scope(
465            select, resolver, inherited, context,
466        )?)),
467        Statement::Insert(insert) => {
468            Statement::Insert(bind_insert(insert, resolver, inherited, context)?)
469        }
470        Statement::Update(update) => {
471            Statement::Update(bind_update(update, resolver, inherited, context)?)
472        }
473        Statement::Delete(delete) => {
474            let mut output = delete.clone();
475            output.with = bind_ctes(&delete.with, resolver, inherited, context)?;
476            let context = context.with_ctes(&delete.with)?;
477            let mut target_scope = inherited.clone();
478            target_scope.insert_qualifier(&delete.target_qualifier);
479            output.using = delete
480                .using
481                .as_ref()
482                .map(|source| bind_from(source, resolver, &target_scope, &context))
483                .transpose()?;
484            let mut expression_scope = target_scope;
485            if let Some(source) = &delete.using {
486                collect_visible_scope(source, &context, &mut expression_scope)?;
487            }
488            output.r#where = bind_optional_expr(
489                delete.r#where.as_ref(),
490                resolver,
491                &expression_scope,
492                &context,
493            )?;
494            output.returning.clear();
495            Statement::Delete(output)
496        }
497        _ => return bind_statement(statement, resolver),
498    })
499}
500
501fn bind_assignment_targets(
502    targets: &crate::ast::AssignmentTargets,
503    resolver: &mut dyn VariableResolver,
504    scope: &RuleBindingScope,
505    context: &RuleBindingContext<'_>,
506) -> Result<crate::ast::AssignmentTargets, SQLError> {
507    let mut targets = targets.clone();
508    for expression in targets.expressions_mut() {
509        *expression = bind_rule_expr_with_scope(expression, resolver, scope, context)?;
510    }
511    Ok(targets)
512}
513
514fn bind_assignment_target(
515    target: &crate::ast::AssignmentTarget,
516    resolver: &mut dyn VariableResolver,
517    scope: &RuleBindingScope,
518    context: &RuleBindingContext<'_>,
519) -> Result<crate::ast::AssignmentTarget, SQLError> {
520    let mut target = target.clone();
521    for expression in target.expressions_mut() {
522        *expression = bind_rule_expr_with_scope(expression, resolver, scope, context)?;
523    }
524    Ok(target)
525}
526
527fn bind_update(
528    update: &UpdateStmt,
529    resolver: &mut dyn VariableResolver,
530    inherited: &RuleBindingScope,
531    context: &RuleBindingContext<'_>,
532) -> Result<UpdateStmt, SQLError> {
533    let mut output = update.clone();
534    output.with = bind_ctes(&update.with, resolver, inherited, context)?;
535    let context = context.with_ctes(&update.with)?;
536    let mut target_scope = inherited.clone();
537    target_scope.insert_qualifier(&update.target_qualifier);
538    output.from = update
539        .from
540        .as_ref()
541        .map(|source| bind_from(source, resolver, &target_scope, &context))
542        .transpose()?;
543    let mut expression_scope = target_scope;
544    if let Some(source) = &update.from {
545        collect_visible_scope(source, &context, &mut expression_scope)?;
546    }
547    output.assignments = update
548        .assignments
549        .iter()
550        .map(|(column, expr)| {
551            Ok((
552                bind_assignment_targets(column, resolver, &expression_scope, &context)?,
553                bind_rule_expr_with_scope(expr, resolver, &expression_scope, &context)?,
554            ))
555        })
556        .collect::<Result<Vec<_>, SQLError>>()?;
557    output.r#where = bind_optional_expr(
558        update.r#where.as_ref(),
559        resolver,
560        &expression_scope,
561        &context,
562    )?;
563    output.returning.clear();
564    Ok(output)
565}
566
567fn bind_select_with_scope(
568    select: &SelectStmt,
569    resolver: &mut dyn VariableResolver,
570    inherited: &RuleBindingScope,
571    context: &RuleBindingContext<'_>,
572) -> Result<SelectStmt, SQLError> {
573    let local_context = context.with_ctes(&select.with)?;
574    let mut scope = inherited.clone();
575    if let Some(source) = &select.from {
576        collect_visible_scope(source, &local_context, &mut scope)?;
577    }
578    Ok(SelectStmt {
579        windows: select
580            .windows
581            .iter()
582            .map(|window| {
583                Ok(crate::ast::WindowDefinition {
584                    name: window.name.clone(),
585                    inherited: window.inherited,
586                    spec: bind_window_spec(&window.spec, resolver, &scope, &local_context)?,
587                })
588            })
589            .collect::<Result<Vec<_>, SQLError>>()?,
590        projections: bind_projections(&select.projections, resolver, &scope, &local_context)?,
591        values: select
592            .values
593            .iter()
594            .map(|row| bind_expanding_exprs(row, resolver, &scope, &local_context))
595            .collect::<Result<Vec<_>, SQLError>>()?,
596        from: select
597            .from
598            .as_ref()
599            .map(|source| bind_from(source, resolver, inherited, &local_context))
600            .transpose()?,
601        r#where: bind_optional_expr(select.r#where.as_ref(), resolver, &scope, &local_context)?,
602        group_by: bind_exprs(&select.group_by, resolver, &scope, &local_context)?,
603        grouping_sets: select
604            .grouping_sets
605            .iter()
606            .map(|set| bind_exprs(set, resolver, &scope, &local_context))
607            .collect::<Result<Vec<_>, SQLError>>()?,
608        group_distinct: select.group_distinct,
609        having: bind_optional_expr(select.having.as_ref(), resolver, &scope, &local_context)?,
610        order_by: bind_orders(&select.order_by, resolver, &scope, &local_context)?,
611        limit: bind_optional_expr(select.limit.as_ref(), resolver, &scope, &local_context)?,
612        with_ties: select.with_ties,
613        offset: bind_optional_expr(select.offset.as_ref(), resolver, &scope, &local_context)?,
614        with: bind_ctes(&select.with, resolver, inherited, context)?,
615        set_op: select
616            .set_op
617            .as_ref()
618            .map(|operation| -> Result<Box<crate::ast::SetOp>, SQLError> {
619                Ok(Box::new(crate::ast::SetOp {
620                    kind: operation.kind,
621                    all: operation.all,
622                    left: operation
623                        .left
624                        .as_deref()
625                        .map(|left| {
626                            bind_select_with_scope(left, resolver, inherited, &local_context)
627                                .map(Box::new)
628                        })
629                        .transpose()?,
630                    right: bind_select_with_scope(
631                        &operation.right,
632                        resolver,
633                        inherited,
634                        &local_context,
635                    )?,
636                    combined_order_by: bind_orders(
637                        &operation.combined_order_by,
638                        resolver,
639                        inherited,
640                        &local_context,
641                    )?,
642                    combined_limit: bind_optional_expr(
643                        operation.combined_limit.as_ref(),
644                        resolver,
645                        inherited,
646                        &local_context,
647                    )?,
648                    combined_with_ties: operation.combined_with_ties,
649                    combined_offset: bind_optional_expr(
650                        operation.combined_offset.as_ref(),
651                        resolver,
652                        inherited,
653                        &local_context,
654                    )?,
655                }))
656            })
657            .transpose()?,
658        distinct: select.distinct,
659        distinct_on: bind_exprs(&select.distinct_on, resolver, &scope, &local_context)?,
660        locking: select.locking.clone(),
661    })
662}
663
664fn bind_from(
665    from: &FromClause,
666    resolver: &mut dyn VariableResolver,
667    inherited: &RuleBindingScope,
668    context: &RuleBindingContext<'_>,
669) -> Result<FromClause, SQLError> {
670    Ok(match from {
671        crate::ast::FromClause::RetainedRows(_) => from.clone(),
672        FromClause::Table { .. } => from.clone(),
673        FromClause::Join { .. } => bind_join_from(from, resolver, inherited, context)?,
674        FromClause::Values {
675            lateral,
676            rows,
677            alias,
678            column_aliases,
679            internal_relation,
680            internal_column_types,
681            internal_column_collations,
682        } => FromClause::Values {
683            lateral: *lateral,
684            rows: rows
685                .iter()
686                .map(|row| bind_exprs(row, resolver, inherited, context))
687                .collect::<Result<Vec<_>, SQLError>>()?,
688            alias: alias.clone(),
689            column_aliases: column_aliases.clone(),
690            internal_relation: *internal_relation,
691            internal_column_types: internal_column_types.clone(),
692            internal_column_collations: internal_column_collations.clone(),
693        },
694        FromClause::Function {
695            name,
696            binding,
697            output_name,
698            relations,
699            args,
700            alias,
701            column_aliases,
702            ordinality,
703            column_types,
704        } => FromClause::Function {
705            name: name.clone(),
706            binding: binding.clone(),
707            output_name: output_name.clone(),
708            relations: relations.clone(),
709            args: bind_exprs(args, resolver, inherited, context)?,
710            alias: alias.clone(),
711            column_aliases: column_aliases.clone(),
712            ordinality: *ordinality,
713            column_types: column_types.clone(),
714        },
715        FromClause::FunctionGroup {
716            functions,
717            alias,
718            column_aliases,
719            ordinality,
720        } => FromClause::FunctionGroup {
721            functions: functions
722                .iter()
723                .map(|function| {
724                    Ok(crate::ast::TableFunction {
725                        name: function.name.clone(),
726                        binding: function.binding.clone(),
727                        output_name: function.output_name.clone(),
728                        relations: function.relations.clone(),
729                        args: bind_exprs(&function.args, resolver, inherited, context)?,
730                        column_aliases: function.column_aliases.clone(),
731                        column_types: function.column_types.clone(),
732                    })
733                })
734                .collect::<Result<Vec<_>, SQLError>>()?,
735            alias: alias.clone(),
736            column_aliases: column_aliases.clone(),
737            ordinality: *ordinality,
738        },
739        FromClause::Subquery {
740            lateral,
741            body,
742            alias,
743            column_aliases,
744        } => FromClause::Subquery {
745            lateral: *lateral,
746            body: Box::new(bind_select_with_scope(body, resolver, inherited, context)?),
747            alias: alias.clone(),
748            column_aliases: column_aliases.clone(),
749        },
750    })
751}
752
753fn bind_join_from(
754    from: &FromClause,
755    resolver: &mut dyn VariableResolver,
756    inherited: &RuleBindingScope,
757    context: &RuleBindingContext<'_>,
758) -> Result<FromClause, SQLError> {
759    let FromClause::Join {
760        comma,
761        left,
762        right,
763        kind,
764        on,
765        using,
766        natural,
767        alias,
768        column_aliases,
769        lateral,
770    } = from
771    else {
772        unreachable!("join binder received a non-join source")
773    };
774    let bound_left = bind_from(left, resolver, inherited, context)?;
775    let mut right_scope = inherited.clone();
776    if *lateral {
777        collect_visible_scope(left, context, &mut right_scope)?;
778    }
779    let bound_right = bind_from(right, resolver, &right_scope, context)?;
780    let mut on_scope = inherited.clone();
781    collect_visible_scope(left, context, &mut on_scope)?;
782    collect_visible_scope(right, context, &mut on_scope)?;
783    Ok(FromClause::Join {
784        comma: *comma,
785        left: Box::new(bound_left),
786        right: Box::new(bound_right),
787        kind: *kind,
788        on: bind_optional_expr(on.as_ref(), resolver, &on_scope, context)?,
789        using: using.clone(),
790        natural: *natural,
791        alias: alias.clone(),
792        column_aliases: column_aliases.clone(),
793        lateral: *lateral,
794    })
795}
796
797fn bind_ctes(
798    ctes: &[CTE],
799    resolver: &mut dyn VariableResolver,
800    inherited: &RuleBindingScope,
801    context: &RuleBindingContext<'_>,
802) -> Result<Vec<CTE>, SQLError> {
803    let mut visible = context.clone();
804    let mut bound = Vec::with_capacity(ctes.len());
805    for cte in ctes {
806        if cte.recursive {
807            visible
808                .ctes
809                .entry(cte.name.to_ascii_lowercase())
810                .or_default();
811            let mut columns = cte_output_columns(&cte.body, &visible)?;
812            apply_positional_aliases(&mut columns, &cte.columns);
813            visible.ctes.insert(cte.name.to_ascii_lowercase(), columns);
814        }
815        bound.push(CTE {
816            name: cte.name.clone(),
817            columns: cte.columns.clone(),
818            recursive: cte.recursive,
819            materialization: cte.materialization,
820            search: cte.search.clone(),
821            cycle: cte
822                .cycle
823                .as_ref()
824                .map(|cycle| -> Result<crate::ast::CteCycleClause, SQLError> {
825                    Ok(crate::ast::CteCycleClause {
826                        columns: cycle.columns.clone(),
827                        mark_column: cycle.mark_column.clone(),
828                        mark_value: bind_rule_expr_with_scope(
829                            &cycle.mark_value,
830                            resolver,
831                            inherited,
832                            &visible,
833                        )?,
834                        mark_default: bind_rule_expr_with_scope(
835                            &cycle.mark_default,
836                            resolver,
837                            inherited,
838                            &visible,
839                        )?,
840                        path_column: cycle.path_column.clone(),
841                    })
842                })
843                .transpose()?,
844            body: match &cte.body {
845                crate::ast::CteBody::Query(query) => crate::ast::CteBody::Query(Box::new(
846                    bind_select_with_scope(query, resolver, inherited, &visible)?,
847                )),
848                // Command CTEs cannot reference a rule's event row. Their own DML row-image aliases belong to RETURNING and must retain their local identities.
849                body => body.clone(),
850            },
851        });
852        let mut columns = cte_output_columns(&cte.body, &visible)?;
853        apply_positional_aliases(&mut columns, &cte.columns);
854        if let Some(search) = &cte.search {
855            columns.push(search.sequence_column.clone());
856        }
857        if let Some(cycle) = &cte.cycle {
858            columns.push(cycle.mark_column.clone());
859            columns.push(cycle.path_column.clone());
860        }
861        visible.ctes.insert(cte.name.to_ascii_lowercase(), columns);
862    }
863    Ok(bound)
864}
865
866fn bind_frame_bound(
867    bound: &FrameBound,
868    resolver: &mut dyn VariableResolver,
869    scope: &RuleBindingScope,
870    context: &RuleBindingContext<'_>,
871) -> Result<FrameBound, SQLError> {
872    Ok(match bound {
873        FrameBound::Preceding(expr) => FrameBound::Preceding(Box::new(bind_rule_expr_with_scope(
874            expr, resolver, scope, context,
875        )?)),
876        FrameBound::Following(expr) => FrameBound::Following(Box::new(bind_rule_expr_with_scope(
877            expr, resolver, scope, context,
878        )?)),
879        _ => bound.clone(),
880    })
881}
882
883fn bind_projections(
884    projections: &[Projection],
885    resolver: &mut dyn VariableResolver,
886    scope: &RuleBindingScope,
887    context: &RuleBindingContext<'_>,
888) -> Result<Vec<Projection>, SQLError> {
889    let mut bound = Vec::with_capacity(projections.len());
890    for projection in projections {
891        if let Some(expressions) = expand_qualified_star(&projection.expr, resolver, scope)? {
892            bound.extend(expressions.into_iter().map(|expr| Projection {
893                expr,
894                alias: projection.alias.clone(),
895            }));
896        } else {
897            bound.push(Projection {
898                expr: bind_rule_expr_with_scope(&projection.expr, resolver, scope, context)?,
899                alias: projection.alias.clone(),
900            });
901        }
902    }
903    Ok(bound)
904}
905
906fn bind_expanding_exprs(
907    expressions: &[Expr],
908    resolver: &mut dyn VariableResolver,
909    scope: &RuleBindingScope,
910    context: &RuleBindingContext<'_>,
911) -> Result<Vec<Expr>, SQLError> {
912    let mut bound = Vec::with_capacity(expressions.len());
913    for expression in expressions {
914        if let Some(expressions) = expand_qualified_star(expression, resolver, scope)? {
915            bound.extend(expressions);
916        } else {
917            bound.push(bind_rule_expr_with_scope(
918                expression, resolver, scope, context,
919            )?);
920        }
921    }
922    Ok(bound)
923}
924
925fn expand_qualified_star(
926    expression: &Expr,
927    resolver: &mut dyn VariableResolver,
928    scope: &RuleBindingScope,
929) -> Result<Option<Vec<Expr>>, SQLError> {
930    let Expr::QualifiedStar(qualifier) = expression else {
931        return Ok(None);
932    };
933    if scope.qualifier_is_shadowed(qualifier) {
934        return Ok(None);
935    }
936    resolver.rewrite_qualified_star(qualifier)
937}
938
939fn bind_exprs(
940    expressions: &[Expr],
941    resolver: &mut dyn VariableResolver,
942    scope: &RuleBindingScope,
943    context: &RuleBindingContext<'_>,
944) -> Result<Vec<Expr>, SQLError> {
945    expressions
946        .iter()
947        .map(|expr| bind_rule_expr_with_scope(expr, resolver, scope, context))
948        .collect()
949}
950
951fn bind_optional_expr(
952    expression: Option<&Expr>,
953    resolver: &mut dyn VariableResolver,
954    scope: &RuleBindingScope,
955    context: &RuleBindingContext<'_>,
956) -> Result<Option<Expr>, SQLError> {
957    expression
958        .map(|expr| bind_rule_expr_with_scope(expr, resolver, scope, context))
959        .transpose()
960}
961
962fn bind_orders(
963    orders: &[OrderBy],
964    resolver: &mut dyn VariableResolver,
965    scope: &RuleBindingScope,
966    context: &RuleBindingContext<'_>,
967) -> Result<Vec<OrderBy>, SQLError> {
968    orders
969        .iter()
970        .map(|order| {
971            Ok(OrderBy {
972                expr: bind_rule_expr_with_scope(&order.expr, resolver, scope, context)?,
973                descending: order.descending,
974                nulls: order.nulls,
975            })
976        })
977        .collect()
978}
979
980pub fn invalid_rule_relation_reference(qualifier: &str) -> SQLError {
981    SQLError::Diagnostic {
982        sqlstate: "42P01".into(),
983        message: format!("invalid reference to FROM-clause entry for table \"{qualifier}\""),
984        detail: Some(format!(
985            "There is an entry for table \"{qualifier}\", but it cannot be referenced from this part of the query."
986        )),
987        hint: None,
988    }
989}