gluesql_core/plan/expr/
aggregate.rs

1use crate::ast::{Aggregate, AggregateFunction, CountArgExpr, Expr};
2
3impl Aggregate {
4    pub fn as_expr(&self) -> Option<&Expr> {
5        match &self.func {
6            AggregateFunction::Count(CountArgExpr::Wildcard) => None,
7            AggregateFunction::Count(CountArgExpr::Expr(expr))
8            | AggregateFunction::Sum(expr)
9            | AggregateFunction::Max(expr)
10            | AggregateFunction::Min(expr)
11            | AggregateFunction::Avg(expr)
12            | AggregateFunction::Variance(expr)
13            | AggregateFunction::Stdev(expr) => Some(expr),
14        }
15    }
16}
17
18#[cfg(test)]
19mod tests {
20    use crate::{
21        ast::{Aggregate, Expr},
22        parse_sql::parse_expr,
23        translate::translate_expr,
24    };
25
26    fn parse(sql: &str) -> Aggregate {
27        let parsed = parse_expr(sql).unwrap();
28        let expr = translate_expr(&parsed).unwrap();
29
30        match expr {
31            Expr::Aggregate(aggregate) => *aggregate,
32            _ => unreachable!("only for aggregate tests"),
33        }
34    }
35
36    #[test]
37    fn as_expr() {
38        assert_eq!(parse("COUNT(*)").as_expr(), None);
39
40        let actual = parse("COUNT(id)");
41        let expected = Expr::Identifier("id".to_owned());
42        assert_eq!(actual.as_expr(), Some(&expected));
43
44        let actual = parse("SUM(id)");
45        let expected = Expr::Identifier("id".to_owned());
46        assert_eq!(actual.as_expr(), Some(&expected));
47
48        let actual = parse("MAX(id)");
49        let expected = Expr::Identifier("id".to_owned());
50        assert_eq!(actual.as_expr(), Some(&expected));
51
52        let actual = parse("MIN(id)");
53        let expected = Expr::Identifier("id".to_owned());
54        assert_eq!(actual.as_expr(), Some(&expected));
55
56        let actual = parse("AVG(id)");
57        let expected = Expr::Identifier("id".to_owned());
58        assert_eq!(actual.as_expr(), Some(&expected));
59
60        let actual = parse("VARIANCE(id)");
61        let expected = Expr::Identifier("id".to_owned());
62        assert_eq!(actual.as_expr(), Some(&expected));
63    }
64}