refactor by CR

Author: chunshao90

src/ast/query.rs

@@ -665,8 +665,8 @@ pub enum TableFactor {
         /// Optional version qualifier to facilitate table time-travel, as
         /// supported by BigQuery and MSSQL.
         version: Option<TableVersion>,
-        /// Partition selection, supported by MySQL.
-        partitions: Vec<Expr>,
+        /// [Partition selection](https://dev.mysql.com/doc/refman/8.0/en/partitioning-selection.html), supported by MySQL.
+        partitions: Vec<Ident>,
     },
     Derived {
         lateral: bool,

src/parser/mod.rs

@@ -6210,16 +6210,10 @@ impl<'a> Parser<'a> {
         } else {
             let name = self.parse_object_name()?;
 
-            let partitions = if dialect_of!(self is MySqlDialect)
+            let partitions: Vec<Ident> = if dialect_of!(self is MySqlDialect | GenericDialect)
                 && self.parse_keyword(Keyword::PARTITION)
             {
-                let mut partitions = self.parse_comma_separated(|p| p.parse_tuple(true, false))?;
-                if partitions.len() != 1 {
-                    return Err(ParserError::ParserError(format!(
-                        "Partition expect one tuple"
-                    )));
-                }
-                partitions.remove(0)
+                self.parse_partitions()?
             } else {
                 vec![]
             };
@@ -7430,6 +7424,37 @@ impl<'a> Parser<'a> {
             representation: UserDefinedTypeRepresentation::Composite { attributes },
         })
     }
+
+    fn parse_partitions(&mut self) -> Result<Vec<Ident>, ParserError> {
+        let mut partition_exprs: Vec<Expr> = self.parse_comma_separated(Parser::parse_expr)?;
+
+        if partition_exprs.len() == 1 {
+            match partition_exprs.remove(0) {
+                Expr::Tuple(exprs) => {
+                    let mut partitions: Vec<Ident> = Vec::with_capacity(exprs.len());
+                    for expr in exprs {
+                        match expr {
+                            Expr::Identifier(ident) => partitions.push(ident.clone()),
+                            _ => {
+                                return Err(ParserError::ParserError(
+                                    "Partition expect one identifier".to_string(),
+                                ));
+                            }
+                        }
+                    }
+                    return Ok(partitions);
+                }
+                _ => {
+                    return Err(ParserError::ParserError(
+                        "Partition expect one tuple".to_string(),
+                    ));
+                }
+            }
+        }
+         Err(ParserError::ParserError(
+            "Partition expect one tuple".to_string(),
+        ))
+    }
 }
 
 impl Word {
@@ -8065,13 +8090,7 @@ mod tests {
                 if let TableFactor::Table { partitions, .. } = table_factor {
                     let actual: Vec<&str> = partitions
                         .iter()
-                        .map(|expr| {
-                            if let Expr::Identifier(ident) = &expr {
-                                ident.value.as_str()
-                            } else {
-                                ""
-                            }
-                        })
+                        .map(|ident| ident.value.as_str())
                         .collect();
                     assert_eq!(expected, actual);
                 }