fix(Snowflake): Enhance parity for FILE_FORMAT & CREDENTIALS in CREATE STAGE (#4969)

* feat(Snowflake): enhance parity for FILE_FORMAT in CREATE STAGE

* minor fix

* add support for CREDENTIALS property in CREATE STAGE expressions

* address review comments

* move credentialsproperty_sql into base Generator

* address more review comments

* minor refactoring

Author: whummer

sqlglot/dialects/snowflake.py

@@ -516,6 +516,7 @@ class Parser(parser.Parser):
 
         PROPERTY_PARSERS = {
             **parser.Parser.PROPERTY_PARSERS,
+            "CREDENTIALS": lambda self: self._parse_credentials_property(),
             "FILE_FORMAT": lambda self: self._parse_file_format_property(),
             "LOCATION": lambda self: self._parse_location_property(),
             "TAG": lambda self: self._parse_tag(),
@@ -903,8 +904,20 @@ def _parse_foreign_key(self) -> exp.ForeignKey:
 
         def _parse_file_format_property(self) -> exp.FileFormatProperty:
             self._match(TokenType.EQ)
+            if self._match(TokenType.L_PAREN, advance=False):
+                expressions = self._parse_wrapped_options()
+            else:
+                expressions = [self._parse_format_name()]
+
             return self.expression(
-                exp.FileFormatProperty, expressions=self._parse_wrapped_options()
+                exp.FileFormatProperty,
+                expressions=expressions,
+            )
+
+        def _parse_credentials_property(self) -> exp.CredentialsProperty:
+            return self.expression(
+                exp.CredentialsProperty,
+                expressions=self._parse_wrapped_options(),
             )
 
     class Tokenizer(tokens.Tokenizer):
@@ -1107,8 +1120,9 @@ class Generator(generator.Generator):
 
         PROPERTIES_LOCATION = {
             **generator.Generator.PROPERTIES_LOCATION,
-            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
+            exp.CredentialsProperty: exp.Properties.Location.POST_WITH,
             exp.LocationProperty: exp.Properties.Location.POST_WITH,
+            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
             exp.SetProperty: exp.Properties.Location.UNSUPPORTED,
             exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
         }

sqlglot/expressions.py

@@ -2789,6 +2789,10 @@ class FileFormatProperty(Property):
     arg_types = {"this": False, "expressions": False}
 
 
+class CredentialsProperty(Property):
+    arg_types = {"expressions": True}
+
+
 class FreespaceProperty(Property):
     arg_types = {"this": True, "percent": False}
 
@@ -3134,6 +3138,7 @@ class Properties(Expression):
         "CLUSTERED_BY": ClusteredByProperty,
         "COLLATE": CollateProperty,
         "COMMENT": SchemaCommentProperty,
+        "CREDENTIALS": CredentialsProperty,
         "DEFINER": DefinerProperty,
         "DISTKEY": DistKeyProperty,
         "DISTRIBUTED_BY": DistributedByProperty,

sqlglot/generator.py

@@ -132,6 +132,8 @@ class Generator(metaclass=_Generator):
         exp.CommentColumnConstraint: lambda self, e: f"COMMENT {self.sql(e, 'this')}",
         exp.ConnectByRoot: lambda self, e: f"CONNECT_BY_ROOT {self.sql(e, 'this')}",
         exp.CopyGrantsProperty: lambda *_: "COPY GRANTS",
+        exp.CredentialsProperty: lambda self,
+        e: f"CREDENTIALS=({self.expressions(e, 'expressions', sep=' ')})",
         exp.DateFormatColumnConstraint: lambda self, e: f"FORMAT {self.sql(e, 'this')}",
         exp.DefaultColumnConstraint: lambda self, e: f"DEFAULT {self.sql(e, 'this')}",
         exp.DynamicProperty: lambda *_: "DYNAMIC",

sqlglot/parser.py

@@ -7966,17 +7966,19 @@ def _parse_wrapped_options(self) -> t.List[t.Optional[exp.Expression]]:
         self._match(TokenType.L_PAREN)
 
         opts: t.List[t.Optional[exp.Expression]] = []
+        option: exp.Expression | None
         while self._curr and not self._match(TokenType.R_PAREN):
             if self._match_text_seq("FORMAT_NAME", "="):
                 # The FORMAT_NAME can be set to an identifier for Snowflake and T-SQL
-                prop = self.expression(
-                    exp.Property, this=exp.var("FORMAT_NAME"), value=self._parse_table_parts()
-                )
-                opts.append(prop)
+                option = self._parse_format_name()
             else:
-                opts.append(self._parse_property())
+                option = self._parse_property()
 
-            self._match(TokenType.COMMA)
+            if option is None:
+                self.raise_error("Unable to parse option")
+                break
+
+            opts.append(option)
 
         return opts
 
@@ -8167,3 +8169,12 @@ def _parse_overlay(self) -> exp.Overlay:
                 "for": self._match_text_seq("FOR") and self._parse_bitwise(),
             },
         )
+
+    def _parse_format_name(self) -> exp.Property:
+        # Note: Although not specified in the docs, Snowflake does accept a string/identifier
+        # for FILE_FORMAT = <format_name>
+        return self.expression(
+            exp.Property,
+            this=exp.var("FORMAT_NAME"),
+            value=self._parse_string() or self._parse_table_parts(),
+        )

tests/dialects/test_snowflake.py

@@ -1,6 +1,6 @@
 from unittest import mock
 
-from sqlglot import UnsupportedError, exp, parse_one
+from sqlglot import UnsupportedError, exp, parse_one, ParseError
 from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
 from sqlglot.optimizer.qualify_columns import quote_identifiers
 from tests.dialects.test_dialect import Validator
@@ -1484,6 +1484,21 @@ def test_ddl(self):
         self.validate_identity(
             "CREATE TEMPORARY STAGE stage1 FILE_FORMAT=(TYPE=PARQUET)"
         ).this.assert_is(exp.Table)
+        self.validate_identity(
+            "CREATE STAGE stage1 FILE_FORMAT='format1'",
+            "CREATE STAGE stage1 FILE_FORMAT=(FORMAT_NAME='format1')",
+        )
+        self.validate_identity("CREATE STAGE stage1 FILE_FORMAT=(FORMAT_NAME=stage1.format1)")
+        self.validate_identity("CREATE STAGE stage1 FILE_FORMAT=(FORMAT_NAME='stage1.format1')")
+        self.validate_identity(
+            "CREATE STAGE stage1 FILE_FORMAT=schema1.format1",
+            "CREATE STAGE stage1 FILE_FORMAT=(FORMAT_NAME=schema1.format1)",
+        )
+        with self.assertRaises(ParseError):
+            self.parse_one("CREATE STAGE stage1 FILE_FORMAT=123", dialect="snowflake")
+        self.validate_identity(
+            "CREATE STAGE s1 URL='s3://bucket-123' FILE_FORMAT=(TYPE='JSON') CREDENTIALS=(aws_key_id='test' aws_secret_key='test')"
+        )
         self.validate_identity(
             "CREATE OR REPLACE TAG IF NOT EXISTS cost_center COMMENT='cost_center tag'"
         ).this.assert_is(exp.Identifier)