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

use std::fmt;
use std::fmt::{Display, Formatter};
use std::str;

use nom::branch::alt;
use nom::bytes::complete::tag_no_case;
use nom::character::complete::{multispace0, multispace1};
use nom::combinator::{map, opt};
use nom::multi::many0;
use nom::sequence::{preceded, tuple};
use nom::IResult;

use base::column::Column;
use base::error::ParseSQLError;
use base::{CommonParser, DisplayUtil};

#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct OrderClause {
    pub columns: Vec<(Column, OrderType)>, // TODO(malte): can this be an arbitrary expr?
}

impl OrderClause {
    // Parse ORDER BY clause
    pub fn parse(i: &str) -> IResult<&str, OrderClause, ParseSQLError<&str>> {
        let (remaining_input, (_, _, _, _, _, columns)) = tuple((
            multispace0,
            tag_no_case("ORDER"),
            multispace1,
            tag_no_case("BY"),
            multispace1,
            many0(Self::order_expr),
        ))(i)?;

        Ok((remaining_input, OrderClause { columns }))
    }

    fn order_expr(i: &str) -> IResult<&str, (Column, OrderType), ParseSQLError<&str>> {
        let (remaining_input, (field_name, ordering, _)) = tuple((
            Column::without_alias,
            opt(preceded(multispace0, OrderType::parse)),
            opt(CommonParser::ws_sep_comma),
        ))(i)?;

        Ok((
            remaining_input,
            (field_name, ordering.unwrap_or(OrderType::Asc)),
        ))
    }
}

impl fmt::Display for OrderClause {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ORDER BY ")?;
        write!(
            f,
            "{}",
            self.columns
                .iter()
                .map(|(c, o)| format!("{} {}", DisplayUtil::escape_if_keyword(&c.name), o))
                .collect::<Vec<_>>()
                .join(", ")
        )
    }
}

/// parse `[ASC | DESC]`
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub enum OrderType {
    Asc,
    Desc,
}

impl OrderType {
    pub fn parse(i: &str) -> IResult<&str, OrderType, ParseSQLError<&str>> {
        alt((
            map(tag_no_case("DESC"), |_| OrderType::Desc),
            map(tag_no_case("ASC"), |_| OrderType::Asc),
        ))(i)
    }
}

impl Display for OrderType {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match *self {
            OrderType::Asc => write!(f, "ASC"),
            OrderType::Desc => write!(f, "DESC"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_order_clause() {
        let str1 = "order by name desc";
        let str2 = "order by name asc, age desc";
        let str3 = "order by name";

        let expected_ord1 = OrderClause {
            columns: vec![("name".into(), OrderType::Desc)],
        };
        let expected_ord2 = OrderClause {
            columns: vec![
                ("name".into(), OrderType::Asc),
                ("age".into(), OrderType::Desc),
            ],
        };
        let expected_ord3 = OrderClause {
            columns: vec![("name".into(), OrderType::Asc)],
        };

        let res1 = OrderClause::parse(str1);
        let res2 = OrderClause::parse(str2);
        let res3 = OrderClause::parse(str3);
        assert_eq!(res1.unwrap().1, expected_ord1);
        assert_eq!(res2.unwrap().1, expected_ord2);
        assert_eq!(res3.unwrap().1, expected_ord3);
    }

    #[test]
    fn parse_order_type() {
        let str1 = "aSc";
        let res1 = OrderType::parse(str1);
        assert!(res1.is_ok());
        assert_eq!(res1.unwrap().1, OrderType::Asc);

        let str2 = "desc";
        let res2 = OrderType::parse(str2);
        assert!(res2.is_ok());
        assert_eq!(res2.unwrap().1, OrderType::Desc);
    }
}