Parse signed/unsigned integer data types correctly in MySQL CAST

MySQL doesn't have the same set of possible CAST types as for e.g.
column definitions. For example, it raises a syntax error for `CAST(1 AS
INTEGER SIGNED)` and instead expects `CAST(1 AS SIGNED INTEGER)`.

This patch takes a somewhat unfortunate route of 1) adding a boolean
flag that modifies the `parse_data_type` match expression, and 2)
storing whether it was parsed this way in the `Expr::Cast` AST node to
be used during formatting. Feedback and ideas for alternative approaches
are very welcome.

Closes #1589

Author: mvzink

src/ast/mod.rs

@@ -798,9 +798,15 @@ pub enum Expr {
         kind: CastKind,
         expr: Box<Expr>,
         data_type: DataType,
-        // Optional CAST(string_expression AS type FORMAT format_string_expression) as used by BigQuery
-        // https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#formatting_syntax
+        /// Optional CAST(string_expression AS type FORMAT format_string_expression) as used by [BigQuery]
+        ///
+        /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#formatting_syntax
         format: Option<CastFormat>,
+        /// Whether this was parsed as a [MySQL]-style cast, which has a different syntax for
+        /// `SIGNED/UNSIGNED INTEGER` casts.
+        ///
+        /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html#function_cast
+        mysql_style_int: bool,
     },
     /// AT a timestamp to a different timezone e.g. `FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00'`
     AtTimeZone {
@@ -1560,32 +1566,42 @@ impl fmt::Display for Expr {
                 expr,
                 data_type,
                 format,
-            } => match kind {
-                CastKind::Cast => {
-                    if let Some(format) = format {
-                        write!(f, "CAST({expr} AS {data_type} FORMAT {format})")
-                    } else {
-                        write!(f, "CAST({expr} AS {data_type})")
+                mysql_style_int,
+            } => {
+                let data_type = if *mysql_style_int && data_type == &DataType::BigInt(None) {
+                    "SIGNED".to_string()
+                } else if *mysql_style_int && data_type == &DataType::UnsignedBigInt(None) {
+                    "UNSIGNED".to_string()
+                } else {
+                    data_type.to_string()
+                };
+                match kind {
+                    CastKind::Cast => {
+                        if let Some(format) = format {
+                            write!(f, "CAST({expr} AS {data_type} FORMAT {format})")
+                        } else {
+                            write!(f, "CAST({expr} AS {data_type})")
+                        }
                     }
-                }
-                CastKind::TryCast => {
-                    if let Some(format) = format {
-                        write!(f, "TRY_CAST({expr} AS {data_type} FORMAT {format})")
-                    } else {
-                        write!(f, "TRY_CAST({expr} AS {data_type})")
+                    CastKind::TryCast => {
+                        if let Some(format) = format {
+                            write!(f, "TRY_CAST({expr} AS {data_type} FORMAT {format})")
+                        } else {
+                            write!(f, "TRY_CAST({expr} AS {data_type})")
+                        }
                     }
-                }
-                CastKind::SafeCast => {
-                    if let Some(format) = format {
-                        write!(f, "SAFE_CAST({expr} AS {data_type} FORMAT {format})")
-                    } else {
-                        write!(f, "SAFE_CAST({expr} AS {data_type})")
+                    CastKind::SafeCast => {
+                        if let Some(format) = format {
+                            write!(f, "SAFE_CAST({expr} AS {data_type} FORMAT {format})")
+                        } else {
+                            write!(f, "SAFE_CAST({expr} AS {data_type})")
+                        }
+                    }
+                    CastKind::DoubleColon => {
+                        write!(f, "{expr}::{data_type}")
                     }
                 }
-                CastKind::DoubleColon => {
-                    write!(f, "{expr}::{data_type}")
-                }
-            },
+            }
             Expr::Extract {
                 field,
                 syntax,

src/ast/spans.rs

@@ -1407,6 +1407,7 @@ impl Spanned for Expr {
                 expr,
                 data_type: _,
                 format: _,
+                mysql_style_int: _,
             } => expr.span(),
             Expr::AtTimeZone {
                 timestamp,

src/keywords.rs

@@ -790,6 +790,7 @@ define_keywords!(
     SHARE,
     SHARING,
     SHOW,
+    SIGNED,
     SIMILAR,
     SKIP,
     SLOW,

src/parser/mod.rs

@@ -2175,14 +2175,19 @@ impl<'a> Parser<'a> {
         self.expect_token(&Token::LParen)?;
         let expr = self.parse_expr()?;
         self.expect_keyword_is(Keyword::AS)?;
-        let data_type = self.parse_data_type()?;
+        let dialect = self.dialect;
+        let mysql_style_int = dialect_is!(dialect is MySqlDialect);
+        let data_type = self.parse_data_type_for_cast(mysql_style_int)?;
+        let mysql_style_int = mysql_style_int
+            && (data_type == DataType::BigInt(None) || data_type == DataType::UnsignedBigInt(None));
         let format = self.parse_optional_cast_format()?;
         self.expect_token(&Token::RParen)?;
         Ok(Expr::Cast {
             kind,
             expr: Box::new(expr),
             data_type,
             format,
+            mysql_style_int,
         })
     }
 
@@ -2884,7 +2889,7 @@ impl<'a> Parser<'a> {
             Some(self.parse_identifier()?)
         };
 
-        let (field_type, trailing_bracket) = self.parse_data_type_helper()?;
+        let (field_type, trailing_bracket) = self.parse_data_type_helper(false)?;
 
         Ok((
             StructField {
@@ -3401,6 +3406,7 @@ impl<'a> Parser<'a> {
                 expr: Box::new(expr),
                 data_type: self.parse_data_type()?,
                 format: None,
+                mysql_style_int: false,
             })
         } else if Token::ExclamationMark == *tok && self.dialect.supports_factorial_operator() {
             Ok(Expr::UnaryOp {
@@ -3641,6 +3647,7 @@ impl<'a> Parser<'a> {
             expr: Box::new(expr),
             data_type: self.parse_data_type()?,
             format: None,
+            mysql_style_int: false,
         })
     }
 
@@ -8793,7 +8800,16 @@ impl<'a> Parser<'a> {
 
     /// Parse a SQL datatype (in the context of a CREATE TABLE statement for example)
     pub fn parse_data_type(&mut self) -> Result<DataType, ParserError> {
-        let (ty, trailing_bracket) = self.parse_data_type_helper()?;
+        self.parse_data_type_for_cast(false)
+    }
+
+    /// Parse a SQL datatype, possibly in the context of a CAST expression, for which some dialects
+    /// (i.e. MySQL) have different syntax. See [`Expr::Cast::mysql_style_int`]
+    pub fn parse_data_type_for_cast(
+        &mut self,
+        mysql_style_int: bool,
+    ) -> Result<DataType, ParserError> {
+        let (ty, trailing_bracket) = self.parse_data_type_helper(mysql_style_int)?;
         if trailing_bracket.0 {
             return parser_err!(
                 format!("unmatched > after parsing data type {ty}"),
@@ -8806,6 +8822,7 @@ impl<'a> Parser<'a> {
 
     fn parse_data_type_helper(
         &mut self,
+        mysql_style_int: bool,
     ) -> Result<(DataType, MatchedTrailingBracket), ParserError> {
         let dialect = self.dialect;
         self.advance_token();
@@ -8832,7 +8849,7 @@ impl<'a> Parser<'a> {
                         ))
                     }
                 }
-                Keyword::TINYINT => {
+                Keyword::TINYINT if !mysql_style_int => {
                     let optional_precision = self.parse_optional_precision();
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::UnsignedTinyInt(optional_precision?))
@@ -8848,23 +8865,23 @@ impl<'a> Parser<'a> {
                         Ok(DataType::Int2(optional_precision?))
                     }
                 }
-                Keyword::SMALLINT => {
+                Keyword::SMALLINT if !mysql_style_int => {
                     let optional_precision = self.parse_optional_precision();
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::UnsignedSmallInt(optional_precision?))
                     } else {
                         Ok(DataType::SmallInt(optional_precision?))
                     }
                 }
-                Keyword::MEDIUMINT => {
+                Keyword::MEDIUMINT if !mysql_style_int => {
                     let optional_precision = self.parse_optional_precision();
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::UnsignedMediumInt(optional_precision?))
                     } else {
                         Ok(DataType::MediumInt(optional_precision?))
                     }
                 }
-                Keyword::INT => {
+                Keyword::INT if !mysql_style_int => {
                     let optional_precision = self.parse_optional_precision();
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::UnsignedInt(optional_precision?))
@@ -8893,15 +8910,15 @@ impl<'a> Parser<'a> {
                 Keyword::INT64 => Ok(DataType::Int64),
                 Keyword::INT128 => Ok(DataType::Int128),
                 Keyword::INT256 => Ok(DataType::Int256),
-                Keyword::INTEGER => {
+                Keyword::INTEGER if !mysql_style_int => {
                     let optional_precision = self.parse_optional_precision();
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::UnsignedInteger(optional_precision?))
                     } else {
                         Ok(DataType::Integer(optional_precision?))
                     }
                 }
-                Keyword::BIGINT => {
+                Keyword::BIGINT if !mysql_style_int => {
                     let optional_precision = self.parse_optional_precision();
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::UnsignedBigInt(optional_precision?))
@@ -9049,7 +9066,8 @@ impl<'a> Parser<'a> {
                         })?)
                     } else {
                         self.expect_token(&Token::Lt)?;
-                        let (inside_type, _trailing_bracket) = self.parse_data_type_helper()?;
+                        let (inside_type, _trailing_bracket) =
+                            self.parse_data_type_helper(mysql_style_int)?;
                         trailing_bracket = self.expect_closing_angle_bracket(_trailing_bracket)?;
                         Ok(DataType::Array(ArrayElemTypeDef::AngleBracket(Box::new(
                             inside_type,
@@ -9110,6 +9128,14 @@ impl<'a> Parser<'a> {
                     let columns = self.parse_returns_table_columns()?;
                     Ok(DataType::Table(columns))
                 }
+                Keyword::UNSIGNED if mysql_style_int => {
+                    let _integer = self.parse_keyword(Keyword::INTEGER);
+                    Ok(DataType::UnsignedBigInt(None))
+                }
+                Keyword::SIGNED if mysql_style_int => {
+                    let _integer = self.parse_keyword(Keyword::INTEGER);
+                    Ok(DataType::BigInt(None))
+                }
                 _ => {
                     self.prev_token();
                     let type_name = self.parse_object_name(false)?;