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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

// SPDX-License-Identifier: Apache-2.0

//! Catalog folding for reusable projection, ordering, aggregate, and window shapes.

use nodedb_types::DatabaseId;

use crate::catalog::SqlCatalog;
use crate::types::{AggregateExpr, Projection, SortKey, SqlExpr, WindowSpec};

use super::catalog_expr_fold::{fold_expr, validate_expr};

pub(super) fn validate_projection(
    projection: &[Projection],
    catalog: &dyn SqlCatalog,
    database_id: DatabaseId,
    tenant_id: u64,
) -> crate::Result<()> {
    for item in projection {
        match item {
            Projection::Computed { expr, .. } | Projection::CpComputed { expr, .. } => {
                validate_expr(expr, catalog, database_id, tenant_id)?;
            }
            Projection::Column(_) | Projection::Star | Projection::QualifiedStar(_) => {}
        }
    }
    Ok(())
}

pub(super) fn validate_sort_keys(
    sort_keys: &[SortKey],
    catalog: &dyn SqlCatalog,
    database_id: DatabaseId,
    tenant_id: u64,
) -> crate::Result<()> {
    for key in sort_keys {
        validate_expr(&key.expr, catalog, database_id, tenant_id)?;
    }
    Ok(())
}

pub(super) fn validate_aggregates(
    aggregates: &[AggregateExpr],
    catalog: &dyn SqlCatalog,
    database_id: DatabaseId,
    tenant_id: u64,
) -> crate::Result<()> {
    for aggregate in aggregates {
        for arg in &aggregate.args {
            validate_expr(arg, catalog, database_id, tenant_id)?;
        }
    }
    Ok(())
}

pub(super) fn validate_windows(
    windows: &[WindowSpec],
    catalog: &dyn SqlCatalog,
    database_id: DatabaseId,
    tenant_id: u64,
) -> crate::Result<()> {
    for window in windows {
        for expr in window.args.iter().chain(&window.partition_by) {
            validate_expr(expr, catalog, database_id, tenant_id)?;
        }
        validate_sort_keys(&window.order_by, catalog, database_id, tenant_id)?;
    }
    Ok(())
}

pub(super) fn fold_projection(
    projection: &mut [Projection],
    catalog: &dyn SqlCatalog,
    database_id: DatabaseId,
    tenant_id: u64,
) {
    // The fold resolves catalog casts (`regclass`, `regtype`) only; a
    // sequence accessor in a Control-Plane-computed item stays a call.
    for item in projection {
        match item {
            Projection::Computed { expr, .. } | Projection::CpComputed { expr, .. } => {
                let owned = std::mem::replace(expr, SqlExpr::Wildcard);
                *expr = fold_expr(owned, catalog, database_id, tenant_id);
            }
            Projection::Column(_) | Projection::Star | Projection::QualifiedStar(_) => {}
        }
    }
}

pub(super) fn fold_sort_keys(
    sort_keys: &mut [SortKey],
    catalog: &dyn SqlCatalog,
    database_id: DatabaseId,
    tenant_id: u64,
) {
    for key in sort_keys {
        let owned = std::mem::replace(&mut key.expr, SqlExpr::Wildcard);
        key.expr = fold_expr(owned, catalog, database_id, tenant_id);
    }
}

pub(super) fn fold_aggregates(
    aggregates: &mut [AggregateExpr],
    catalog: &dyn SqlCatalog,
    database_id: DatabaseId,
    tenant_id: u64,
) {
    for aggregate in aggregates {
        for arg in &mut aggregate.args {
            let owned = std::mem::replace(arg, SqlExpr::Wildcard);
            *arg = fold_expr(owned, catalog, database_id, tenant_id);
        }
    }
}

pub(super) fn fold_windows(
    windows: &mut [WindowSpec],
    catalog: &dyn SqlCatalog,
    database_id: DatabaseId,
    tenant_id: u64,
) {
    for window in windows {
        for expr in window.args.iter_mut().chain(&mut window.partition_by) {
            let owned = std::mem::replace(expr, SqlExpr::Wildcard);
            *expr = fold_expr(owned, catalog, database_id, tenant_id);
        }
        fold_sort_keys(&mut window.order_by, catalog, database_id, tenant_id);
    }
}