provide LISTAGG implementation

This patch provides an initial implemenation of LISTAGG[1]. Notably this
implemenation deviates from ANSI SQL by allowing both WITHIN GROUP and
the delimiter to be optional. We do so because Redshift SQL works this
way and this approach is ultimately more flexible.

Fixes #169.

[1] https://modern-sql.com/feature/listagg

Author: maxcountryman

src/ast/mod.rs

@@ -223,6 +223,8 @@ pub enum Expr {
     /// A parenthesized subquery `(SELECT ...)`, used in expression like
     /// `SELECT (subquery) AS x` or `WHERE (subquery) = x`
     Subquery(Box<Query>),
+    /// The `lISTAGG` function, e.g. `SELECT LISTAGG(...) WITHIN GROUP (ORDER BY ...)`.
+    ListAgg(ListAgg),
 }
 
 impl fmt::Display for Expr {
@@ -298,6 +300,7 @@ impl fmt::Display for Expr {
             }
             Expr::Exists(s) => write!(f, "EXISTS ({})", s),
             Expr::Subquery(s) => write!(f, "({})", s),
+            Expr::ListAgg(listagg) => write!(f, "{}", listagg),
         }
     }
 }
@@ -812,6 +815,71 @@ impl FromStr for FileFormat {
     }
 }
 
