hamelin_legacy 0.3.8

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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::{cell::RefCell, rc::Rc, sync::Arc};

use hamelin_lib::completion::Completion;
use hamelin_lib::func::def::FunctionTranslationContext;
use hamelin_lib::func::registry::FunctionRegistry;
use hamelin_lib::provider::EnvironmentProvider;
use hamelin_lib::sql::expression::SQLExpression;
use hamelin_sql::TranslationRegistry;

use crate::env::Environment;

pub mod apply;
pub mod assignment_clause;
pub mod cast;
pub mod column_ref;
pub mod command;
pub mod deref;
pub mod expression;
pub mod from_clause;
pub mod index;
pub mod pipeline;
pub mod query;
pub mod sort_expression;
pub mod string;

pub struct QueryTranslationContext {
    pub within: Option<SQLExpression>,
    pub provider: Arc<dyn EnvironmentProvider>,
    pub registry: Arc<FunctionRegistry>,
    pub translation_registry: Arc<TranslationRegistry>,
    pub at: Option<usize>,
    pub completions: Rc<RefCell<Option<Completion>>>,
}

impl QueryTranslationContext {
    pub fn new(
        within: Option<SQLExpression>,
        provider: Arc<dyn EnvironmentProvider>,
        registry: Arc<FunctionRegistry>,
        translation_registry: Arc<TranslationRegistry>,
        at: Option<usize>,
    ) -> Rc<Self> {
        Rc::new(Self {
            within,
            provider,
            registry,
            translation_registry,
            at,
            completions: Rc::new(RefCell::new(None)),
        })
    }

    pub fn default_expression_translation_context(
        &self,
        env: &Environment,
    ) -> Rc<ExpressionTranslationContext> {
        Rc::new(ExpressionTranslationContext {
            fctx: FunctionTranslationContext::default(),
            bindings: Arc::new(env.clone()),
            registry: self.registry.clone(),
            translation_registry: self.translation_registry.clone(),
            at: self.at.clone(),
            completions: self.completions.clone(),
        })
    }

    pub fn expression_translation_context(
        &self,
        env: &Environment,
        fctx: FunctionTranslationContext,
    ) -> Rc<ExpressionTranslationContext> {
        Rc::new(ExpressionTranslationContext {
            fctx,
            bindings: Arc::new(env.clone()),
            registry: self.registry.clone(),
            translation_registry: self.translation_registry.clone(),
            at: self.at.clone(),
            completions: self.completions.clone(),
        })
    }

    pub fn without_completion(&self) -> Rc<Self> {
        Self::new(
            self.within.clone(),
            self.provider.clone(),
            self.registry.clone(),
            self.translation_registry.clone(),
            None,
        )
    }
}

#[derive(Clone, Debug)]
pub struct ExpressionTranslationContext {
    pub fctx: FunctionTranslationContext,
    pub bindings: Arc<Environment>, // TODO: Rc
    pub registry: Arc<FunctionRegistry>,
    pub translation_registry: Arc<TranslationRegistry>,
    pub at: Option<usize>,
    pub completions: Rc<RefCell<Option<Completion>>>,
}

impl ExpressionTranslationContext {
    pub fn new(
        bindings: Arc<Environment>,
        registry: Arc<FunctionRegistry>,
        translation_registry: Arc<TranslationRegistry>,
        fctx: FunctionTranslationContext,
        at: Option<usize>,
        completions: Rc<RefCell<Option<Completion>>>,
    ) -> Rc<Self> {
        Rc::new(Self {
            fctx,
            bindings,
            registry,
            translation_registry,
            at,
            completions,
        })
    }

    pub fn without_completion(
        self: Rc<ExpressionTranslationContext>,
    ) -> Rc<ExpressionTranslationContext> {
        Rc::new(ExpressionTranslationContext {
            fctx: self.fctx.clone(),
            bindings: self.bindings.clone(),
            registry: self.registry.clone(),
            translation_registry: self.translation_registry.clone(),
            at: None,
            completions: self.completions.clone(),
        })
    }

    pub fn with_env(
        self: Rc<ExpressionTranslationContext>,
        env: Arc<Environment>,
    ) -> Rc<ExpressionTranslationContext> {
        Rc::new(ExpressionTranslationContext {
            fctx: self.fctx.clone(),
            bindings: env,
            registry: self.registry.clone(),
            translation_registry: self.translation_registry.clone(),
            at: self.at,
            completions: self.completions.clone(),
        })
    }
}