ddl, parser: support 'ALTER TABLE RENAME KEY TO' syntax

ast/ddl.go

@@ -717,6 +717,7 @@ const (
 	AlterTableAlterColumn
 	AlterTableLock
 	AlterTableAlgorithm
+	AlterTableRenameIndex
 
 // TODO: Add more actions
 )
@@ -747,6 +748,8 @@ type AlterTableSpec struct {
 	Position      *ColumnPosition
 	LockType      LockType
 	Comment       string
+	FromKey       model.CIStr
+	ToKey         model.CIStr
 }
 
 // Accept implements Node Accept interface.

ddl/ddl_api.go

@@ -991,6 +991,8 @@ func (d *ddl) AlterTable(ctx sessionctx.Context, ident ast.Ident, specs []*ast.A
 			err = d.RenameTable(ctx, ident, newIdent)
 		case ast.AlterTableDropPrimaryKey:
 			err = ErrUnsupportedModifyPrimaryKey.GenByArgs("drop")
+		case ast.AlterTableRenameIndex:
+			err = d.RenameIndex(ctx, ident, spec)
 		case ast.AlterTableOption:
 			for _, opt := range spec.Options {
 				switch opt.Tp {
@@ -1559,6 +1561,42 @@ func (d *ddl) AlterTableComment(ctx sessionctx.Context, ident ast.Ident, spec *a
 	return errors.Trace(err)
 }
 
+// RenameIndex updates the table comment information.
+func (d *ddl) RenameIndex(ctx sessionctx.Context, ident ast.Ident, spec *ast.AlterTableSpec) error {
+	is := d.infoHandle.Get()
+	schema, ok := is.SchemaByName(ident.Schema)
+	if !ok {
+		return infoschema.ErrDatabaseNotExists.GenByArgs(ident.Schema)
+	}
+
+	tb, err := is.TableByName(ident.Schema, ident.Name)
+	if err != nil {
+		return errors.Trace(infoschema.ErrTableNotExists.GenByArgs(ident.Schema, ident.Name))
+	}
+
+	if fromIdx := findIndexByName(spec.FromKey.L, tb.Meta().Indices); fromIdx == nil {
+		return errors.Trace(infoschema.ErrKeyNotExists.GenByArgs(spec.FromKey.O, tb.Meta().Name))
+	}
+	if spec.FromKey.O == spec.ToKey.O {
+		return nil
+	}
+	if toIdx := findIndexByName(spec.ToKey.L, tb.Meta().Indices); toIdx != nil && spec.FromKey.L != spec.ToKey.L {
+		return errors.Trace(infoschema.ErrKeyNameDuplicate.GenByArgs(toIdx.Name.O))
+	}
+
+	job := &model.Job{
+		SchemaID:   schema.ID,
+		TableID:    tb.Meta().ID,
+		Type:       model.ActionRenameIndex,
+		BinlogInfo: &model.HistoryInfo{},
+		Args:       []interface{}{spec.FromKey, spec.ToKey},
+	}
+
+	err = d.doDDLJob(ctx, job)
+	err = d.callHookOnChanged(err)
+	return errors.Trace(err)
+}
+
 // DropTable will proceed even if some table in the list does not exists.
 func (d *ddl) DropTable(ctx sessionctx.Context, ti ast.Ident) (err error) {
 	is := d.getInformationSchema()

ddl/ddl_worker.go

@@ -376,6 +376,8 @@ func (d *ddl) runDDLJob(t *meta.Meta, job *model.Job) (ver int64, err error) {
 		ver, err = d.onShardRowID(t, job)
 	case model.ActionModifyTableComment:
 		ver, err = d.onModifyTableComment(t, job)
+	case model.ActionRenameIndex:
+		ver, err = d.onRenameIndex(t, job)
 	default:
 		// Invalid job, cancel it.
 		job.State = model.JobStateCancelled

ddl/table.go

@@ -356,6 +356,31 @@ func (d *ddl) onModifyTableComment(t *meta.Meta, job *model.Job) (ver int64, _ e
 	return ver, nil
 }
 
+func (d *ddl) onRenameIndex(t *meta.Meta, job *model.Job) (ver int64, _ error) {
+	var from, to model.CIStr
+	if err := job.DecodeArgs(&from, &to); err != nil {
+		job.State = model.JobStateCancelled
+		return ver, errors.Trace(err)
+	}
+
+	tblInfo, err := getTableInfo(t, job, job.SchemaID)
+	if err != nil {
+		return ver, errors.Trace(err)
+	}
+
+	idx := findIndexByName(from.L, tblInfo.Indices)
+	if idx == nil {
+		return ver, errors.Trace(infoschema.ErrKeyNotExists.GenByArgs(from, tblInfo.Name))
+	}
+	idx.Name = to
+	ver, err = updateVersionAndTableInfo(t, job, tblInfo, true)
+	if err != nil {
+		return ver, errors.Trace(err)
+	}
+	job.FinishTableJob(model.JobStateDone, model.StatePublic, ver, tblInfo)
+	return ver, nil
+}
+
 func checkTableNotExists(t *meta.Meta, job *model.Job, schemaID int64, tableName string) error {
 	// Check this table's database.
 	tables, err := t.ListTables(schemaID)

executor/executor_test.go

@@ -2635,6 +2635,51 @@ func (s *testSuite) TestCheckIndex(c *C) {
 	// table     data (handle, data): (1, 10), (2, 20), (4, 40)
 }
 
+func (s *testSuite) TestRenameIndex(c *C) {
+	s.ctx = mock.NewContext()
+	s.ctx.Store = s.store
+	_, err := session.BootstrapSession(s.store)
+	c.Assert(err, IsNil)
+	se, err := session.CreateSession4Test(s.store)
+	c.Assert(err, IsNil)
+	defer se.Close()
+
+	_, err = se.Execute(context.Background(), "create database test_rename_index")
+	c.Assert(err, IsNil)
+	_, err = se.Execute(context.Background(), "use test_rename_index")
+	c.Assert(err, IsNil)
+	_, err = se.Execute(context.Background(), "create table t (pk int primary key, c int default 1, c1 int default 1, unique key k1(c), key k2(c1))")
+	c.Assert(err, IsNil)
+
+	// Test rename success
+	_, err = se.Execute(context.Background(), "alter table t rename index k1 to k3")
+	c.Assert(err, IsNil)
+	_, err = se.Execute(context.Background(), "admin check index t k3")
+	c.Assert(err, IsNil)
+
+	// Test rename to the same name
+	_, err = se.Execute(context.Background(), "alter table t rename index k3 to k3")
+	c.Assert(err, IsNil)
+	_, err = se.Execute(context.Background(), "admin check index t k3")
+	c.Assert(err, IsNil)
+
+	// Test rename on non-exists keys
+	_, err = se.Execute(context.Background(), "alter table t rename index x to x")
+	c.Assert(err, NotNil)
+	c.Assert(strings.Contains(err.Error(), "Key 'x' doesn't exist in table 't'"), IsTrue)
+
+	// Test rename on already-exists keys
+	_, err = se.Execute(context.Background(), "alter table t rename index k3 to k2")
+	c.Assert(err, NotNil)
+	c.Assert(strings.Contains(err.Error(), "Duplicate key name 'k2'"), IsTrue)
+
+	_, err = se.Execute(context.Background(), "alter table t rename index k2 to K2")
+	c.Assert(err, IsNil)
+	_, err = se.Execute(context.Background(), "alter table t rename key k3 to K2")
+	c.Assert(err, NotNil)
+	c.Assert(strings.Contains(err.Error(), "Duplicate key name 'K2'"), IsTrue)
+}
+
 func setColValue(c *C, txn kv.Transaction, key kv.Key, v types.Datum) {
 	row := []types.Datum{v, {}}
 	colIDs := []int64{2, 3}

infoschema/infoschema.go

@@ -50,6 +50,10 @@ var (
 	ErrColumnExists = terror.ClassSchema.New(codeColumnExists, "Duplicate column name '%s'")
 	// ErrIndexExists returns for index already exists.
 	ErrIndexExists = terror.ClassSchema.New(codeIndexExists, "Duplicate Index")
+	// ErrKeyNameDuplicate returns for index duplicate when rename index.
+	ErrKeyNameDuplicate = terror.ClassSchema.New(codeKeyNameDuplicate, "Duplicate key name '%s'")
+	// ErrKeyNotExists returns for index not exists.
+	ErrKeyNotExists = terror.ClassSchema.New(codeKeyNotExists, " Key '%s' doesn't exist in table '%s'")
 	// ErrMultiplePriKey returns for multiple primary keys.
 	ErrMultiplePriKey = terror.ClassSchema.New(codeMultiplePriKey, "Multiple primary key defined")
 	// ErrTooManyKeyParts returns for too many key parts.
@@ -279,13 +283,15 @@ const (
 	codeForeignKeyNotExists = 1091
 	codeWrongFkDef          = 1239
 
-	codeDatabaseExists  = 1007
-	codeTableExists     = 1050
-	codeBadTable        = 1051
-	codeColumnExists    = 1060
-	codeIndexExists     = 1831
-	codeMultiplePriKey  = 1068
-	codeTooManyKeyParts = 1070
+	codeDatabaseExists   = 1007
+	codeTableExists      = 1050
+	codeBadTable         = 1051
+	codeColumnExists     = 1060
+	codeIndexExists      = 1831
+	codeMultiplePriKey   = 1068
+	codeTooManyKeyParts  = 1070
+	codeKeyNameDuplicate = 1061
+	codeKeyNotExists     = 1176
 )
 
 func init() {
@@ -304,6 +310,8 @@ func init() {
 		codeIndexExists:         mysql.ErrDupIndex,
 		codeMultiplePriKey:      mysql.ErrMultiplePriKey,
 		codeTooManyKeyParts:     mysql.ErrTooManyKeyParts,
+		codeKeyNameDuplicate:    mysql.ErrDupKeyName,
+		codeKeyNotExists:        mysql.ErrKeyDoesNotExist,
 	}
 	terror.ErrClassToMySQLCodes[terror.ClassSchema] = schemaMySQLErrCodes
 	initInfoSchemaDB()

model/ddl.go

@@ -46,6 +46,7 @@ const (
 	ActionSetDefaultValue    ActionType = 15
 	ActionShardRowID         ActionType = 16
 	ActionModifyTableComment ActionType = 17
+	ActionRenameIndex        ActionType = 18
 )
 
 var actionMap = map[ActionType]string{
@@ -66,6 +67,7 @@ var actionMap = map[ActionType]string{
 	ActionSetDefaultValue:    "set default value",
 	ActionShardRowID:         "shard row ID",
 	ActionModifyTableComment: "modify table comment",
+	ActionRenameIndex:        "rename index",
 }
 
 // String return current ddl action in string

parser/parser.y

@@ -1036,6 +1036,14 @@ AlterTableSpec:
 			NewTable:      $3.(*ast.TableName),
 		}
 	}
+|	"RENAME" KeyOrIndex Identifier "TO" Identifier
+	{
+		$$ = &ast.AlterTableSpec{
+			Tp:    		ast.AlterTableRenameIndex,
+			FromKey:    model.NewCIStr($3),
+			ToKey:      model.NewCIStr($5),
+		}
+	}
 |	LockClause
 	{
 		$$ = &ast.AlterTableSpec{