Modify the code according to the recommendations and add more test cases

Author: wugeer

src/dialect/mod.rs

@@ -590,6 +590,16 @@ pub trait Dialect: Debug + Any {
     fn supports_try_convert(&self) -> bool {
         false
     }
+
+    /// Returns true if the dialect supports `listen` clause
+    fn supports_listen_clause(&self) -> bool {
+        false
+    }
+
+    /// Returns true if the dialect supports `notify` clause
+    fn supports_notify_clause(&self) -> bool {
+        false
+    }
 }
 
 /// This represents the operators for which precedence must be defined

src/dialect/postgresql.rs

@@ -191,6 +191,16 @@ impl Dialect for PostgreSqlDialect {
     fn supports_explain_with_utility_options(&self) -> bool {
         true
     }
+
+    /// see <https://www.postgresql.org/docs/current/sql-listen.html>
+    fn supports_listen_clause(&self) -> bool {
+        true
+    }
+
+    /// see <https://www.postgresql.org/docs/current/sql-notify.html>
+    fn supports_notify_clause(&self) -> bool {
+        true
+    }
 }
 
 pub fn parse_comment(parser: &mut Parser) -> Result<Statement, ParserError> {

src/parser/mod.rs

@@ -534,12 +534,8 @@ impl<'a> Parser<'a> {
                 Keyword::MERGE => self.parse_merge(),
                 // `LISTEN` and `NOTIFY` are Postgres-specific
                 // syntaxes. They are used for Postgres statement.
-                Keyword::LISTEN if dialect_of!(self is PostgreSqlDialect | GenericDialect) => {
-                    self.parse_listen()
-                }
-                Keyword::NOTIFY if dialect_of!(self is PostgreSqlDialect | GenericDialect) => {
-                    self.parse_notify()
-                }
+                Keyword::LISTEN if self.dialect.supports_listen_clause() => self.parse_listen(),
+                Keyword::NOTIFY if self.dialect.supports_notify_clause() => self.parse_notify(),
                 // `PRAGMA` is sqlite specific https://www.sqlite.org/pragma.html
                 Keyword::PRAGMA => self.parse_pragma(),
                 Keyword::UNLOAD => self.parse_unload(),

tests/sqlparser_common.rs

@@ -11460,3 +11460,79 @@ fn test_try_convert() {
         all_dialects_where(|d| d.supports_try_convert() && !d.convert_type_before_value());
     dialects.verified_expr("TRY_CONVERT('foo', VARCHAR(MAX))");
 }
+
+#[test]
+fn parse_listen_channel() {
+    let dialects = all_dialects_where(|d| d.supports_listen_clause());
+
+    match dialects.verified_stmt("LISTEN test1") {
+        Statement::LISTEN { channel } => {
+            assert_eq!(Ident::new("test1"), channel);
+        }
+        _ => unreachable!(),
+    };
+
+    assert_eq!(
+        dialects.parse_sql_statements("LISTEN *").unwrap_err(),
+        ParserError::ParserError("Expected: identifier, found: *".to_string())
+    );
+
+    let dialects = all_dialects_where(|d| !d.supports_listen_clause());
+
+    assert_eq!(
+        dialects.parse_sql_statements("LISTEN test1").unwrap_err(),
+        ParserError::ParserError("Expected: an SQL statement, found: LISTEN".to_string())
+    );
+}
+
+#[test]
+fn parse_notify_channel() {
+    let dialects = all_dialects_where(|d| d.supports_notify_clause());
+
+    match dialects.verified_stmt("NOTIFY test1") {
+        Statement::NOTIFY { channel, payload } => {
+            assert_eq!(Ident::new("test1"), channel);
+            assert_eq!(payload, None);
+        }
+        _ => unreachable!(),
+    };
+
+    match dialects.verified_stmt("NOTIFY test1, 'this is a test notification'") {
+        Statement::NOTIFY {
+            channel,
+            payload: Some(payload),
+        } => {
+            assert_eq!(Ident::new("test1"), channel);
+            assert_eq!("this is a test notification", payload);
+        }
+        _ => unreachable!(),
+    };
+
+    assert_eq!(
+        dialects.parse_sql_statements("NOTIFY *").unwrap_err(),
+        ParserError::ParserError("Expected: identifier, found: *".to_string())
+    );
+    assert_eq!(
+        dialects
+            .parse_sql_statements("NOTIFY test1, *")
+            .unwrap_err(),
+        ParserError::ParserError("Expected: literal string, found: *".to_string())
+    );
+
+    let sql_statements = [
+        "NOTIFY test1",
+        "NOTIFY test1, 'this is a test notification'",
+    ];
+    let dialects = all_dialects_where(|d| !d.supports_notify_clause());
+
+    for &sql in &sql_statements {
+        assert_eq!(
+            dialects.parse_sql_statements(sql).unwrap_err(),
+            ParserError::ParserError("Expected: an SQL statement, found: NOTIFY".to_string())
+        );
+        assert_eq!(
+            dialects.parse_sql_statements(sql).unwrap_err(),
+            ParserError::ParserError("Expected: an SQL statement, found: NOTIFY".to_string())
+        );
+    }
+}

tests/sqlparser_postgres.rs

@@ -5157,34 +5157,3 @@ fn parse_create_type_as_enum() {
         _ => unreachable!(),
     }
 }
-
-#[test]
-fn parse_listen_channel() {
-    match pg_and_generic().verified_stmt("LISTEN test1") {
-        Statement::LISTEN { channel } => {
-            assert_eq!(Ident::new("test1"), channel);
-        }
-        _ => unreachable!(),
-    }
-}
-
-#[test]
-fn parse_notify_channel() {
-    match pg_and_generic().verified_stmt("NOTIFY test1") {
-        Statement::NOTIFY { channel, payload } => {
-            assert_eq!(Ident::new("test1"), channel);
-            assert_eq!(payload, None);
-        }
-        _ => unreachable!(),
-    }
-    match pg_and_generic().verified_stmt("NOTIFY test1, 'this is a test notification'") {
-        Statement::NOTIFY {
-            channel,
-            payload: Some(payload),
-        } => {
-            assert_eq!(Ident::new("test1"), channel);
-            assert_eq!("this is a test notification", payload);
-        }
-        _ => unreachable!(),
-    }
-}