Snowflake: Support dollar quoted comments

src/dialect/snowflake.rs

@@ -245,6 +245,14 @@ impl Dialect for SnowflakeDialect {
                     .map(|p| Some(ColumnOption::Policy(ColumnPolicy::ProjectionPolicy(p)))))
             } else if parser.parse_keywords(&[Keyword::TAG]) {
                 Ok(parse_column_tags(parser, with).map(|p| Some(ColumnOption::Tags(p))))
+            } else if parser.parse_keywords(&[Keyword::COMMENT]) {
+                let next_token = parser.next_token();
+                match next_token.token {
+                    Token::DollarQuotedString(value, ..) => {
+                        Ok(Ok(Some(ColumnOption::Comment(value.value))))
+                    }
+                    _ => Err(ParserError::ParserError("not found match".to_string())),
+                }
             } else {
                 Err(ParserError::ParserError("not found match".to_string()))
             }
@@ -422,7 +430,7 @@ pub fn parse_create_table(
                 Keyword::COMMENT => {
                     // Rewind the COMMENT keyword
                     parser.prev_token();
-                    builder = builder.comment(parser.parse_optional_inline_comment()?);
+                    builder = builder.comment(parser.parse_optional_inline_comment(true)?);
                 }
                 Keyword::AS => {
                     let query = parser.parse_query()?;
@@ -646,6 +654,7 @@ pub fn parse_create_stage(
         parser.expect_token(&Token::Eq)?;
         comment = Some(match parser.next_token().token {
             Token::SingleQuotedString(word) => Ok(word),
+            Token::DollarQuotedString(word) => Ok(word.value),
             _ => parser.expected("a comment statement", parser.peek_token()),
         }?)
     }

src/parser/mod.rs

@@ -5323,6 +5323,7 @@ impl<'a> Parser<'a> {
             let next_token = self.next_token();
             match next_token.token {
                 Token::SingleQuotedString(str) => Some(str),
+                Token::DollarQuotedString(str) => Some(str.value),
                 _ => self.expected("string literal", next_token)?,
             }
         } else {
@@ -5764,7 +5765,7 @@ impl<'a> Parser<'a> {
             None
         };
 
-        let comment = self.parse_optional_inline_comment()?;
+        let comment = self.parse_optional_inline_comment(false)?;
 
         let with_dcproperties =
             match self.parse_options_with_keywords(&[Keyword::WITH, Keyword::DCPROPERTIES])? {
@@ -6821,7 +6822,8 @@ impl<'a> Parser<'a> {
         if !dialect_of!(self is HiveDialect) && self.parse_keyword(Keyword::COMMENT) {
             // rewind the COMMENT keyword
             self.prev_token();
-            comment = self.parse_optional_inline_comment()?
+            let support_dollar_quoted_comment = dialect_of!(self is SnowflakeDialect);
+            comment = self.parse_optional_inline_comment(support_dollar_quoted_comment)?
         };
 
         // Parse optional `AS ( query )`
@@ -6922,18 +6924,23 @@ impl<'a> Parser<'a> {
         })
     }
 
-    pub fn parse_optional_inline_comment(&mut self) -> Result<Option<CommentDef>, ParserError> {
+    pub fn parse_optional_inline_comment(
+        &mut self,
+        support_dollar_quoted_comment: bool,
+    ) -> Result<Option<CommentDef>, ParserError> {
         let comment = if self.parse_keyword(Keyword::COMMENT) {
             let has_eq = self.consume_token(&Token::Eq);
             let next_token = self.next_token();
-            match next_token.token {
-                Token::SingleQuotedString(str) => Some(if has_eq {
-                    CommentDef::WithEq(str)
-                } else {
-                    CommentDef::WithoutEq(str)
-                }),
+            let comment = match next_token.token {
+                Token::SingleQuotedString(str) => str,
+                Token::DollarQuotedString(str) if support_dollar_quoted_comment => str.value,
                 _ => self.expected("comment", next_token)?,
-            }
+            };
+            Some(if has_eq {
+                CommentDef::WithEq(comment)
+            } else {
+                CommentDef::WithoutEq(comment)
+            })
         } else {
             None
         };

tests/sqlparser_snowflake.rs

@@ -976,6 +976,27 @@ fn parse_sf_create_or_replace_with_comment_for_snowflake() {
     }
 }
 
+#[test]
+fn parse_sf_create_table_or_view_with_dollar_quoted_comment() {
+    assert!(snowflake()
+        .parse_sql_statements(
+            r#"CREATE OR REPLACE TEMPORARY VIEW foo.bar.baz (
+            "COL_1" COMMENT $$comment 1$$
+        ) COMMENT = $$view comment$$ AS (
+            SELECT 1
+        )"#
+        )
+        .is_ok());
+
+    assert!(snowflake()
+        .parse_sql_statements(
+            r#"CREATE TABLE my_table (
+            a STRING COMMENT $$comment 1$$
+        ) COMMENT = $$table comment$$"#
+        )
+        .is_ok());
+}
+
 #[test]
 fn test_sf_derived_table_in_parenthesis() {
     // Nesting a subquery in an extra set of parentheses is non-standard,