mysql support DROP INDEX idx_a ON table_a and ALTER TABLE table_a DROP INDEX idx_a

Author: vimko

src/ast/ddl.rs

@@ -186,6 +186,14 @@ pub enum AlterTableOperation {
     DropForeignKey {
         name: Ident,
     },
+    /// `DROP INDEX <index_name>`
+    ///
+    /// Note: this is a [MySQL]-specific operation.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    DropIndex {
+        name: Ident,
+    },
     /// `ENABLE ALWAYS RULE rewrite_rule_name`
     ///
     /// Note: this is a PostgreSQL-specific operation.
@@ -605,6 +613,7 @@ impl fmt::Display for AlterTableOperation {
             }
             AlterTableOperation::DropPrimaryKey => write!(f, "DROP PRIMARY KEY"),
             AlterTableOperation::DropForeignKey { name } => write!(f, "DROP FOREIGN KEY {name}"),
+            AlterTableOperation::DropIndex { name } => write!(f, "DROP INDEX {name}"),
             AlterTableOperation::DropColumn {
                 column_name,
                 if_exists,

src/ast/mod.rs

@@ -3208,6 +3208,17 @@ pub enum Statement {
     /// `CREATE INDEX`
     /// ```
     CreateIndex(CreateIndex),
+    /// DROP INDEX
+    ///
+    /// ```sql
+    /// DROP INDEX index_name ON tbl_name
+    /// ```
+    /// See [MySql](https://dev.mysql.com/doc/refman/8.4/en/drop-index.html)
+    /// TODO: No support `[algorithm_option | lock_option]`
+    DropIndex {
+        index_name: ObjectName,
+        table_name: Option<ObjectName>,
+    },
     /// ```sql
     /// CREATE ROLE
     /// ```
@@ -4916,6 +4927,17 @@ impl fmt::Display for Statement {
                 Ok(())
             }
             Statement::CreateIndex(create_index) => create_index.fmt(f),
+            Statement::DropIndex {
+                index_name,
+                table_name,
+            } => {
+                write!(f, "DROP INDEX")?;
+                match &table_name {
+                    Some(table_name) => write!(f, " {index_name} ON {table_name}")?,
+                    None => write!(f, " {index_name}")?,
+                };
+                Ok(())
+            }
             Statement::CreateExtension {
                 name,
                 if_not_exists,

src/ast/spans.rs

@@ -421,6 +421,7 @@ impl Spanned for Statement {
                     .chain(module_args.iter().map(|i| i.span)),
             ),
             Statement::CreateIndex(create_index) => create_index.span(),
+            Statement::DropIndex { .. } => Span::empty(),
             Statement::CreateRole { .. } => Span::empty(),
             Statement::CreateSecret { .. } => Span::empty(),
             Statement::CreateConnector { .. } => Span::empty(),
@@ -1110,6 +1111,7 @@ impl Spanned for AlterTableOperation {
                 .union_opt(&with_name.as_ref().map(|n| n.span)),
             AlterTableOperation::DropPrimaryKey => Span::empty(),
             AlterTableOperation::DropForeignKey { name } => name.span,
+            AlterTableOperation::DropIndex { name } => name.span,
             AlterTableOperation::EnableAlwaysRule { name } => name.span,
             AlterTableOperation::EnableAlwaysTrigger { name } => name.span,
             AlterTableOperation::EnableReplicaRule { name } => name.span,

src/parser/mod.rs

@@ -5347,6 +5347,24 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Parse statements of the DropIndex type such as:
+    ///
+    /// ```sql
+    /// DROP Index idx_name ON table_name
+    /// ```
+    pub fn parse_drop_index(&mut self) -> Result<Statement, ParserError> {
+        let index_name = self.parse_object_name(false)?;
+        let table_name = if self.parse_keyword(Keyword::ON) {
+            Some(self.parse_object_name(false)?)
+        } else {
+            None
+        };
+        Ok(Statement::DropIndex {
+            index_name,
+            table_name,
+        })
+    }
+
     /// Parse statements of the DropTrigger type such as:
     ///
     /// ```sql
@@ -6196,7 +6214,11 @@ impl<'a> Parser<'a> {
         } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEW]) {
             ObjectType::MaterializedView
         } else if self.parse_keyword(Keyword::INDEX) {
-            ObjectType::Index
+            if dialect_of!(self is MySqlDialect){
+                return self.parse_drop_index();
+            }else {
+                ObjectType::Index
+            }
         } else if self.parse_keyword(Keyword::ROLE) {
             ObjectType::Role
         } else if self.parse_keyword(Keyword::SCHEMA) {
@@ -8599,6 +8621,9 @@ impl<'a> Parser<'a> {
             } else if self.parse_keywords(&[Keyword::FOREIGN, Keyword::KEY]) {
                 let name = self.parse_identifier()?;
                 AlterTableOperation::DropForeignKey { name }
+            } else if self.parse_keyword(Keyword::INDEX) {
+                let name = self.parse_identifier()?;
+                AlterTableOperation::DropIndex { name }
             } else if self.parse_keyword(Keyword::PROJECTION)
                 && dialect_of!(self is ClickHouseDialect|GenericDialect)
             {

tests/sqlparser_common.rs

@@ -9099,7 +9099,9 @@ fn test_create_index_with_with_clause() {
 #[test]
 fn parse_drop_index() {
     let sql = "DROP INDEX idx_a";
-    match verified_stmt(sql) {
+    // MySql dialect doesn't support `DROP INDEX idx_a`,you need to specify a specific table, please refer:
+    // [MySql](https://dev.mysql.com/doc/refman/8.4/en/drop-index.html)
+    match all_dialects_except(|d| d.is::<MySqlDialect>()).verified_stmt(sql) {
         Statement::Drop {
             names, object_type, ..
         } => {

tests/sqlparser_mysql.rs

@@ -3985,3 +3985,26 @@ fn parse_straight_join() {
     mysql()
         .verified_stmt("SELECT a.*, b.* FROM table_a STRAIGHT_JOIN table_b AS b ON a.b_id = b.id");
 }
+
+#[test]
+fn parse_drop_index() {
+    let sql_drop_index = "DROP INDEX idx_name ON tab_name;";
+    let drop_stmt = mysql().one_statement_parses_to(sql_drop_index, "");
+    assert_eq!(
+        drop_stmt,
+        Statement::DropIndex {
+            index_name: ObjectName::from(vec![Ident::new("idx_name")]),
+            table_name: Some(ObjectName::from(vec![Ident::new("tab_name")])),
+        }
+    );
+}
+
+#[test]
+fn parse_alter_table_drop_index() {
+    assert_matches!(
+        alter_table_op(
+            mysql_and_generic().verified_stmt("ALTER TABLE tab DROP INDEX idx_index")
+        ),
+        AlterTableOperation::DropIndex { name } if name.value == "idx_index"
+    );
+}