feat: support mysql charset

imotai · imotai · commit 9a04d232c7c0 · 2022-03-30T15:28:05.000+08:00
diff --git a/src/ast/data_type.rs b/src/ast/data_type.rs
@@ -25,10 +25,10 @@ use super::value::escape_single_quote_string;
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum DataType {
-    /// Fixed-length character type e.g. CHAR(10)
-    Char(Option<u64>),
+    /// Fixed-length character type e.g. CHAR(10), CHAR CHARACTER set utf8mb4
+    Char(Option<u64>, Option<String>),
     /// Variable-length character type e.g. VARCHAR(10)
-    Varchar(Option<u64>),
+    Varchar(Option<u64>, Option<String>),
     /// Uuid type
     Uuid,
     /// Large character object e.g. CLOB(1000)
@@ -94,8 +94,8 @@ pub enum DataType {
 impl fmt::Display for DataType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            DataType::Char(size) => format_type_with_optional_length(f, "CHAR", size, false),
-            DataType::Varchar(size) => {
+            DataType::Char(size, _) => format_type_with_optional_length(f, "CHAR", size, false),
+            DataType::Varchar(size, _) => {
                 format_type_with_optional_length(f, "CHARACTER VARYING", size, false)
             }
             DataType::Uuid => write!(f, "UUID"),
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -240,6 +240,7 @@ pub enum Expr {
     Cast {
         expr: Box<Expr>,
         data_type: DataType,
+        collation: Option<String>,
     },
     /// TRY_CAST an expression to a different data type e.g. `TRY_CAST(foo AS VARCHAR(123))`
     //  this differs from CAST in the choice of how to implement invalid conversions
@@ -396,7 +397,9 @@ impl fmt::Display for Expr {
                     write!(f, "{} {}", op, expr)
                 }
             }
-            Expr::Cast { expr, data_type } => write!(f, "CAST({} AS {})", expr, data_type),
+            Expr::Cast {
+                expr, data_type, ..
+            } => write!(f, "CAST({} AS {})", expr, data_type),
             Expr::TryCast { expr, data_type } => write!(f, "TRY_CAST({} AS {})", expr, data_type),
             Expr::Extract { field, expr } => write!(f, "EXTRACT({} FROM {})", field, expr),
             Expr::Collate { expr, collation } => write!(f, "{} COLLATE {}", expr, collation),
diff --git a/src/parser.rs b/src/parser.rs
@@ -740,9 +740,19 @@ impl<'a> Parser<'a> {
         self.expect_keyword(Keyword::AS)?;
         let data_type = self.parse_data_type()?;
         self.expect_token(&Token::RParen)?;
+        let collation = if self.parse_keywords(&[Keyword::COLLATE]) {
+            match self.next_token() {
+                Token::Word(w) => Some(w.value),
+                unexpected => self.expected("identifier", unexpected)?,
+            }
+        } else {
+            None
+        };
+
         Ok(Expr::Cast {
             expr: Box::new(expr),
             data_type,
+            collation,
         })
     }
 
@@ -1240,6 +1250,7 @@ impl<'a> Parser<'a> {
         Ok(Expr::Cast {
             expr: Box::new(expr),
             data_type: self.parse_data_type()?,
+            collation: None,
         })
     }
 
@@ -2430,12 +2441,19 @@ impl<'a> Parser<'a> {
                         Ok(DataType::BigInt(optional_precision?))
                     }
                 }
-                Keyword::VARCHAR => Ok(DataType::Varchar(self.parse_optional_precision()?)),
+                Keyword::VARCHAR => Ok(DataType::Varchar(self.parse_optional_precision()?, None)),
                 Keyword::CHAR | Keyword::CHARACTER => {
-                    if self.parse_keyword(Keyword::VARYING) {
-                        Ok(DataType::Varchar(self.parse_optional_precision()?))
-                    } else {
-                        Ok(DataType::Char(self.parse_optional_precision()?))
+                    let is_var = self.parse_keyword(Keyword::VARYING);
+                    let precision = self.parse_optional_precision()?;
+                    let mut charset: Option<String> = None;
+                    // handle CAST('test' AS CHAR CHARACTER SET utf8mb4);
+                    if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) {
+                        let name = self.parse_identifier()?;
+                        charset = Some(name.value);
+                    }
+                    match is_var {
+                        true => Ok(DataType::Varchar(precision, charset)),
+                        _ => Ok(DataType::Char(precision, charset)),
                     }
                 }
                 Keyword::UUID => Ok(DataType::Uuid),
