hamelin_legacy 0.3.9

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

use crate::ast::expression::HamelinExpression;
use crate::ast::pipeline::HamelinPipeline;
use crate::env::Environment;
use crate::translation::projection_builder::{ProjectionBuilder, ProjectionBuilderExt};
use crate::translation::sql_query_helpers::prepend_projections;
use crate::translation::PendingQueryResult;
use hamelin_lib::antlr::hamelinparser::{
    AssignmentContextAttrs, LetCommandContext, LetCommandContextAttrs,
};
use hamelin_lib::err::TranslationError;
use hamelin_lib::sql::expression::identifier::HamelinIdentifier;

pub fn translate(
    ctx: &LetCommandContext<'static>,
    pipeline: &HamelinPipeline,
    pending_query_result: &mut PendingQueryResult,
) {
    let mut new_projections = ProjectionBuilder::default();
    for (identifier_ctx, expression_ctx) in
        ctx.assignment_all().into_iter().flat_map(|assignment| {
            assignment
                .identifier()
                .and_then(|i| assignment.expression().map(|e| (i, e)))
        })
    {
        let identifier = pending_query_result
            .errors
            .consume_errors(HamelinIdentifier::new(identifier_ctx).to_sql());
        let expr_ctx = pipeline
            .context
            .default_expression_translation_context(&pending_query_result.translation.env);
        let expression = HamelinExpression::new(expression_ctx, expr_ctx);
        let expression_translation = pending_query_result
            .errors
            .consume_errors(expression.translate());

        if let Some((identifier, expression_translation)) = identifier.zip(expression_translation) {
            new_projections.intialize_struct_reference_then_bind(
                identifier,
                expression_translation.sql,
                expression_translation.typ,
                &pending_query_result.translation.env,
            );
        }
    }

    let env = Environment::new(new_projections.clone().build_hamelin_type());
    pending_query_result.translation.env =
        pending_query_result.translation.env.prepend_overwrite(&env);

    if let Some(projections) = pending_query_result.errors.consume_errors(
        new_projections
            .build_projections()
            .map_err(|e| TranslationError::wrap_box(ctx, e.into()).single()),
    ) {
        pending_query_result.translation.query = prepend_projections(
            &pending_query_result.translation.query,
            projections,
            &pending_query_result.translation.env,
        );
    }
}