1use 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
51pub 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
195pub 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 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}