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

use std::collections::HashSet;

use crate::translation::projection_builder::ProjectionBuilder;
use crate::translation::PendingQuery;
use hamelin_lib::antlr::hamelinparser::{
    DropCommandContext, DropCommandContextAttrs, SelectionContextAttrs,
};
use hamelin_lib::err::{TranslationError, TranslationErrors};
use hamelin_lib::sql::expression::identifier::HamelinIdentifier;
use hamelin_lib::sql::expression::identifier::{Identifier, SimpleIdentifier};
use hamelin_lib::sql::expression::literal::ColumnReference;

pub fn translate(
    ctx: &DropCommandContext<'static>,
    previous: &PendingQuery,
) -> Result<PendingQuery, TranslationErrors> {
    let columns_to_drop = ctx
        .selection_all()
        .into_iter()
        .flat_map(|sctx| sctx.identifier())
        .map(|i| HamelinIdentifier::new(i))
        .collect::<Vec<_>>();

    previous.env.check_column_references(&columns_to_drop[..])?;

    let rendered_columns_to_drop = columns_to_drop
        .into_iter()
        .map(|c| c.to_sql().and_then(|c| Ok(ColumnReference::new(c))))
        .collect::<Result<Vec<_>, _>>()?;

    let env = previous
        .env
        .clone()
        .drop(rendered_columns_to_drop.clone())
        .map_err(|e| TranslationError::wrap_box(ctx, e.into()).single())?;

    let simple_columns_to_drop = rendered_columns_to_drop
        .iter()
        .flat_map(|cr| match cr.identifier.clone() {
            Identifier::Simple(s) => Some(s),
            _ => None,
        })
        .collect::<Vec<_>>();

    let complex_columns_to_drop = rendered_columns_to_drop
        .iter()
        .filter(|cr| match cr.identifier {
            Identifier::Simple(_) => false,
            Identifier::Compound(_) => true,
        })
        .collect::<Vec<_>>();

    if !complex_columns_to_drop.is_empty() {
        let modified = complex_columns_to_drop
            .iter()
            .map(|cr| cr.identifier.first())
            .collect::<HashSet<_>>();

        let mut projection_builder = ProjectionBuilder::default();
        for (ident, typ) in env.fields.fields.iter() {
            if modified.contains(ident) {
                projection_builder.initialize_key(
                    ident.clone(),
                    typ.clone()
                        .try_unwrap_struct()
                        .expect("ported a class cast"),
                );
            } else {
                projection_builder.bind_column_reference(ident.clone(), typ.clone());
            }
        }

        Ok(PendingQuery::new(
            previous.query.replace_projections(
                projection_builder
                    .build_projections()
                    .map_err(|e| TranslationError::wrap_box(ctx, e.into()).single())?,
            ),
            env,
        ))
    } else {
        let idents: Vec<SimpleIdentifier> = simple_columns_to_drop
            .into_iter()
            .map(|s| s.into())
            .collect::<Vec<_>>();
        Ok(PendingQuery::new(
            previous.query.remove_simple_projections(&idents[..]),
            env,
        ))
    }
}