fixup

Author: MazterQyou

src/ast/mod.rs

@@ -2423,7 +2423,6 @@ pub struct ListAgg {
     pub expr: Box<Expr>,
     pub separator: Option<Box<Expr>>,
     pub on_overflow: Option<ListAggOnOverflow>,
-    pub within_group: Vec<OrderByExpr>,
 }
 
 impl fmt::Display for ListAgg {
@@ -2441,13 +2440,6 @@ impl fmt::Display for ListAgg {
             write!(f, "{}", on_overflow)?;
         }
         write!(f, ")")?;
-        if !self.within_group.is_empty() {
-            write!(
-                f,
-                " WITHIN GROUP (ORDER BY {})",
-                display_comma_separated(&self.within_group)
-            )?;
-        }
         Ok(())
     }
 }
@@ -2497,7 +2489,6 @@ pub struct ArrayAgg {
     pub expr: Box<Expr>,
     pub order_by: Option<Box<OrderByExpr>>,
     pub limit: Option<Box<Expr>>,
-    pub within_group: bool, // order by is used inside a within group or not
 }
 
 impl fmt::Display for ArrayAgg {
@@ -2508,20 +2499,13 @@ impl fmt::Display for ArrayAgg {
             if self.distinct { "DISTINCT " } else { "" },
             self.expr
         )?;
-        if !self.within_group {
-            if let Some(order_by) = &self.order_by {
-                write!(f, " ORDER BY {}", order_by)?;
-            }
-            if let Some(limit) = &self.limit {
-                write!(f, " LIMIT {}", limit)?;
-            }
+        if let Some(order_by) = &self.order_by {
+            write!(f, " ORDER BY {}", order_by)?;
         }
-        write!(f, ")")?;
-        if self.within_group {
-            if let Some(order_by) = &self.order_by {
-                write!(f, " WITHIN GROUP (ORDER BY {})", order_by)?;
-            }
+        if let Some(limit) = &self.limit {
+            write!(f, " LIMIT {}", limit)?;
         }
+        write!(f, ")")?;
         Ok(())
     }
 }

src/parser.rs

@@ -1014,17 +1014,24 @@ impl<'a> Parser<'a> {
             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)?;
-            order_by_expr
+            Some(order_by_expr)
         } else {
-            vec![]
+            None
         };
-        Ok(Expr::ListAgg(ListAgg {
+        let list_agg = Expr::ListAgg(ListAgg {
             distinct,
             expr,
             separator,
             on_overflow,
-            within_group,
-        }))
+        });
+        Ok(if let Some(within_group) = within_group {
+            Expr::WithinGroup(WithinGroup {
+                expr: Box::new(list_agg),
+                order_by: within_group,
+            })
+        } else {
+            list_agg
+        })
     }
 
     pub fn parse_array_agg_expr(&mut self) -> Result<Expr, ParserError> {
@@ -1050,7 +1057,6 @@ impl<'a> Parser<'a> {
                 expr,
                 order_by,
                 limit,
-                within_group: false,
             }));
         }
         // Snowflake defines ORDERY BY in within group instead of inside the function like
@@ -1061,18 +1067,25 @@ impl<'a> Parser<'a> {
             self.expect_keywords(&[Keyword::ORDER, Keyword::BY])?;
             let order_by_expr = self.parse_order_by_expr()?;
             self.expect_token(&Token::RParen)?;
-            Some(Box::new(order_by_expr))
+            Some(order_by_expr)
         } else {
             None
         };
 
-        Ok(Expr::ArrayAgg(ArrayAgg {
+        let array_agg = Expr::ArrayAgg(ArrayAgg {
             distinct,
             expr,
-            order_by: within_group,
+            order_by: None,
             limit: None,
-            within_group: true,
-        }))
+        });
+        Ok(if let Some(within_group) = within_group {
+            Expr::WithinGroup(WithinGroup {
+                expr: Box::new(array_agg),
+                order_by: vec![within_group],
+            })
+        } else {
+            array_agg
+        })
     }
 
     // This function parses date/time fields for both the EXTRACT function-like

tests/sqlparser_common.rs

@@ -1702,14 +1702,16 @@ fn parse_listagg() {
         },
     ];
     assert_eq!(
-        &Expr::ListAgg(ListAgg {
-            distinct: true,
-            expr,
-            separator: Some(Box::new(Expr::Value(Value::SingleQuotedString(
-                ", ".to_string()
-            )))),
-            on_overflow,
-            within_group
+        &Expr::WithinGroup(WithinGroup {
+            expr: Box::new(Expr::ListAgg(ListAgg {
+                distinct: true,
+                expr,
+                separator: Some(Box::new(Expr::Value(Value::SingleQuotedString(
+                    ", ".to_string()
+                )))),
+                on_overflow,
+            })),
+            order_by: within_group
         }),
         expr_from_projection(only(&select.projection))
     );