Fix: GROUPING SETS accept values without parenthesis

src/parser/mod.rs

@@ -2273,6 +2273,16 @@ impl<'a> Parser<'a> {
         }
     }
 
+    // Helper function to parse an element within GROUPING SETS
+    // This element can either be a single expression or a parenthesized list of expressions.
+    fn parse_grouping_set_element(&mut self) -> Result<Vec<Expr>, ParserError> {
+        if self.peek_token_ref().token == Token::LParen {
+            self.parse_tuple(true, true)
+        } else {
+            Ok(vec![self.parse_expr()?])
+        }
+    }
+
     pub fn parse_case_expr(&mut self) -> Result<Expr, ParserError> {
         let mut operand = None;
         if !self.parse_keyword(Keyword::WHEN) {
@@ -10045,7 +10055,7 @@ impl<'a> Parser<'a> {
             }
             if self.parse_keywords(&[Keyword::GROUPING, Keyword::SETS]) {
                 self.expect_token(&Token::LParen)?;
-                let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;
+                let result = self.parse_comma_separated(|p| p.parse_grouping_set_element())?;
                 self.expect_token(&Token::RParen)?;
                 modifiers.push(GroupByWithModifier::GroupingSets(Expr::GroupingSets(
                     result,

tests/sqlparser_common.rs

@@ -2822,6 +2822,38 @@ fn parse_group_by_special_grouping_sets() {
     }
 }
 
+#[test]
+fn parse_group_by_grouping_sets_single_values() {
+    let sql = "SELECT a, b, SUM(c) FROM tab1 GROUP BY a, b GROUPING SETS ((a, b), a, (b), c, ())";
+    let canonical =
+        "SELECT a, b, SUM(c) FROM tab1 GROUP BY a, b GROUPING SETS ((a, b), (a), (b), (c), ())";
+    match all_dialects().one_statement_parses_to(sql, canonical) {
+        Statement::Query(query) => {
+            let group_by = &query.body.as_select().unwrap().group_by;
+            assert_eq!(
+                group_by,
+                &GroupByExpr::Expressions(
+                    vec![
+                        Expr::Identifier(Ident::new("a")),
+                        Expr::Identifier(Ident::new("b"))
+                    ],
+                    vec![GroupByWithModifier::GroupingSets(Expr::GroupingSets(vec![
+                        vec![
+                            Expr::Identifier(Ident::new("a")),
+                            Expr::Identifier(Ident::new("b"))
+                        ],
+                        vec![Expr::Identifier(Ident::new("a"))],
+                        vec![Expr::Identifier(Ident::new("b"))],
+                        vec![Expr::Identifier(Ident::new("c"))],
+                        vec![]
+                    ]))]
+                )
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn parse_select_having() {
     let sql = "SELECT foo FROM bar GROUP BY foo HAVING COUNT(*) > 1";