hamelin_legacy 0.4.2

Legacy AST translation code for Hamelin (to be deprecated)
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

use std::mem::swap;

use hamelin_lib::operator::Operator;
use hamelin_lib::sql::expression::apply::BinaryOperatorApply;
use hamelin_lib::sql::expression::identifier::Identifier;
use hamelin_lib::sql::expression::{OrderByExpression, SQLExpression};
use hamelin_lib::sql::query::projection::{Binding, Projection};
use hamelin_lib::sql::query::SQLQuery;

use crate::env::Environment;

/// Prepend projections onto the front of a query.
///
/// Two things to keep in mind: (1) If these new projections have expressions that make
/// references to columns that are defined in the current list of projections, those are pushed
/// to a subquery. (2) If these new projections simply shadow columns that are defined in
/// the current list of projections, those projections are just removed. The new one wins.
///
/// # Arguments
/// - `query` The query to modify.
/// - `projections` The new set of projections to prepend.
/// - `env` The environment that the query's select should maintain through this transformation.
pub fn prepend_projections(
    query: &SQLQuery,
    mut projections: Vec<Projection>,
    env: &Environment,
) -> SQLQuery {
    let mut ret = query.clone();

    if ret.references_column_in_projections(&projections) {
        ret = ret.push_down();
    }

    let new_names: Vec<Identifier> = projections
        .iter()
        .map(|p| match p {
            Projection::Binding(Binding { name, .. }) => name.clone().into(),
            Projection::ColumnProjection(cp) => cp.identifier.clone(),
        })
        .collect();

    ret = ret.remove_projections(&new_names[..]);
    swap(&mut ret.projections, &mut projections);
    ret.projections.extend(projections.iter().cloned());
    for projection in env.get_column_projections() {
        if ret.projections.iter().all(|p| match p {
            Projection::ColumnProjection(cp) => {
                cp.identifier.last() != projection.identifier.last()
            }
            Projection::Binding(Binding { name, .. }) => {
                let id: Identifier = name.clone().into();
                id != projection.identifier
            }
        }) {
            ret.projections.push(projection.into());
        }
    }

    ret
}

pub fn add_filter_condition(
    query: &SQLQuery,
    condition: SQLExpression,
    env: &Environment,
) -> SQLQuery {
    let mut ret = query.clone();
    if ret.references_columns_in_column_refs(&condition.get_column_references()[..]) {
        ret = ret.push_down().select(
            env.get_column_projections()
                .into_iter()
                .map(|cp| cp.into())
                .collect(),
        );
    }
    let new_where = ret
        .where_
        .map(|current| {
            BinaryOperatorApply::new(
                Operator::And.try_into().unwrap(),
                condition.clone(),
                current.clone(),
            )
            .into()
        })
        .unwrap_or(condition);
    ret.where_ = Some(new_where);
    ret
}

pub fn add_order_expression(
    query: SQLQuery,
    order_by: Vec<OrderByExpression>,
    env: &Environment,
) -> SQLQuery {
    let push_down_needed = order_by
        .iter()
        .map(|e| SQLExpression::from(e.clone()).get_column_references())
        .any(|c| query.references_columns_in_column_refs(&c[..]));
    let ret_query = if push_down_needed {
        query.push_down().select(
            env.get_column_projections()
                .into_iter()
                .map(|cp| Projection::from(cp))
                .collect(),
        )
    } else {
        query.clone()
    };
    ret_query.order_by(order_by)
}

pub fn apply_limit(query: SQLQuery, limit: SQLExpression, env: &Environment) -> SQLQuery {
    if query.limit.is_some() {
        query
            .push_down()
            .select(
                env.get_column_projections()
                    .into_iter()
                    .map(|cp| Projection::from(cp))
                    .collect(),
            )
            .limit(limit)
    } else {
        query.limit(limit)
    }
}