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 rows,
676 alias,
677 column_aliases,
678 internal_relation,
679 internal_column_types,
680 internal_column_collations,
681 } => FromClause::Values {
682 rows: rows
683 .iter()
684 .map(|row| bind_exprs(row, resolver, inherited, context))
685 .collect::<Result<Vec<_>, SQLError>>()?,
686 alias: alias.clone(),
687 column_aliases: column_aliases.clone(),
688 internal_relation: *internal_relation,
689 internal_column_types: internal_column_types.clone(),
690 internal_column_collations: internal_column_collations.clone(),
691 },
692 FromClause::Function {
693 name,
694 binding,
695 output_name,
696 relations,
697 args,
698 alias,
699 column_aliases,
700 ordinality,
701 column_types,
702 } => FromClause::Function {
703 name: name.clone(),
704 binding: binding.clone(),
705 output_name: output_name.clone(),
706 relations: relations.clone(),
707 args: bind_exprs(args, resolver, inherited, context)?,
708 alias: alias.clone(),
709 column_aliases: column_aliases.clone(),
710 ordinality: *ordinality,
711 column_types: column_types.clone(),
712 },
713 FromClause::FunctionGroup {
714 functions,
715 alias,
716 column_aliases,
717 ordinality,
718 } => FromClause::FunctionGroup {
719 functions: functions
720 .iter()
721 .map(|function| {
722 Ok(crate::ast::TableFunction {
723 name: function.name.clone(),
724 binding: function.binding.clone(),
725 output_name: function.output_name.clone(),
726 relations: function.relations.clone(),
727 args: bind_exprs(&function.args, resolver, inherited, context)?,
728 column_aliases: function.column_aliases.clone(),
729 column_types: function.column_types.clone(),
730 })
731 })
732 .collect::<Result<Vec<_>, SQLError>>()?,
733 alias: alias.clone(),
734 column_aliases: column_aliases.clone(),
735 ordinality: *ordinality,
736 },
737 FromClause::Subquery {
738 body,
739 alias,
740 column_aliases,
741 } => FromClause::Subquery {
742 body: Box::new(bind_select_with_scope(body, resolver, inherited, context)?),
743 alias: alias.clone(),
744 column_aliases: column_aliases.clone(),
745 },
746 })
747}
748
749fn bind_join_from(
750 from: &FromClause,
751 resolver: &mut dyn VariableResolver,
752 inherited: &RuleBindingScope,
753 context: &RuleBindingContext<'_>,
754) -> Result<FromClause, SQLError> {
755 let FromClause::Join {
756 left,
757 right,
758 kind,
759 on,
760 using,
761 natural,
762 alias,
763 column_aliases,
764 lateral,
765 } = from
766 else {
767 unreachable!("join binder received a non-join source")
768 };
769 let bound_left = bind_from(left, resolver, inherited, context)?;
770 let mut right_scope = inherited.clone();
771 if *lateral {
772 collect_visible_scope(left, context, &mut right_scope)?;
773 }
774 let bound_right = bind_from(right, resolver, &right_scope, context)?;
775 let mut on_scope = inherited.clone();
776 collect_visible_scope(left, context, &mut on_scope)?;
777 collect_visible_scope(right, context, &mut on_scope)?;
778 Ok(FromClause::Join {
779 left: Box::new(bound_left),
780 right: Box::new(bound_right),
781 kind: *kind,
782 on: bind_optional_expr(on.as_ref(), resolver, &on_scope, context)?,
783 using: using.clone(),
784 natural: *natural,
785 alias: alias.clone(),
786 column_aliases: column_aliases.clone(),
787 lateral: *lateral,
788 })
789}
790
791fn bind_ctes(
792 ctes: &[CTE],
793 resolver: &mut dyn VariableResolver,
794 inherited: &RuleBindingScope,
795 context: &RuleBindingContext<'_>,
796) -> Result<Vec<CTE>, SQLError> {
797 let mut visible = context.clone();
798 let mut bound = Vec::with_capacity(ctes.len());
799 for cte in ctes {
800 if cte.recursive {
801 visible
802 .ctes
803 .entry(cte.name.to_ascii_lowercase())
804 .or_default();
805 let mut columns = cte_output_columns(&cte.body, &visible)?;
806 apply_positional_aliases(&mut columns, &cte.columns);
807 visible.ctes.insert(cte.name.to_ascii_lowercase(), columns);
808 }
809 bound.push(CTE {
810 name: cte.name.clone(),
811 columns: cte.columns.clone(),
812 recursive: cte.recursive,
813 materialization: cte.materialization,
814 search: cte.search.clone(),
815 cycle: cte
816 .cycle
817 .as_ref()
818 .map(|cycle| -> Result<crate::ast::CteCycleClause, SQLError> {
819 Ok(crate::ast::CteCycleClause {
820 columns: cycle.columns.clone(),
821 mark_column: cycle.mark_column.clone(),
822 mark_value: bind_rule_expr_with_scope(
823 &cycle.mark_value,
824 resolver,
825 inherited,
826 &visible,
827 )?,
828 mark_default: bind_rule_expr_with_scope(
829 &cycle.mark_default,
830 resolver,
831 inherited,
832 &visible,
833 )?,
834 path_column: cycle.path_column.clone(),
835 })
836 })
837 .transpose()?,
838 body: match &cte.body {
839 crate::ast::CteBody::Query(query) => crate::ast::CteBody::Query(Box::new(
840 bind_select_with_scope(query, resolver, inherited, &visible)?,
841 )),
842 body => body.clone(),
844 },
845 });
846 let mut columns = cte_output_columns(&cte.body, &visible)?;
847 apply_positional_aliases(&mut columns, &cte.columns);
848 if let Some(search) = &cte.search {
849 columns.push(search.sequence_column.clone());
850 }
851 if let Some(cycle) = &cte.cycle {
852 columns.push(cycle.mark_column.clone());
853 columns.push(cycle.path_column.clone());
854 }
855 visible.ctes.insert(cte.name.to_ascii_lowercase(), columns);
856 }
857 Ok(bound)
858}
859
860fn bind_frame_bound(
861 bound: &FrameBound,
862 resolver: &mut dyn VariableResolver,
863 scope: &RuleBindingScope,
864 context: &RuleBindingContext<'_>,
865) -> Result<FrameBound, SQLError> {
866 Ok(match bound {
867 FrameBound::Preceding(expr) => FrameBound::Preceding(Box::new(bind_rule_expr_with_scope(
868 expr, resolver, scope, context,
869 )?)),
870 FrameBound::Following(expr) => FrameBound::Following(Box::new(bind_rule_expr_with_scope(
871 expr, resolver, scope, context,
872 )?)),
873 _ => bound.clone(),
874 })
875}
876
877fn bind_projections(
878 projections: &[Projection],
879 resolver: &mut dyn VariableResolver,
880 scope: &RuleBindingScope,
881 context: &RuleBindingContext<'_>,
882) -> Result<Vec<Projection>, SQLError> {
883 let mut bound = Vec::with_capacity(projections.len());
884 for projection in projections {
885 if let Some(expressions) = expand_qualified_star(&projection.expr, resolver, scope)? {
886 bound.extend(expressions.into_iter().map(|expr| Projection {
887 expr,
888 alias: projection.alias.clone(),
889 }));
890 } else {
891 bound.push(Projection {
892 expr: bind_rule_expr_with_scope(&projection.expr, resolver, scope, context)?,
893 alias: projection.alias.clone(),
894 });
895 }
896 }
897 Ok(bound)
898}
899
900fn bind_expanding_exprs(
901 expressions: &[Expr],
902 resolver: &mut dyn VariableResolver,
903 scope: &RuleBindingScope,
904 context: &RuleBindingContext<'_>,
905) -> Result<Vec<Expr>, SQLError> {
906 let mut bound = Vec::with_capacity(expressions.len());
907 for expression in expressions {
908 if let Some(expressions) = expand_qualified_star(expression, resolver, scope)? {
909 bound.extend(expressions);
910 } else {
911 bound.push(bind_rule_expr_with_scope(
912 expression, resolver, scope, context,
913 )?);
914 }
915 }
916 Ok(bound)
917}
918
919fn expand_qualified_star(
920 expression: &Expr,
921 resolver: &mut dyn VariableResolver,
922 scope: &RuleBindingScope,
923) -> Result<Option<Vec<Expr>>, SQLError> {
924 let Expr::QualifiedStar(qualifier) = expression else {
925 return Ok(None);
926 };
927 if scope.qualifier_is_shadowed(qualifier) {
928 return Ok(None);
929 }
930 resolver.rewrite_qualified_star(qualifier)
931}
932
933fn bind_exprs(
934 expressions: &[Expr],
935 resolver: &mut dyn VariableResolver,
936 scope: &RuleBindingScope,
937 context: &RuleBindingContext<'_>,
938) -> Result<Vec<Expr>, SQLError> {
939 expressions
940 .iter()
941 .map(|expr| bind_rule_expr_with_scope(expr, resolver, scope, context))
942 .collect()
943}
944
945fn bind_optional_expr(
946 expression: Option<&Expr>,
947 resolver: &mut dyn VariableResolver,
948 scope: &RuleBindingScope,
949 context: &RuleBindingContext<'_>,
950) -> Result<Option<Expr>, SQLError> {
951 expression
952 .map(|expr| bind_rule_expr_with_scope(expr, resolver, scope, context))
953 .transpose()
954}
955
956fn bind_orders(
957 orders: &[OrderBy],
958 resolver: &mut dyn VariableResolver,
959 scope: &RuleBindingScope,
960 context: &RuleBindingContext<'_>,
961) -> Result<Vec<OrderBy>, SQLError> {
962 orders
963 .iter()
964 .map(|order| {
965 Ok(OrderBy {
966 expr: bind_rule_expr_with_scope(&order.expr, resolver, scope, context)?,
967 descending: order.descending,
968 nulls: order.nulls,
969 })
970 })
971 .collect()
972}
973
974pub fn invalid_rule_relation_reference(qualifier: &str) -> SQLError {
975 SQLError::Diagnostic {
976 sqlstate: "42P01".into(),
977 message: format!("invalid reference to FROM-clause entry for table \"{qualifier}\""),
978 detail: Some(format!(
979 "There is an entry for table \"{qualifier}\", but it cannot be referenced from this part of the query."
980 )),
981 hint: None,
982 }
983}