Re-enable trailing commas in DCL

src/parser/mod.rs

@@ -3278,6 +3278,31 @@
         ret
     }
 
+    pub fn parse_actions_list(
+        &mut self,
+    ) -> Result<Vec<(Keyword, Option<Vec<Ident>>)>, ParserError> {
+        let mut values = vec![];
+        loop {
+            values.push(self.parse_grant_permission()?);
+            if !self.consume_token(&Token::Comma) {
+                break;
+            } else if self.options.trailing_commas {
+                match self.peek_token().token {
+                    Token::Word(kw) if kw.keyword == Keyword::ON => {
+                        break;
+                    }
+                    Token::RParen
+                    | Token::SemiColon
+                    | Token::EOF
+                    | Token::RBracket
+                    | Token::RBrace => break,
+                    _ => continue,
+                }
+            }
+        }
+        Ok(values)
+    }
+
     /// Parse a comma-separated list of 1+ items accepted by `F`
     pub fn parse_comma_separated<T, F>(&mut self, mut f: F) -> Result<Vec<T>, ParserError>
     where
@@ -3291,9 +3316,7 @@
             } else if self.options.trailing_commas {
                 match self.peek_token().token {
                     Token::Word(kw)
-                        if keywords::RESERVED_FOR_COLUMN_ALIAS
-                            .iter()
-                            .any(|d| kw.keyword == *d) =>
+                        if keywords::RESERVED_FOR_COLUMN_ALIAS.contains(&kw.keyword) =>
                     {
                         break;
                     }
@@ -9556,11 +9579,8 @@
                 with_privileges_keyword: self.parse_keyword(Keyword::PRIVILEGES),
             }
         } else {
-            let old_value = self.options.trailing_commas;
-            self.options.trailing_commas = false;
-
             let (actions, err): (Vec<_>, Vec<_>) = self
-                .parse_comma_separated(Parser::parse_grant_permission)?
+                .parse_actions_list()?
                 .into_iter()
                 .map(|(kw, columns)| match kw {
                     Keyword::DELETE => Ok(Action::Delete),
@@ -9582,8 +9602,6 @@
                 })
                 .partition(Result::is_ok);
 
-            self.options.trailing_commas = old_value;
-
             if !err.is_empty() {
                 let errors: Vec<Keyword> = err.into_iter().filter_map(|x| x.err()).collect();
                 return Err(ParserError::ParserError(format!(

tests/sqlparser_common.rs

@@ -8894,6 +8894,11 @@ fn parse_trailing_comma() {
         "CREATE TABLE employees (name TEXT, age INT)",
     );
 
+    trailing_commas.one_statement_parses_to(
+        "GRANT USAGE, SELECT, INSERT, ON p TO u",
+        "GRANT USAGE, SELECT, INSERT ON p TO u",
+    );
+
     trailing_commas.verified_stmt("SELECT album_id, name FROM track");
 
     trailing_commas.verified_stmt("SELECT * FROM track ORDER BY milliseconds");
@@ -8913,6 +8918,13 @@ fn parse_trailing_comma() {
         ParserError::ParserError("Expected an expression, found: from".to_string())
     );
 
+    assert_eq!(
+        trailing_commas
+            .parse_sql_statements("REVOKE USAGE, SELECT, ON p TO u")
+            .unwrap_err(),
+        ParserError::ParserError("Expected a privilege keyword, found: ON".to_string())
+    );
+
     assert_eq!(
         trailing_commas
             .parse_sql_statements("CREATE TABLE employees (name text, age int,)")