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

use {
    super::{ExprNode, SelectItemNode},
    crate::{
        ast::SelectItem,
        ast_builder::ExprWithAliasNode,
        parse_sql::parse_select_items,
        result::{Error, Result},
        translate::translate_select_item,
    },
};

#[derive(Clone, Debug)]
pub enum SelectItemList<'a> {
    Text(String),
    SelectItems(Vec<SelectItemNode<'a>>),
}

impl<'a> From<&str> for SelectItemList<'a> {
    fn from(exprs: &str) -> Self {
        SelectItemList::Text(exprs.to_owned())
    }
}

impl<'a> From<Vec<&str>> for SelectItemList<'a> {
    fn from(select_items: Vec<&str>) -> Self {
        SelectItemList::SelectItems(select_items.into_iter().map(Into::into).collect())
    }
}

impl<'a> From<ExprNode<'a>> for SelectItemList<'a> {
    fn from(expr_node: ExprNode<'a>) -> Self {
        SelectItemList::SelectItems(vec![expr_node.into()])
    }
}

impl<'a> From<Vec<ExprNode<'a>>> for SelectItemList<'a> {
    fn from(expr_nodes: Vec<ExprNode<'a>>) -> Self {
        SelectItemList::SelectItems(expr_nodes.into_iter().map(Into::into).collect())
    }
}

impl<'a> From<ExprWithAliasNode<'a>> for SelectItemList<'a> {
    fn from(expr_node: ExprWithAliasNode<'a>) -> Self {
        SelectItemList::SelectItems(vec![expr_node.into()])
    }
}

impl<'a> From<Vec<ExprWithAliasNode<'a>>> for SelectItemList<'a> {
    fn from(expr_nodes: Vec<ExprWithAliasNode<'a>>) -> Self {
        SelectItemList::SelectItems(expr_nodes.into_iter().map(Into::into).collect())
    }
}

impl<'a> TryFrom<SelectItemList<'a>> for Vec<SelectItem> {
    type Error = Error;

    fn try_from(select_items: SelectItemList<'a>) -> Result<Self> {
        match select_items {
            SelectItemList::Text(items) => parse_select_items(items)?
                .iter()
                .map(translate_select_item)
                .collect::<Result<Vec<_>>>(),
            SelectItemList::SelectItems(items) => items
                .into_iter()
                .map(TryInto::try_into)
                .collect::<Result<Vec<_>>>(),
        }
    }
}

#[cfg(test)]
mod tests {
    use {
        crate::{
            ast::SelectItem,
            ast_builder::{col, expr, SelectItemList},
            parse_sql::parse_select_items,
            result::Result,
            translate::translate_select_item,
        },
        pretty_assertions::assert_eq,
    };

    fn test(actual: SelectItemList, expected: &str) {
        let parsed = parse_select_items(expected).expect(expected);
        let expected = parsed
            .iter()
            .map(translate_select_item)
            .collect::<Result<Vec<SelectItem>>>();

        assert_eq!(actual.try_into(), expected);
    }

    #[test]
    fn select_item_list() {
        let actual = "id, name".into();
        let expected = "id, name";
        test(actual, expected);

        let actual = vec!["id", "name"].into();
        let expected = "id, name";
        test(actual, expected);

        let actual = col("id").into();
        let expected = "id";
        test(actual, expected);

        let actual = vec![col("id"), "name".into()].into();
        let expected = "id, name";
        test(actual, expected);

        let actual = col("id").sub(1).alias_as("new_id").into();
        let expected = "id - 1 AS new_id";
        test(actual, expected);

        let actual = vec![
            col("age").avg().alias_as("avg_age"),
            expr("name || ':foo'").alias_as("res"),
        ]
        .into();
        let expected = "AVG(age) AS avg_age, name || ':foo' AS res";
        test(actual, expected);
    }
}