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

@@ -6876,19 +6876,27 @@ 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_using_index_type_clause()?;
             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
-        };
+
+        if let Some(second_using) = self.parse_using_index_type_clause()? {
+            if using.is_some() {
+                return Err(ParserError::ParserError("USING already specified".into()));
+            }
+            using = Some(second_using);
+        }
 
         let columns = self.parse_parenthesized_index_column_list()?;
 
@@ -8303,6 +8311,14 @@ impl<'a> Parser<'a> {
         }
     }
 
+    pub fn parse_using_index_type_clause(&mut self) -> Result<Option<IndexType>, ParserError> {
+        if self.parse_keyword(Keyword::USING) {
+            Ok(Some(self.parse_index_type()?))
+        } else {
+            Ok(None)
+        }
+    }
+
     pub fn parse_index_type(&mut self) -> Result<IndexType, ParserError> {
         Ok(if self.parse_keyword(Keyword::BTREE) {
             IndexType::BTree

tests/sqlparser_common.rs

@@ -16156,3 +16156,44 @@ fn test_identifier_unicode_start() {
     ]);
     let _ = dialects.verified_stmt(sql);
 }
+
+#[test]
+fn parse_create_index_using_before_on() {
+    let sql = "CREATE INDEX idx_name USING BTREE ON table_name (col1)";
+    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!(),
+    }
+
+    let sql = "CREATE UNIQUE INDEX idx_name USING HASH ON table_name (col1, col2)";
+    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::Hash));
+            assert_eq!(columns.len(), 2);
+            assert!(unique);
+        }
+        _ => unreachable!(),
+    }
+}