MySQL: Parse USING index type before PRIMARY KEY and UNIQUE columns

fuzz/fuzz_seeds/mysql_2739_key_using_before_columns.sql

@@ -0,0 +1 @@
+CREATE TABLE t (id INT, PRIMARY KEY USING BTREE (id), UNIQUE USING HASH (id))

src/parser/mod.rs

@@ -10586,7 +10586,7 @@ impl<'a> Parser<'a> {
                 let nulls_distinct = self.parse_optional_nulls_distinct()?;
 
                 // optional index name
-                let index_name = self.parse_optional_ident()?;
+                let index_name = self.parse_optional_index_name()?;
                 let index_type = self.parse_optional_using_then_index_type()?;
 
                 let columns = self.parse_parenthesized_index_column_list()?;
@@ -10621,7 +10621,7 @@ impl<'a> Parser<'a> {
                 }
 
                 // optional index name
-                let index_name = self.parse_optional_ident()?;
+                let index_name = self.parse_optional_index_name()?;
                 let index_type = self.parse_optional_using_then_index_type()?;
 
                 let columns = self.parse_parenthesized_index_column_list()?;
@@ -10702,10 +10702,7 @@ impl<'a> Parser<'a> {
             {
                 let display_as_key = w.keyword == Keyword::KEY;
 
-                let name = match &self.peek_token_ref().token {
-                    Token::Word(word) if word.keyword == Keyword::USING => None,
-                    _ => self.parse_optional_ident()?,
-                };
+                let name = self.parse_optional_index_name()?;
 
                 let index_type = self.parse_optional_using_then_index_type()?;
                 let columns = self.parse_parenthesized_index_column_list()?;
@@ -10972,6 +10969,15 @@ impl<'a> Parser<'a> {
         self.maybe_parse(|parser| parser.parse_identifier())
     }
 
+    /// Parse an optional index name, leaving a `USING` index type for the caller.
+    fn parse_optional_index_name(&mut self) -> Result<Option<Ident>, ParserError> {
+        if self.peek_keyword(Keyword::USING) {
+            Ok(None)
+        } else {
+            self.parse_optional_ident()
+        }
+    }
+
     #[must_use]
     /// Parse optional `KEY` or `INDEX` display tokens used in index/constraint declarations.
     pub fn parse_index_type_display(&mut self) -> KeyOrIndexDisplay {

tests/sqlparser_mysql.rs

@@ -5213,3 +5213,35 @@ fn parse_create_table_engine_name_quoting() {
     mysql_and_generic().verified_stmt("CREATE TABLE t (a INT) ENGINE = `InnoDB`");
     mysql_and_generic().verified_stmt("CREATE TABLE t (a INT) ENGINE = InnoDB");
 }
+
+#[test]
+fn parse_key_constraint_index_type_before_columns() {
+    for key in ["PRIMARY KEY", "UNIQUE", "UNIQUE KEY"] {
+        let sql = format!("CREATE TABLE t (id INT, {key} USING BTREE (id))");
+        let Statement::CreateTable(CreateTable { constraints, .. }) =
+            mysql_and_generic().verified_stmt(&sql)
+        else {
+            unreachable!()
+        };
+        let (index_name, index_type) = match &constraints[..] {
+            [TableConstraint::PrimaryKey(c)] => (&c.index_name, &c.index_type),
+            [TableConstraint::Unique(c)] => (&c.index_name, &c.index_type),
+            _ => unreachable!(),
+        };
+        assert_eq!(index_name, &None, "{sql}");
+        assert_eq!(index_type, &Some(IndexType::BTree), "{sql}");
+
+        mysql_and_generic().verified_stmt(&format!(
+            "ALTER TABLE t ADD CONSTRAINT c {key} USING HASH (id)"
+        ));
+
+        let sql = format!("CREATE TABLE t (id INT, {key} USING (id))");
+        assert_eq!(
+            mysql_and_generic().parse_sql_statements(&sql),
+            Err(ParserError::ParserError(
+                "Expected: identifier, found: (".to_string()
+            )),
+            "{sql}"
+        );
+    }
+}