Snowflake: accept COMMENT interspersed among CREATE FILE FORMAT options

Snowflake accepts file-format options in any order, including COMMENT before
other options (e.g. COMMENT = 'c' COMPRESSION = 'GZIP'). The previous parser
treated COMMENT as a stop keyword and then expected end-of-statement, so any
option after COMMENT was a syntax error. Parse COMMENT in the same loop as the
key-value options (matching CREATE TABLE / CREATE DATABASE), hoisting it into
the dedicated comment field.

Author: Wojciech Padlo

src/dialect/snowflake.rs

@@ -2234,15 +2234,6 @@ fn parse_create_file_format(
         format_type = Some(parser.parse_identifier()?);
     }
 
-    let options = if like_source.is_some() {
-        KeyValueOptions {
-            options: vec![],
-            delimiter: KeyValueOptionsDelimiter::Space,
-        }
-    } else {
-        parser.parse_key_value_options(false, &[Keyword::COMMENT])?
-    };
-
     // `LIKE` is mutually exclusive with `TYPE`/options per Snowflake's grammar.
     if like_source.is_some() && !matches!(parser.peek_token().token, Token::EOF | Token::SemiColon) {
         return parser.expected(
@@ -2251,11 +2242,36 @@ fn parse_create_file_format(
         );
     }
 
-    let comment = if parser.parse_keyword(Keyword::COMMENT) {
-        parser.expect_token(&Token::Eq)?;
-        Some(parser.parse_comment_value()?)
-    } else {
-        None
+    // `COMMENT` may appear anywhere among the options (Snowflake accepts any
+    // order, like CREATE TABLE / CREATE DATABASE), so it is parsed in the same
+    // loop rather than only as a trailing clause. It is hoisted into its own
+    // AST field; the remaining key-value options stay in `options`.
+    let mut comment = None;
+    let mut option_list: Vec<KeyValueOption> = Vec::new();
+    let mut delimiter = KeyValueOptionsDelimiter::Space;
+    if like_source.is_none() {
+        loop {
+            if parser.parse_keyword(Keyword::COMMENT) {
+                parser.expect_token(&Token::Eq)?;
+                comment = Some(parser.parse_comment_value()?);
+                continue;
+            }
+            if matches!(parser.peek_token().token, Token::EOF | Token::SemiColon) {
+                break;
+            }
+            let parsed = parser.parse_key_value_options(false, &[Keyword::COMMENT])?;
+            if parsed.options.is_empty() {
+                break;
+            }
+            if parsed.delimiter == KeyValueOptionsDelimiter::Comma {
+                delimiter = KeyValueOptionsDelimiter::Comma;
+            }
+            option_list.extend(parsed.options);
+        }
+    }
+    let options = KeyValueOptions {
+        options: option_list,
+        delimiter,
     };
 
     Ok(Statement::CreateFileFormat {

tests/sqlparser_snowflake.rs

@@ -6927,6 +6927,28 @@ fn test_create_file_format_temporary_with_comment() {
     }
 }
 
+#[test]
+fn test_create_file_format_comment_between_options() {
+    // Snowflake accepts options in any order, including COMMENT before other
+    // options. COMMENT is hoisted into its own field; the rest stay in options.
+    let sql = "CREATE FILE FORMAT f TYPE = CSV COMMENT = 'c' COMPRESSION = 'GZIP'";
+    let canonical = "CREATE FILE FORMAT f TYPE = CSV COMPRESSION='GZIP' COMMENT = 'c'";
+    match snowflake().one_statement_parses_to(sql, canonical) {
+        Statement::CreateFileFormat {
+            format_type,
+            options,
+            comment,
+            ..
+        } => {
+            assert_eq!(Some(Ident::new("CSV")), format_type);
+            assert_eq!(1, options.options.len());
+            assert_eq!("COMPRESSION", options.options[0].option_name);
+            assert_eq!(Some("c".to_string()), comment);
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn test_create_file_format_temp_synonym() {
     // TEMP and VOLATILE are synonyms of TEMPORARY for file formats; both