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

use std::rc::Rc;

use hamelin_lib::err::TranslationErrors;
use hamelin_lib::types::Type;
use hamelin_lib::{
    antlr::hamelinparser::{SortExpressionContextAll, SortExpressionContextAttrs},
    sql::expression::{Direction, OrderByExpression},
};

use crate::ast::expression::HamelinExpression;
use crate::ast::ExpressionTranslationContext;

#[derive(Clone)]
pub struct HamelinSortExpression {
    ctx: Vec<Rc<SortExpressionContextAll<'static>>>,
    context: Rc<ExpressionTranslationContext>,
}

impl HamelinSortExpression {
    pub fn new(
        ctx: Vec<Rc<SortExpressionContextAll<'static>>>,
        context: Rc<ExpressionTranslationContext>,
    ) -> Self {
        Self { ctx, context }
    }

    pub fn translate(&self) -> Result<(Vec<OrderByExpression>, Vec<Type>), TranslationErrors> {
        let translated = TranslationErrors::from_vec(
            self.ctx
                .iter()
                .map(|se| {
                    HamelinExpression::new(
                        TranslationErrors::expect(se.as_ref(), se.expression())?,
                        self.context.clone(),
                    )
                    .translate()
                })
                .collect(),
        )?;

        let res = translated
            .into_iter()
            .zip(self.ctx.iter())
            .map(|(t, se)| {
                (
                    OrderByExpression::new(
                        t.sql,
                        if se.DESC().is_some() {
                            Direction::DESC
                        } else {
                            Direction::ASC
                        },
                    ),
                    t.typ,
                )
            })
            .collect();

        Ok(res)
    }
}