MySQL: allow USING clause before ON in CREATE INDEX

MySQL allows specifying the index type `USING index_type`
before the `ON` clause in `CREATE INDEX` statements.

This PR allows the `CREATE INDEX` parser to accept both
positions of the `USING` clause, regardless of the dialect.

docs: https://dev.mysql.com/doc/refman/8.4/en/create-index.html

Author: MohamedAbdeen21

src/parser/mod.rs

@@ -7061,19 +7061,24 @@ impl<'a> Parser<'a> {
     pub fn parse_create_index(&mut self, unique: bool) -> Result<Statement, ParserError> {
         let concurrently = self.parse_keyword(Keyword::CONCURRENTLY);
         let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
+
+        let mut using = None;
+
         let index_name = if if_not_exists || !self.parse_keyword(Keyword::ON) {
             let index_name = self.parse_object_name(false)?;
+            // MySQL allows `USING index_type` either before or after `ON table_name`
+            using = self.parse_optional_using_then_index_type()?;
             self.expect_keyword_is(Keyword::ON)?;
             Some(index_name)
         } else {
             None
         };
+
         let table_name = self.parse_object_name(false)?;
-        let using = if self.parse_keyword(Keyword::USING) {
-            Some(self.parse_index_type()?)
-        } else {
-            None
-        };
+
+        // MySQL allows having two `USING` clauses.
+        // In that case, the second clause overwrites the first.
+        using = self.parse_optional_using_then_index_type()?.or(using);
 
         let columns = self.parse_parenthesized_index_column_list()?;
 

tests/sqlparser_common.rs

@@ -17246,3 +17246,47 @@ fn parse_invisible_column() {
         _ => panic!("Unexpected statement {stmt}"),
     }
 }
+
+#[test]
+fn parse_create_index_using_before_on() {
+    let sql = "CREATE INDEX idx_name USING BTREE ON table_name (col1)";
+    // Can't use `verified_stmt` here as the USING will be placed after the `ON` clause
+    match all_dialects().parse_sql_statements(sql).unwrap()[0].clone() {
+        Statement::CreateIndex(CreateIndex {
+            name,
+            table_name,
+            using,
+            columns,
+            unique,
+            ..
+        }) => {
+            assert_eq!(name.unwrap().to_string(), "idx_name");
+            assert_eq!(table_name.to_string(), "table_name");
+            assert_eq!(using, Some(IndexType::BTree));
+            assert_eq!(columns.len(), 1);
+            assert!(!unique);
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn parse_create_index_using_multiple_clauses() {
+    let sql = "CREATE INDEX idx_name USING BTREE ON table_name USING HASH (col1)";
+    // Can't use `verified_stmt` here as the first USING will be ignored
+    match all_dialects().parse_sql_statements(sql).unwrap()[0].clone() {
+        Statement::CreateIndex(CreateIndex {
+            name,
+            table_name,
+            using,
+            columns,
+            ..
+        }) => {
+            assert_eq!(name.unwrap().to_string(), "idx_name");
+            assert_eq!(table_name.to_string(), "table_name");
+            assert_eq!(using, Some(IndexType::Hash));
+            assert_eq!(columns.len(), 1);
+        }
+        _ => unreachable!(),
+    }
+}