feat: add support for postgresql comment keyword

Author: zhamlin

src/ast/mod.rs

@@ -604,6 +604,22 @@ impl fmt::Display for ShowCreateObject {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum CommentObject {
+    Column,
+    Table,
+}
+
+impl fmt::Display for CommentObject {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            CommentObject::Column => f.write_str("COLUMN"),
+            CommentObject::Table => f.write_str("TABLE"),
+        }
+    }
+}
+
 /// A top-level statement (SELECT, INSERT, CREATE, etc.)
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -791,6 +807,14 @@ pub enum Statement {
         snapshot: Option<Value>,
         session: bool,
     },
+    /// `COMMENT ON ...`
+    ///
+    /// Note: this is a PostgreSQL-specific statement.
+    Comment {
+        object_type: CommentObject,
+        object_name: ObjectName,
+        comment: Option<String>,
+    },
     /// `COMMIT [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ]`
     Commit { chain: bool },
     /// `ROLLBACK [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ]`
@@ -1471,6 +1495,21 @@ impl fmt::Display for Statement {
                 }
                 write!(f, "AS {}", statement)
             }
+            Statement::Comment {
+                object_type,
+                object_name,
+                comment,
+            } => write!(
+                f,
+                "COMMENT ON {} {} IS {}",
+                object_type,
+                object_name,
+                if let Some(c) = comment {
+                    format!("'{}'", c)
+                } else {
+                    "NULL".to_string()
+                }
+            ),
         }
     }
 }

src/keywords.rs

@@ -128,6 +128,7 @@ define_keywords!(
     COLLECT,
     COLUMN,
     COLUMNS,
+    COMMENT,
     COMMIT,
     COMMITTED,
     COMPUTE,

src/parser.rs

@@ -175,6 +175,9 @@ impl<'a> Parser<'a> {
                     self.prev_token();
                     Ok(self.parse_insert()?)
                 }
+                Keyword::COMMENT if dialect_of!(self is PostgreSqlDialect) => {
+                    Ok(self.parse_comment()?)
+                }
                 _ => self.expected("an SQL statement", Token::Word(w)),
             },
             Token::LParen => {
@@ -3511,6 +3514,35 @@ impl<'a> Parser<'a> {
             statement,
         })
     }
+
+    fn parse_comment(&mut self) -> Result<Statement, ParserError> {
+        self.expect_keyword(Keyword::ON)?;
+        let token = self.next_token();
+
+        let (object_type, object_name) = match token {
+            Token::Word(w) if w.keyword == Keyword::COLUMN => {
+                let object_name = self.parse_object_name()?;
+                (CommentObject::Column, object_name)
+            }
+            Token::Word(w) if w.keyword == Keyword::TABLE => {
+                let object_name = self.parse_object_name()?;
+                (CommentObject::Table, object_name)
+            }
+            _ => self.expected("comment object_type", token)?,
+        };
+
+        self.expect_keyword(Keyword::IS)?;
+        let comment = if self.parse_keyword(Keyword::NULL) {
+            None
+        } else {
+            Some(self.parse_literal_string()?)
+        };
+        Ok(Statement::Comment {
+            object_type,
+            object_name,
+            comment,
+        })
+    }
 }
 
 impl Word {

tests/sqlparser_postgres.rs

@@ -749,6 +749,47 @@ fn test_transaction_statement() {
     );
 }
 
+#[test]
+fn parse_comments() {
+    match pg().verified_stmt("COMMENT ON COLUMN tab.name IS 'comment'") {
+        Statement::Comment {
+            object_type,
+            object_name,
+            comment: Some(comment),
+        } => {
+            assert_eq!("comment", comment);
+            assert_eq!("tab.name", object_name.to_string());
+            assert_eq!(CommentObject::Column, object_type);
+        }
+        _ => unreachable!(),
+    }
+
+    match pg().verified_stmt("COMMENT ON TABLE public.tab IS 'comment'") {
+        Statement::Comment {
+            object_type,
+            object_name,
+            comment: Some(comment),
+        } => {
+            assert_eq!("comment", comment);
+            assert_eq!("public.tab", object_name.to_string());
+            assert_eq!(CommentObject::Table, object_type);
+        }
+        _ => unreachable!(),
+    }
+
+    match pg().verified_stmt("COMMENT ON TABLE public.tab IS NULL") {
+        Statement::Comment {
+            object_type,
+            object_name,
+            comment: None,
+        } => {
+            assert_eq!("public.tab", object_name.to_string());
+            assert_eq!(CommentObject::Table, object_type);
+        }
+        _ => unreachable!(),
+    }
+}
+
 fn pg() -> TestedDialects {
     TestedDialects {
         dialects: vec![Box::new(PostgreSqlDialect {})],