nodedb-sql 0.6.0

SQL parser, planner, and optimizer for NodeDB
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

// SPDX-License-Identifier: Apache-2.0

//! Group-row column qualification.

use crate::types::SqlExpr;

/// `expr` with every column reference stripped of its table qualifier. A
/// finalized group row keys its columns by bare name.
pub(super) fn unqualify_columns(expr: SqlExpr) -> SqlExpr {
    match expr {
        SqlExpr::Column { name, .. } => SqlExpr::Column { table: None, name },
        SqlExpr::Function {
            name,
            args,
            distinct,
        } => SqlExpr::Function {
            name,
            args: args.into_iter().map(unqualify_columns).collect(),
            distinct,
        },
        SqlExpr::BinaryOp { left, op, right } => SqlExpr::BinaryOp {
            left: Box::new(unqualify_columns(*left)),
            op,
            right: Box::new(unqualify_columns(*right)),
        },
        SqlExpr::UnaryOp { op, expr } => SqlExpr::UnaryOp {
            op,
            expr: Box::new(unqualify_columns(*expr)),
        },
        SqlExpr::Cast { expr, to_type } => SqlExpr::Cast {
            expr: Box::new(unqualify_columns(*expr)),
            to_type,
        },
        SqlExpr::IsNull { expr, negated } => SqlExpr::IsNull {
            expr: Box::new(unqualify_columns(*expr)),
            negated,
        },
        SqlExpr::Case {
            operand,
            when_then,
            else_expr,
        } => SqlExpr::Case {
            operand: operand.map(|e| Box::new(unqualify_columns(*e))),
            when_then: when_then
                .into_iter()
                .map(|(when, then)| (unqualify_columns(when), unqualify_columns(then)))
                .collect(),
            else_expr: else_expr.map(|e| Box::new(unqualify_columns(*e))),
        },
        SqlExpr::InList {
            expr,
            list,
            negated,
        } => SqlExpr::InList {
            expr: Box::new(unqualify_columns(*expr)),
            list: list.into_iter().map(unqualify_columns).collect(),
            negated,
        },
        SqlExpr::Between {
            expr,
            low,
            high,
            negated,
        } => SqlExpr::Between {
            expr: Box::new(unqualify_columns(*expr)),
            low: Box::new(unqualify_columns(*low)),
            high: Box::new(unqualify_columns(*high)),
            negated,
        },
        SqlExpr::Like {
            expr,
            pattern,
            negated,
            case_insensitive,
        } => SqlExpr::Like {
            expr: Box::new(unqualify_columns(*expr)),
            pattern: Box::new(unqualify_columns(*pattern)),
            negated,
            case_insensitive,
        },
        SqlExpr::ArrayLiteral(items) => {
            SqlExpr::ArrayLiteral(items.into_iter().map(unqualify_columns).collect())
        }
        SqlExpr::Literal(_) | SqlExpr::Subquery(_) | SqlExpr::Wildcard => expr,
    }
}