MySQL: Allow optional SIGNED suffix on integer data types

In MySQL, a data type like `INT(20) SIGNED` is equivalent to `INT(20)`.
In other dialects, this may be interpreted differently; e.g. in
Postgres, `SELECT 1::integer signed` indicates an alias of "signed". So
we parse the optional `SIGNED` suffix only on dialects that allow it (I
currently don't know of any other than MySQL).

Author: mvzink

src/dialect/generic.rs

@@ -100,6 +100,10 @@ impl Dialect for GenericDialect {
         true
     }
 
+    fn allow_optional_signed_suffix(&self) -> bool {
+        true
+    }
+
     fn supports_create_index_with_clause(&self) -> bool {
         true
     }

src/dialect/mod.rs

@@ -835,6 +835,11 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if this dialect allows an optional `SIGNED` suffix after integer data types.
+    fn allow_optional_signed_suffix(&self) -> bool {
+        false
+    }
+
     /// Returns true if this dialect allows dollar placeholders
     /// e.g. `SELECT $var` (SQLite)
     fn supports_dollar_placeholder(&self) -> bool {

src/dialect/mysql.rs

@@ -66,6 +66,10 @@ impl Dialect for MySqlDialect {
         Some('`')
     }
 
+    fn allow_optional_signed_suffix(&self) -> bool {
+        true
+    }
+
     // See https://dev.mysql.com/doc/refman/8.0/en/string-literals.html#character-escape-sequences
     fn supports_string_literal_backslash_escape(&self) -> bool {
         true

src/parser/mod.rs

@@ -9852,6 +9852,8 @@ impl<'a> Parser<'a> {
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::TinyIntUnsigned(optional_precision?))
                     } else {
+                        let _ = dialect.allow_optional_signed_suffix()
+                            && self.parse_keyword(Keyword::SIGNED);
                         Ok(DataType::TinyInt(optional_precision?))
                     }
                 }
@@ -9868,6 +9870,8 @@ impl<'a> Parser<'a> {
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::SmallIntUnsigned(optional_precision?))
                     } else {
+                        let _ = dialect.allow_optional_signed_suffix()
+                            && self.parse_keyword(Keyword::SIGNED);
                         Ok(DataType::SmallInt(optional_precision?))
                     }
                 }
@@ -9876,6 +9880,8 @@ impl<'a> Parser<'a> {
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::MediumIntUnsigned(optional_precision?))
                     } else {
+                        let _ = dialect.allow_optional_signed_suffix()
+                            && self.parse_keyword(Keyword::SIGNED);
                         Ok(DataType::MediumInt(optional_precision?))
                     }
                 }
@@ -9884,6 +9890,8 @@ impl<'a> Parser<'a> {
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::IntUnsigned(optional_precision?))
                     } else {
+                        let _ = dialect.allow_optional_signed_suffix()
+                            && self.parse_keyword(Keyword::SIGNED);
                         Ok(DataType::Int(optional_precision?))
                     }
                 }
@@ -9913,6 +9921,8 @@ impl<'a> Parser<'a> {
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::IntegerUnsigned(optional_precision?))
                     } else {
+                        let _ = dialect.allow_optional_signed_suffix()
+                            && self.parse_keyword(Keyword::SIGNED);
                         Ok(DataType::Integer(optional_precision?))
                     }
                 }
@@ -9921,6 +9931,8 @@ impl<'a> Parser<'a> {
                     if self.parse_keyword(Keyword::UNSIGNED) {
                         Ok(DataType::BigIntUnsigned(optional_precision?))
                     } else {
+                        let _ = dialect.allow_optional_signed_suffix()
+                            && self.parse_keyword(Keyword::SIGNED);
                         Ok(DataType::BigInt(optional_precision?))
                     }
                 }

tests/sqlparser_mysql.rs

@@ -1705,6 +1705,51 @@ fn parse_create_table_unsigned() {
     }
 }
 
+#[test]
+fn parse_create_table_signed() {
+    let sql = "CREATE TABLE foo (bar_tinyint TINYINT(3) SIGNED, bar_smallint SMALLINT(5) SIGNED, bar_mediumint MEDIUMINT(13) SIGNED, bar_int INT(11) SIGNED, bar_bigint BIGINT(20) SIGNED)";
+    let canonical = "CREATE TABLE foo (bar_tinyint TINYINT(3), bar_smallint SMALLINT(5), bar_mediumint MEDIUMINT(13), bar_int INT(11), bar_bigint BIGINT(20))";
+    match mysql().one_statement_parses_to(sql, canonical) {
+        Statement::CreateTable(CreateTable { name, columns, .. }) => {
+            assert_eq!(name.to_string(), "foo");
+            assert_eq!(
+                vec![
+                    ColumnDef {
+                        name: Ident::new("bar_tinyint"),
+                        data_type: DataType::TinyInt(Some(3)),
+                        options: vec![],
+                    },
+                    ColumnDef {
+                        name: Ident::new("bar_smallint"),
+                        data_type: DataType::SmallInt(Some(5)),
+                        options: vec![],
+                    },
+                    ColumnDef {
+                        name: Ident::new("bar_mediumint"),
+                        data_type: DataType::MediumInt(Some(13)),
+                        options: vec![],
+                    },
+                    ColumnDef {
+                        name: Ident::new("bar_int"),
+                        data_type: DataType::Int(Some(11)),
+                        options: vec![],
+                    },
+                    ColumnDef {
+                        name: Ident::new("bar_bigint"),
+                        data_type: DataType::BigInt(Some(20)),
+                        options: vec![],
+                    },
+                ],
+                columns
+            );
+        }
+        _ => unreachable!(),
+    }
+    all_dialects_except(|d| d.allow_optional_signed_suffix())
+        .run_parser_method(sql, |p| p.parse_statement())
+        .expect_err("SIGNED suffix should not be allowed");
+}
+
 #[test]
 fn parse_simple_insert() {
     let sql = r"INSERT INTO tasks (title, priority) VALUES ('Test Some Inserts', 1), ('Test Entry 2', 2), ('Test Entry 3', 3)";