feat: WITHIN GROUP expression support

src/ast/mod.rs

@@ -348,6 +348,8 @@ pub enum Expr {
     ListAgg(ListAgg),
     /// The `ARRAY_AGG` function `SELECT ARRAY_AGG(... ORDER BY ...)`
     ArrayAgg(ArrayAgg),
+    /// The `WITHIN GROUP` expr `... WITHIN GROUP (ORDER BY ...)`
+    WithinGroup(WithinGroup),
     /// The `GROUPING SETS` expr.
     GroupingSets(Vec<Vec<Expr>>),
     /// The `CUBE` expr.
@@ -549,6 +551,7 @@ impl fmt::Display for Expr {
             Expr::ArraySubquery(s) => write!(f, "ARRAY({})", s),
             Expr::ListAgg(listagg) => write!(f, "{}", listagg),
             Expr::ArrayAgg(arrayagg) => write!(f, "{}", arrayagg),
+            Expr::WithinGroup(withingroup) => write!(f, "{}", withingroup),
             Expr::GroupingSets(sets) => {
                 write!(f, "GROUPING SETS (")?;
                 let mut sep = "";
@@ -2523,6 +2526,26 @@ impl fmt::Display for ArrayAgg {
     }
 }
 
+/// A `WITHIN GROUP` invocation `<expr> WITHIN GROUP (ORDER BY <sort_expr> )`
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct WithinGroup {
+    pub expr: Box<Expr>,
+    pub order_by: Vec<OrderByExpr>,
+}
+
+impl fmt::Display for WithinGroup {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{} WITHIN GROUP (ORDER BY {})",
+            self.expr,
+            display_comma_separated(&self.order_by),
+        )?;
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum ObjectType {

src/parser.rs

@@ -627,14 +627,33 @@ impl<'a> Parser<'a> {
             None
         };
 
-        Ok(Expr::Function(Function {
+        let within_group = if self.parse_keywords(&[Keyword::WITHIN, Keyword::GROUP]) {
+            self.expect_token(&Token::LParen)?;
+            self.expect_keywords(&[Keyword::ORDER, Keyword::BY])?;
+            let order_by_expr = self.parse_comma_separated(Parser::parse_order_by_expr)?;
+            self.expect_token(&Token::RParen)?;
+            Some(order_by_expr)
+        } else {
+            None
+        };
+
+        let function = Expr::Function(Function {
             name,
             args,
             over,
             distinct,
             special: false,
             approximate: false,
-        }))
+        });
+
+        Ok(if let Some(within_group) = within_group {
+            Expr::WithinGroup(WithinGroup {
+                expr: Box::new(function),
+                order_by: within_group,
+            })
+        } else {
+            function
+        })
     }
 
     pub fn parse_time_functions(&mut self, name: ObjectName) -> Result<Expr, ParserError> {

tests/sqlparser_common.rs

@@ -1736,6 +1736,41 @@ fn parse_array_agg_func() {
     }
 }
 
+#[test]
+fn parse_within_group() {
+    let sql = "SELECT PERCENTILE_CONT(0.0) WITHIN GROUP (ORDER BY name ASC NULLS FIRST)";
+    let select = verified_only_select(sql);
+
+    #[cfg(feature = "bigdecimal")]
+    let value = bigdecimal::BigDecimal::from(0);
+    #[cfg(not(feature = "bigdecimal"))]
+    let value = "0.0".to_string();
+    let expr = Expr::Value(Value::Number(value, false));
+    let function = Expr::Function(Function {
+        name: ObjectName(vec![Ident::new("PERCENTILE_CONT")]),
+        args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(expr))],
+        over: None,
+        distinct: false,
+        special: false,
+        approximate: false,
+    });
+    let within_group = vec![OrderByExpr {
+        expr: Expr::Identifier(Ident {
+            value: "name".to_string(),
+            quote_style: None,
+        }),
+        asc: Some(true),
+        nulls_first: Some(true),
+    }];
+    assert_eq!(
+        &Expr::WithinGroup(WithinGroup {
+            expr: Box::new(function),
+            order_by: within_group
+        }),
+        expr_from_projection(only(&select.projection))
+    );
+}
+
 #[test]
 fn parse_create_table() {
     let sql = "CREATE TABLE uk_cities (\