Refactor: replace dialect_of! table partition check with Dialect trait method

src/dialect/generic.rs

@@ -285,6 +285,10 @@ impl Dialect for GenericDialect {
         true
     }
 
+    fn supports_table_partitions(&self) -> bool {
+        true
+    }
+
     fn supports_select_format(&self) -> bool {
         true
     }

src/dialect/mod.rs

@@ -1764,6 +1764,19 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if this dialect supports the `PARTITION` clause on a table factor,
+    /// restricting a query to an explicit list of partitions.
+    ///
+    /// Example:
+    /// ```sql
+    /// SELECT * FROM employees PARTITION (p0, p1)
+    /// ```
+    ///
+    /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/partitioning-selection.html)
+    fn supports_table_partitions(&self) -> bool {
+        false
+    }
+
     /// Returns true if this dialect supports the `FORMAT` clause in `SELECT` statements.
     ///
     /// Example:

src/dialect/mysql.rs

@@ -203,6 +203,11 @@ impl Dialect for MySqlDialect {
         true
     }
 
+    /// See: <https://dev.mysql.com/doc/refman/8.4/en/partitioning-selection.html>
+    fn supports_table_partitions(&self) -> bool {
+        true
+    }
+
     fn supports_comment_optimizer_hint(&self) -> bool {
         true
     }

src/parser/mod.rs

@@ -16753,7 +16753,7 @@ impl<'a> Parser<'a> {
                 _ => None,
             };
 
-            let partitions: Vec<Ident> = if dialect_of!(self is MySqlDialect | GenericDialect)
+            let partitions: Vec<Ident> = if self.dialect.supports_table_partitions()
                 && self.parse_keyword(Keyword::PARTITION)
             {
                 self.parse_parenthesized_identifiers()?

tests/sqlparser_custom_dialect.rs

@@ -156,6 +156,47 @@ fn test_map_syntax_not_support_default() -> Result<(), ParserError> {
     Ok(())
 }
 
+#[test]
+fn custom_dialect_supports_table_partitions() -> Result<(), ParserError> {
+    #[derive(Debug)]
+    struct MyDialect {}
+
+    impl Dialect for MyDialect {
+        fn is_identifier_start(&self, ch: char) -> bool {
+            is_identifier_start(ch)
+        }
+
+        fn is_identifier_part(&self, ch: char) -> bool {
+            is_identifier_part(ch)
+        }
+
+        fn supports_table_partitions(&self) -> bool {
+            true
+        }
+    }
+
+    let sql = "SELECT * FROM employees PARTITION (p0, p1)";
+    let ast = Parser::parse_sql(&MyDialect {}, sql)?;
+    assert_eq!(sql, &format!("{}", ast[0]));
+
+    // A dialect that does not opt in still rejects the clause.
+    #[derive(Debug)]
+    struct WithoutPartitions {}
+
+    impl Dialect for WithoutPartitions {
+        fn is_identifier_start(&self, ch: char) -> bool {
+            is_identifier_start(ch)
+        }
+
+        fn is_identifier_part(&self, ch: char) -> bool {
+            is_identifier_part(ch)
+        }
+    }
+
+    assert!(Parser::parse_sql(&WithoutPartitions {}, sql).is_err());
+    Ok(())
+}
+
 fn is_identifier_start(ch: char) -> bool {
     ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_'
 }