MySQL: CREATE INDEX: allow USING clause before ON

src/ast/ddl.rs

@@ -2361,6 +2361,8 @@ pub struct CreateIndex {
     pub name: Option<ObjectName>,
     #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
     pub table_name: ObjectName,
+    /// Index type used in the statement. Can also be found inside [`CreateIndex::index_options`]
+    /// depending on the position of the option within the statement.
     pub using: Option<IndexType>,
     pub columns: Vec<IndexColumn>,
     pub unique: bool,

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()?;
 
@@ -7118,6 +7123,15 @@ impl<'a> Parser<'a> {
         // parse it anyway (as we do inside `ALTER TABLE` and `CREATE TABLE` parsing).
         let index_options = self.parse_index_options()?;
 
+        // Only keep the latest USING, we don't take the IndexOption out of the vec and place the
+        // value in the `using` var because we try to keep the order of the options as they appear.
+        if index_options
+            .iter()
+            .any(|opt| matches!(opt, IndexOption::Using(_)))
+        {
+            using = None;
+        };
+
         // MySQL allows `ALGORITHM` and `LOCK` options. Unlike in `ALTER TABLE`, they need not be comma separated.
         let mut alter_options = Vec::new();
         while self

tests/sqlparser_common.rs

@@ -17246,3 +17246,46 @@ fn parse_invisible_column() {
         _ => panic!("Unexpected statement {stmt}"),
     }
 }
+
+#[test]
+fn parse_create_index_different_using_positions() {
+    let sql = "CREATE INDEX idx_name USING BTREE ON table_name (col1)";
+    let expected = "CREATE INDEX idx_name ON table_name USING BTREE (col1)";
+    match all_dialects().one_statement_parses_to(sql, expected) {
+        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!(),
+    }
+
+    let sql = "CREATE INDEX idx_name USING BTREE ON table_name (col1) USING HASH";
+    let expected = "CREATE INDEX idx_name ON table_name(col1) USING HASH";
+    match all_dialects().one_statement_parses_to(sql, expected) {
+        Statement::CreateIndex(CreateIndex {
+            name,
+            table_name,
+            columns,
+            index_options,
+            ..
+        }) => {
+            assert_eq!(name.unwrap().to_string(), "idx_name");
+            assert_eq!(table_name.to_string(), "table_name");
+            assert_eq!(columns.len(), 1);
+            assert!(index_options
+                .iter()
+                .any(|o| o == &IndexOption::Using(IndexType::Hash)));
+        }
+        _ => unreachable!(),
+    }
+}