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

use std::fmt;
use std::fmt::Display;

use nom::branch::alt;
use nom::bytes::complete::tag_no_case;
use nom::combinator::map;
use nom::IResult;

use base::error::ParseSQLError;

/// Parse binary comparison operators
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub enum Operator {
    Not,
    And,
    Or,
    Like,
    NotLike,
    Equal,
    NotEqual,
    Greater,
    GreaterOrEqual,
    Less,
    LessOrEqual,
    In,
    NotIn,
    Is,
}

impl Operator {
    pub fn parse(i: &str) -> IResult<&str, Operator, ParseSQLError<&str>> {
        alt((
            map(tag_no_case("NOT_LIKE"), |_| Operator::NotLike),
            map(tag_no_case("LIKE"), |_| Operator::Like),
            map(tag_no_case("!="), |_| Operator::NotEqual),
            map(tag_no_case("<>"), |_| Operator::NotEqual),
            map(tag_no_case(">="), |_| Operator::GreaterOrEqual),
            map(tag_no_case("<="), |_| Operator::LessOrEqual),
            map(tag_no_case("="), |_| Operator::Equal),
            map(tag_no_case("<"), |_| Operator::Less),
            map(tag_no_case(">"), |_| Operator::Greater),
            map(tag_no_case("IN"), |_| Operator::In),
        ))(i)
    }
}

impl Display for Operator {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let op = match *self {
            Operator::Not => "NOT",
            Operator::And => "AND",
            Operator::Or => "OR",
            Operator::Like => "LIKE",
            Operator::NotLike => "NOT_LIKE",
            Operator::Equal => "=",
            Operator::NotEqual => "!=",
            Operator::Greater => ">",
            Operator::GreaterOrEqual => ">=",
            Operator::Less => "<",
            Operator::LessOrEqual => "<=",
            Operator::In => "IN",
            Operator::NotIn => "NOT IN",
            Operator::Is => "IS",
        };
        write!(f, "{}", op)
    }
}