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

use ahash::AHashMap;

use super::AL01::{Aliasing, RuleAL01};
use crate::core::config::Value;
use crate::core::rules::base::{Erased, ErasedRule, LintResult, Rule};
use crate::core::rules::context::RuleContext;
use crate::core::rules::crawlers::{Crawler, SegmentSeekerCrawler};
use crate::utils::functional::context::FunctionalContext;

#[derive(Debug, Clone)]
pub struct RuleAL02 {
    base: RuleAL01,
}

impl Default for RuleAL02 {
    fn default() -> Self {
        Self { base: RuleAL01::default().target_parent_types(&["select_clause_element"]) }
    }
}

impl RuleAL02 {
    pub fn aliasing(mut self, aliasing: Aliasing) -> Self {
        self.base = self.base.aliasing(aliasing);
        self
    }
}

impl Rule for RuleAL02 {
    fn load_from_config(&self, _config: &AHashMap<String, Value>) -> ErasedRule {
        RuleAL02::default().erased()
    }

    fn name(&self) -> &'static str {
        "aliasing.column"
    }

    fn description(&self) -> &'static str {
        "Implicit/explicit aliasing of columns."
    }

    fn eval(&self, context: RuleContext) -> Vec<LintResult> {
        if FunctionalContext::new(context.clone())
            .segment()
            .children(None)
            .last()
            .unwrap()
            .get_raw()
            .unwrap()
            == "="
        {
            return Vec::new();
        }

        self.base.eval(context)
    }

    fn crawl_behaviour(&self) -> Crawler {
        SegmentSeekerCrawler::new(["alias_expression"].into()).into()
    }
}

#[cfg(test)]
mod tests {
    use crate::api::simple::fix;
    use crate::core::rules::base::Erased;
    use crate::rules::aliasing::AL01::Aliasing;
    use crate::rules::aliasing::AL02::RuleAL02;

    #[test]
    fn test_fail_explicit_column_default() {
        assert_eq!(
            fix("select 1 bar from table1 b".into(), vec![RuleAL02::default().erased()]),
            "select 1 AS bar from table1 b"
        );
    }

    #[test]
    fn test_fail_explicit_column_explicit() {
        let sql = "select 1 bar from table1 b";

        let result =
            fix(sql.to_string(), vec![RuleAL02::default().aliasing(Aliasing::Explicit).erased()]);

        assert_eq!(result, "select 1 AS bar from table1 b");
    }

    #[test]
    fn test_fail_explicit_column_implicit() {
        let sql = "select 1 AS bar from table1 b";

        let result =
            fix(sql.to_string(), vec![RuleAL02::default().aliasing(Aliasing::Implicit).erased()]);

        assert_eq!(result, "select 1 bar from table1 b");
    }

    #[test]
    fn test_fail_alias_ending_raw_equals() {
        let sql = "select col1 raw_equals";
        let result =
            fix(sql.to_string(), vec![RuleAL02::default().aliasing(Aliasing::Explicit).erased()]);

        assert_eq!(result, "select col1 AS raw_equals");
    }
}