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 nom::branch::alt;
use nom::bytes::complete::tag_no_case;
use nom::character::complete::multispace1;
use nom::combinator::map;
use nom::sequence::tuple;
use nom::IResult;
use std::fmt::{Display, Formatter};

use base::ParseSQLError;

/// parse `[MATCH FULL | MATCH PARTIAL | MATCH SIMPLE]`
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub enum MatchType {
    Full,
    Partial,
    Simple,
}

impl Display for MatchType {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match *self {
            MatchType::Full => write!(f, "MATCH FULL"),
            MatchType::Partial => write!(f, "MATCH PARTIAL"),
            MatchType::Simple => write!(f, "MATCH SIMPLE"),
        }
    }
}

impl MatchType {
    pub fn parse(i: &str) -> IResult<&str, MatchType, ParseSQLError<&str>> {
        map(
            tuple((
                tag_no_case("MATCH"),
                multispace1,
                alt((
                    map(tag_no_case("FULL"), |_| MatchType::Full),
                    map(tag_no_case("PARTIAL"), |_| MatchType::Partial),
                    map(tag_no_case("SIMPLE"), |_| MatchType::Simple),
                )),
            )),
            |x| x.2,
        )(i)
    }
}

#[cfg(test)]
mod tests {
    use base::MatchType;

    #[test]
    fn parse_algorithm_type() {
        let str1 = "MATCH Full ";
        let res1 = MatchType::parse(str1);
        assert!(res1.is_ok());
        assert_eq!(res1.unwrap().1, MatchType::Full);

        let str2 = "match PARTIAL";
        let res2 = MatchType::parse(str2);
        assert!(res2.is_ok());
        assert_eq!(res2.unwrap().1, MatchType::Partial);

        let str3 = "match  SIMPLE   ";
        let res3 = MatchType::parse(str3);
        assert!(res3.is_ok());
        assert_eq!(res3.unwrap().1, MatchType::Simple);
    }
}