uqa-sql 0.3.0

PostgreSQL-compatible SQL compiler built on libpg_query
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! MERGE expressions resolve against their candidate row's relation namespace.

use super::{RowSchema, SchemaScope};
use crate::plan::{MergePlan, MergeWhenPlan};
use crate::routines::RoutineResolution;
use crate::{SQLError, SQLParam};

impl SchemaScope {
    pub(super) fn bind_merge_expressions(
        &mut self,
        routines: &dyn RoutineResolution,
        merge: &MergePlan,
        params: &[SQLParam],
        target: &RowSchema,
        joined: &RowSchema,
    ) -> Result<(), SQLError> {
        let qualifier = merge
            .target_alias
            .as_deref()
            .unwrap_or(&merge.target_qualifier);
        let target = RowSchema::with_qualified_types(
            qualifier,
            target.columns().to_vec(),
            target.column_types().to_vec(),
        );
        let source = self.bind_source(routines, &merge.source, &merge.subqueries, params, None)?;
        self.bind_expression_type(
            routines,
            &merge.join_condition,
            joined,
            &merge.subqueries,
            params,
            None,
        )?;
        if let Some(predicate) = &merge.target_predicate {
            self.bind_expression_type(
                routines,
                predicate,
                joined,
                &merge.subqueries,
                params,
                None,
            )?;
        }
        for clause in &merge.when_clauses {
            let input = match clause {
                MergeWhenPlan::UpdateNotMatchedBySource { .. }
                | MergeWhenPlan::DeleteNotMatchedBySource { .. }
                | MergeWhenPlan::NothingNotMatchedBySource { .. } => &target,
                MergeWhenPlan::InsertNotMatched { .. }
                | MergeWhenPlan::NothingNotMatched { .. } => &source,
                _ => joined,
            };
            let (condition, values) = match clause {
                MergeWhenPlan::UpdateMatched {
                    condition,
                    assignments,
                }
                | MergeWhenPlan::UpdateNotMatchedBySource {
                    condition,
                    assignments,
                } => (
                    condition,
                    assignments
                        .iter()
                        .map(|assignment| &assignment.value)
                        .collect::<Vec<_>>(),
                ),
                MergeWhenPlan::InsertNotMatched {
                    condition, values, ..
                } => (condition, values.iter().collect()),
                MergeWhenPlan::DeleteMatched { condition }
                | MergeWhenPlan::DeleteNotMatchedBySource { condition }
                | MergeWhenPlan::NothingMatched { condition }
                | MergeWhenPlan::NothingNotMatched { condition }
                | MergeWhenPlan::NothingNotMatchedBySource { condition } => (condition, Vec::new()),
            };
            for expression in condition.iter().chain(values) {
                self.bind_expression_type(
                    routines,
                    expression,
                    input,
                    &merge.subqueries,
                    params,
                    None,
                )?;
            }
        }
        Ok(())
    }
}