Snowflake: FILE_FORMAT = <name> shorthand in COPY INTO (#11)

* Snowflake: FILE_FORMAT = <name> shorthand in COPY INTO

* Snowflake: test FILE_FORMAT = <name> shorthand; fix pre-existing rustfmt

Add a parser test covering the FILE_FORMAT = <name> COPY INTO shorthand
(unquoted ident, quoted string, and the unaffected parenthesized form).

Also reflow a pre-existing unformatted block in parser/mod.rs so
'cargo fmt --all -- --check' (CI codestyle) passes.

---------

Co-authored-by: Wojciech Padlo <wojciech.padlo@localstack.cloud>

Author: wojpadlo

src/dialect/snowflake.rs

@@ -1623,7 +1623,25 @@ pub fn parse_copy_into(parser: &mut Parser) -> Result<Statement, ParserError> {
         // FILE_FORMAT
         if parser.parse_keyword(Keyword::FILE_FORMAT) {
             parser.expect_token(&Token::Eq)?;
-            file_format = parser.parse_key_value_options(true, &[])?.options;
+            if parser.peek_token().token == Token::LParen {
+                file_format = parser.parse_key_value_options(true, &[])?.options;
+            } else {
+                // Shorthand `FILE_FORMAT = '<name>'` / `FILE_FORMAT = <ident>`
+                // is sugar for `FILE_FORMAT = (FORMAT_NAME = <name>)` —
+                // normalize it (mirrors CREATE STAGE).
+                let tok = parser.peek_token();
+                let value = match tok.token {
+                    Token::Word(w) => {
+                        parser.next_token();
+                        Value::Placeholder(w.value.clone()).with_span(tok.span)
+                    }
+                    _ => parser.parse_value()?,
+                };
+                file_format = vec![KeyValueOption {
+                    option_name: "FORMAT_NAME".to_string(),
+                    option_value: KeyValueOptionKind::Single(value),
+                }];
+            }
         // PARTITION BY
         } else if parser.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) {
             partition = Some(Box::new(parser.parse_expr()?))

src/parser/mod.rs

@@ -1886,16 +1886,21 @@ impl<'a> Parser<'a> {
                 // callee name (an `ObjectNamePart::Function`) and the trailing
                 // `(args)` is the actual call — mirror the object-name grammar
                 // so the resulting `Expr::Function` matches the CALL path shape.
-                if self.dialect.is_identifier_generating_function_name(&ident, &[]) {
+                if self
+                    .dialect
+                    .is_identifier_generating_function_name(&ident, &[])
+                {
                     let checkpoint = self.index;
                     self.expect_token(&Token::LParen)?;
-                    let args = self
-                        .parse_comma_separated0(Self::parse_function_args, Token::RParen)?;
+                    let args =
+                        self.parse_comma_separated0(Self::parse_function_args, Token::RParen)?;
                     self.expect_token(&Token::RParen)?;
                     if self.peek_token_ref().token == Token::LParen {
-                        let name = ObjectName(vec![ObjectNamePart::Function(
-                            ObjectNamePartFunction { name: ident, args },
-                        )]);
+                        let name =
+                            ObjectName(vec![ObjectNamePart::Function(ObjectNamePartFunction {
+                                name: ident,
+                                args,
+                            })]);
                         return self.parse_function(name);
                     }
                     self.index = checkpoint;

tests/sqlparser_snowflake.rs

@@ -2675,6 +2675,83 @@ fn test_copy_into_file_format() {
     }
 }
 
+#[test]
+fn test_copy_into_file_format_name_shorthand() {
+    // Bare `FILE_FORMAT = <name>` is sugar for
+    // `FILE_FORMAT = (FORMAT_NAME = <name>)`, for both the location-unload and
+    // table-load forms. An unquoted identifier parses to a `Placeholder`.
+    for sql in [
+        "COPY INTO @my_stage/out.csv FROM (SELECT * FROM t) FILE_FORMAT = my_format",
+        "COPY INTO my_table FROM @my_stage FILE_FORMAT = my_format",
+    ] {
+        match snowflake()
+            .parse_sql_statements(sql)
+            .unwrap()
+            .pop()
+            .unwrap()
+        {
+            Statement::CopyIntoSnowflake { file_format, .. } => {
+                assert_eq!(
+                    file_format.options,
+                    vec![KeyValueOption {
+                        option_name: "FORMAT_NAME".to_string(),
+                        option_value: KeyValueOptionKind::Single(
+                            Value::Placeholder("my_format".to_string()).with_empty_span()
+                        ),
+                    }]
+                );
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    // A quoted name parses to a `SingleQuotedString`.
+    match snowflake()
+        .parse_sql_statements(
+            "COPY INTO @my_stage/out.csv FROM (SELECT * FROM t) FILE_FORMAT = 'my_format'",
+        )
+        .unwrap()
+        .pop()
+        .unwrap()
+    {
+        Statement::CopyIntoSnowflake { file_format, .. } => {
+            assert_eq!(
+                file_format.options,
+                vec![KeyValueOption {
+                    option_name: "FORMAT_NAME".to_string(),
+                    option_value: KeyValueOptionKind::Single(
+                        Value::SingleQuotedString("my_format".to_string()).with_empty_span()
+                    ),
+                }]
+            );
+        }
+        _ => unreachable!(),
+    }
+
+    // The parenthesized form is unaffected.
+    match snowflake()
+        .parse_sql_statements(
+            "COPY INTO @my_stage/out.csv FROM (SELECT * FROM t) FILE_FORMAT = (TYPE = 'CSV')",
+        )
+        .unwrap()
+        .pop()
+        .unwrap()
+    {
+        Statement::CopyIntoSnowflake { file_format, .. } => {
+            assert_eq!(
+                file_format.options,
+                vec![KeyValueOption {
+                    option_name: "TYPE".to_string(),
+                    option_value: KeyValueOptionKind::Single(
+                        Value::SingleQuotedString("CSV".to_string()).with_empty_span()
+                    ),
+                }]
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn test_copy_into_copy_options() {
     let sql = concat!(