+/// A `LISTAGG` invocation
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ListAgg {
+    pub distinct: bool,
+    pub expr: Box<Expr>,
+    pub separator: Option<Box<Expr>>,
+    pub on_overflow: Option<ListAggOnOverflow>,
+    pub within_group: Option<Vec<OrderByExpr>>,
+}
+
+impl fmt::Display for ListAgg {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let distinct = if self.distinct { "DISTINCT " } else { "ALL " };
+        let args = if let Some(separator) = &self.separator {
+            format!(
+                "{}",
+                display_comma_separated(&[self.expr.clone(), separator.clone()])
+            )
+        } else {
+            format!("{}", self.expr)
+        };
+        if let Some(on_overflow) = &self.on_overflow {
+            write!(f, "LISTAGG({}{}{})", distinct, args, on_overflow)
+        } else {
+            write!(f, "LISTAGG({}{})", distinct, args)
+        }?;
+        if let Some(within_group) = &self.within_group {
+            write!(
+                f,
+                " WITHIN GROUP (ORDER BY {})",
+                display_comma_separated(within_group)
+            )
+        } else {
+            Ok(())
+        }
+    }
+}
+
+/// The `ON OVERFLOW` clause of a LISTAGG invocation
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ListAggOnOverflow {
+    pub error: bool,
+    pub filler: Option<Box<Expr>>,
+    pub with_count: bool,
+}
+
+impl fmt::Display for ListAggOnOverflow {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let overflow = if self.error {
+            "ERROR".to_owned()
+        } else {
+            format!(
+                "TRUNCATE {}{} COUNT",
+                if let Some(filler) = &self.filler {
+                    format!("{} ", filler)
+                } else {
+                    "".to_owned()
+                },
+                if self.with_count { "WITH" } else { "WITHOUT" }
+            )
+        };
+        write!(f, " ON OVERFLOW {}", overflow)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ObjectType {
     Table,

src/dialect/keywords.rs

@@ -160,6 +160,7 @@ define_keywords!(
     END_FRAME,
     END_PARTITION,
     EQUALS,
+    ERROR,
     ESCAPE,
     EVERY,
     EXCEPT,
@@ -227,6 +228,7 @@ define_keywords!(
     LIKE,
     LIKE_REGEX,
     LIMIT,
+    LISTAGG,
     LN,
     LOCAL,
     LOCALTIME,
@@ -275,6 +277,7 @@ define_keywords!(
     OUT,
     OUTER,
     OVER,
+    OVERFLOW,
     OVERLAPS,
     OVERLAY,
     PARAMETER,

src/parser.rs

@@ -191,6 +191,7 @@ impl Parser {
                 "EXISTS" => self.parse_exists_expr(),
                 "EXTRACT" => self.parse_extract_expr(),
                 "INTERVAL" => self.parse_literal_interval(),
+                "LISTAGG" => self.parse_listagg_expr(),
                 "NOT" => Ok(Expr::UnaryOp {
                     op: UnaryOperator::Not,
                     expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
@@ -423,6 +424,74 @@ impl Parser {
         })
     }
 
+    /// Parse a SQL LISTAGG expression, e.g. `LISTAGG(...) WITHIN GROUP (ORDER BY ...)`.
+    pub fn parse_listagg_expr(&mut self) -> Result<Expr, ParserError> {
+        self.expect_token(&Token::LParen)?;
+        let all = self.parse_keyword("ALL");
+        let distinct = self.parse_keyword("DISTINCT");
+        if all && distinct {
+            return parser_err!("Cannot specify both ALL and DISTINCT in LISTAGG".to_string());
+        }
+        let args = self.parse_comma_separated(Parser::parse_expr)?;
+        // TODO: Is there a safer way of grabbing the expr and separator?
+        let expr = Box::new(args[0].clone());
+        // While ANSI SQL would require the separator, Redshift makes this optional. Here we also
+        // make the separator optional as this provides a more general implementation.
+        let separator = if let Some(separtor) = args.get(1) {
+            Some(Box::new(separtor.clone()))
+        } else {
+            None
+        };
+        let on_overflow = if self.parse_keywords(vec!["ON", "OVERFLOW"]) {
+            let error = self.parse_keyword("ERROR");
+            let filler = if !error {
+                self.expect_keyword("TRUNCATE")?;
+                Some(Box::new(self.parse_expr()?))
+            } else {
+                None
+            };
+            let with_count = if !error {
+                let with_count = self.parse_keywords(vec!["WITH", "COUNT"]);
+                let without_count = self.parse_keywords(vec!["WITHOUT", "COUNT"]);
+                if !with_count && !without_count {
+                    return parser_err!(
+                        "Expected either WITH COUNT or WITHOUT COUNT in LISTAGG".to_string()
+                    );
+                };
+                with_count
+            } else {
+                false
+            };
+            Some(ListAggOnOverflow {
+                error,
+                filler,
+                with_count,
+            })
+        } else {
+            None
+        };
+        self.expect_token(&Token::RParen)?;
+        // Once again ANSI SQL requires WITHIN GROUP, but Redshift does not. Again we choose the
+        // more general implementation.
+        let within_group = if self.parse_keywords(vec!["WITHIN", "GROUP"]) {
+            self.expect_token(&Token::LParen)?;
+            self.expect_keywords(&["ORDER", "BY"])?;
+            Some(self.parse_comma_separated(Parser::parse_order_by_expr)?)
+        } else {
+            None
+        };
+        if within_group.is_some() {
+            self.expect_token(&Token::RParen)?;
+        }
+        Ok(Expr::ListAgg(ListAgg {
+            distinct,
+            expr,
+            separator,
+            on_overflow,
+            within_group,
+        }))
+    }
+
     // This function parses date/time fields for both the EXTRACT function-like
     // operator and interval qualifiers. EXTRACT supports a wider set of
     // date/time fields than interval qualifiers, so this function may need to

tests/sqlparser_common.rs

@@ -886,6 +886,57 @@ fn parse_extract() {
     );
 }
 
+#[test]
+fn parse_listagg() {
+    let sql = "SELECT LISTAGG(DISTINCT dateid, ', ' ON OVERFLOW TRUNCATE '%' WITHOUT COUNT) \
+               WITHIN GROUP (ORDER BY id, username)";
+    let select = verified_only_select(sql);
+
+    one_statement_parses_to(
+        "SELECT LISTAGG(sellerid) WITHIN GROUP (ORDER BY dateid)",
+        "SELECT LISTAGG(ALL sellerid) WITHIN GROUP (ORDER BY dateid)",
+    );
+    one_statement_parses_to("SELECT LISTAGG(dateid)", "SELECT LISTAGG(ALL dateid)");
+    verified_stmt("SELECT LISTAGG(DISTINCT dateid)");
+
+    let expr = Box::new(Expr::Identifier(Ident::new("dateid")));
+    let on_overflow = Some(ListAggOnOverflow {
+        error: false,
+        filler: Some(Box::new(Expr::Value(Value::SingleQuotedString(
+            "%".to_string(),
+        )))),
+        with_count: false,
+    });
+    let within_group = Some(vec![
+        OrderByExpr {
+            expr: Expr::Identifier(Ident {
+                value: "id".to_string(),
+                quote_style: None,
+            }),
+            asc: None,
+        },
+        OrderByExpr {
+            expr: Expr::Identifier(Ident {
+                value: "username".to_string(),
+                quote_style: None,
+            }),
+            asc: None,
+        },
+    ]);
+    assert_eq!(
+        &Expr::ListAgg(ListAgg {
+            distinct: true,
+            expr,
+            separator: Some(Box::new(Expr::Value(Value::SingleQuotedString(
+                ", ".to_string()
+            )))),
+            on_overflow,
+            within_group
+        }),
+        expr_from_projection(only(&select.projection))
+    );
+}
+
 #[test]
 fn parse_create_table() {
     let sql = "CREATE TABLE uk_cities (\