ddl: support alter table .. truncate partition (#8624)

ddl/db_test.go

@@ -2947,6 +2947,62 @@ func (s *testDBSuite) TestAlterTableDropPartition(c *C) {
 	s.testErrorCode(c, sql4, tmysql.ErrDropPartitionNonExistent)
 }
 
+func (s *testDBSuite) TestAlterTableTruncatePartition(c *C) {
+	s.tk = testkit.NewTestKit(c, s.store)
+	s.tk.MustExec("use test")
+	s.tk.MustExec("drop table if exists employees")
+	s.tk.MustExec("set @@tidb_enable_table_partition = 1")
+	s.tk.MustExec(`create table employees (
+	  id int not null,
+	  hired int not null
+	) partition by range( hired ) (
+		partition p1 values less than (1991),
+		partition p2 values less than (1996),
+		partition p3 values less than (2001)
+	)`)
+	s.tk.MustExec("insert into employees values (1, 1990)")
+	s.tk.MustExec("insert into employees values (2, 1995)")
+	s.tk.MustExec("insert into employees values (3, 2000)")
+	result := s.tk.MustQuery("select * from employees order by id")
+	result.Check(testkit.Rows(`1 1990`, `2 1995`, `3 2000`))
+
+	s.testErrorCode(c, "alter table employees truncate partition xxx", tmysql.ErrUnknownPartition)
+
+	ctx := s.tk.Se.(sessionctx.Context)
+	is := domain.GetDomain(ctx).InfoSchema()
+	oldTblInfo, err := is.TableByName(model.NewCIStr("test"), model.NewCIStr("employees"))
+	c.Assert(err, IsNil)
+	oldPID := oldTblInfo.Meta().Partition.Definitions[0].ID
+
+	s.tk.MustExec("alter table employees truncate partition p1")
+	result = s.tk.MustQuery("select * from employees order by id")
+	result.Check(testkit.Rows(`2 1995`, `3 2000`))
+
+	partitionPrefix := tablecodec.EncodeTablePrefix(oldPID)
+	hasOldPartitionData := checkPartitionDelRangeDone(c, s, partitionPrefix)
+	c.Assert(hasOldPartitionData, IsFalse)
+
+	is = domain.GetDomain(ctx).InfoSchema()
+	oldTblInfo, err = is.TableByName(model.NewCIStr("test"), model.NewCIStr("employees"))
+	c.Assert(err, IsNil)
+	newPID := oldTblInfo.Meta().Partition.Definitions[0].ID
+	c.Assert(oldPID != newPID, IsTrue)
+
+	s.tk.MustExec("alter table employees truncate partition p3")
+	result = s.tk.MustQuery("select * from employees")
+	result.Check(testkit.Rows(`2 1995`))
+
+	s.tk.MustExec("insert into employees values (1, 1984)")
+	result = s.tk.MustQuery("select * from employees order by id")
+	result.Check(testkit.Rows(`1 1984`, `2 1995`))
+	s.tk.MustExec("insert into employees values (3, 2000)")
+	result = s.tk.MustQuery("select * from employees order by id")
+	result.Check(testkit.Rows(`1 1984`, `2 1995`, `3 2000`))
+
+	s.tk.MustExec(`create table non_partition (id int)`)
+	s.testErrorCode(c, "alter table non_partition truncate partition p0", tmysql.ErrPartitionMgmtOnNonpartitioned)
+}
+
 func (s *testDBSuite) TestAddPartitionTooManyPartitions(c *C) {
 	s.tk = testkit.NewTestKit(c, s.store)
 	s.tk.MustExec("use test")

ddl/ddl.go

@@ -83,6 +83,7 @@ var (
 	errWaitReorgTimeout      = terror.ClassDDL.New(codeWaitReorgTimeout, "wait for reorganization timeout")
 	errInvalidStoreVer       = terror.ClassDDL.New(codeInvalidStoreVer, "invalid storage current version")
 
+	errUnknownPartition = terror.ClassDDL.New(codeUnknownPartition, mysql.MySQLErrName[mysql.ErrUnknownPartition])
 	// We don't support dropping column with index covered now.
 	errCantDropColWithIndex     = terror.ClassDDL.New(codeCantDropColWithIndex, "can't drop column with index")
 	errUnsupportedAddColumn     = terror.ClassDDL.New(codeUnsupportedAddColumn, "unsupported add column")
@@ -620,6 +621,7 @@ const (
 	codeUniqueKeyNeedAllFieldsInPf             = terror.ErrCode(mysql.ErrUniqueKeyNeedAllFieldsInPf)
 	codePrimaryCantHaveNull                    = terror.ErrCode(mysql.ErrPrimaryCantHaveNull)
 	codeWrongExprInPartitionFunc               = terror.ErrCode(mysql.ErrWrongExprInPartitionFunc)
+	codeUnknownPartition                       = terror.ErrCode(mysql.ErrUnknownPartition)
 )
 
 func init() {
@@ -667,6 +669,7 @@ func init() {
 		codeUniqueKeyNeedAllFieldsInPf:             mysql.ErrUniqueKeyNeedAllFieldsInPf,
 		codePrimaryCantHaveNull:                    mysql.ErrPrimaryCantHaveNull,
 		codeWrongExprInPartitionFunc:               mysql.ErrWrongExprInPartitionFunc,
+		codeUnknownPartition:                       mysql.ErrUnknownPartition,
 	}
 	terror.ErrClassToMySQLCodes[terror.ClassDDL] = ddlMySQLErrCodes
 }

ddl/ddl_api.go

@@ -920,7 +920,7 @@ func (d *ddl) CreateTable(ctx sessionctx.Context, s *ast.CreateTableStmt) (err e
 				return errors.Trace(err)
 			}
 
-			if err = checkAddPartitionTooManyPartitions(len(pi.Definitions)); err != nil {
+			if err = checkAddPartitionTooManyPartitions(uint64(len(pi.Definitions))); err != nil {
 				return errors.Trace(err)
 			}
 
@@ -1115,6 +1115,8 @@ func (d *ddl) AlterTable(ctx sessionctx.Context, ident ast.Ident, specs []*ast.A
 			err = d.DropIndex(ctx, ident, model.NewCIStr(spec.Name))
 		case ast.AlterTableDropPartition:
 			err = d.DropTablePartition(ctx, ident, spec)
+		case ast.AlterTableTruncatePartition:
+			err = d.TruncateTablePartition(ctx, ident, spec)
 		case ast.AlterTableAddConstraint:
 			constr := spec.Constraint
 			switch spec.Constraint.Tp {
@@ -1360,7 +1362,7 @@ func (d *ddl) AddTablePartitions(ctx sessionctx.Context, ident ast.Ident, spec *
 		return errors.Trace(err)
 	}
 
-	err = checkAddPartitionTooManyPartitions(len(meta.Partition.Definitions) + len(partInfo.Definitions))
+	err = checkAddPartitionTooManyPartitions(uint64(len(meta.Partition.Definitions) + len(partInfo.Definitions)))
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -1388,6 +1390,43 @@ func (d *ddl) AddTablePartitions(ctx sessionctx.Context, ident ast.Ident, spec *
 	return errors.Trace(err)
 }
 
+func (d *ddl) TruncateTablePartition(ctx sessionctx.Context, ident ast.Ident, spec *ast.AlterTableSpec) error {
+	is := d.infoHandle.Get()
+	schema, ok := is.SchemaByName(ident.Schema)
+	if !ok {
+		return errors.Trace(infoschema.ErrDatabaseNotExists.GenWithStackByArgs(schema))
+	}
+	t, err := is.TableByName(ident.Schema, ident.Name)
+	if err != nil {
+		return errors.Trace(infoschema.ErrTableNotExists.GenWithStackByArgs(ident.Schema, ident.Name))
+	}
+	meta := t.Meta()
+	if meta.GetPartitionInfo() == nil {
+		return errors.Trace(ErrPartitionMgmtOnNonpartitioned)
+	}
+
+	var pid int64
+	pid, err = findPartitionByName(meta, spec.Name)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	job := &model.Job{
+		SchemaID:   schema.ID,
+		TableID:    meta.ID,
+		Type:       model.ActionTruncateTablePartition,
+		BinlogInfo: &model.HistoryInfo{},
+		Args:       []interface{}{pid},
+	}
+
+	err = d.doDDLJob(ctx, job)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	err = d.callHookOnChanged(err)
+	return errors.Trace(err)
+}
+
 func (d *ddl) DropTablePartition(ctx sessionctx.Context, ident ast.Ident, spec *ast.AlterTableSpec) error {
 	is := d.infoHandle.Get()
 	schema, ok := is.SchemaByName(ident.Schema)

ddl/ddl_worker.go

@@ -285,7 +285,7 @@ func (w *worker) finishDDLJob(t *meta.Meta, job *model.Job) (err error) {
 
 			// After rolling back an AddIndex operation, we need to use delete-range to delete the half-done index data.
 			err = w.deleteRange(job)
-		case model.ActionDropSchema, model.ActionDropTable, model.ActionTruncateTable, model.ActionDropIndex, model.ActionDropTablePartition:
+		case model.ActionDropSchema, model.ActionDropTable, model.ActionTruncateTable, model.ActionDropIndex, model.ActionDropTablePartition, model.ActionTruncateTablePartition:
 			err = w.deleteRange(job)
 		}
 		if err != nil {
@@ -472,6 +472,8 @@ func (w *worker) runDDLJob(d *ddlCtx, t *meta.Meta, job *model.Job) (ver int64,
 		ver, err = onDropTable(t, job)
 	case model.ActionDropTablePartition:
 		ver, err = onDropTablePartition(t, job)
+	case model.ActionTruncateTablePartition:
+		ver, err = onTruncateTablePartition(t, job)
 	case model.ActionAddColumn:
 		ver, err = onAddColumn(d, t, job)
 	case model.ActionDropColumn:

ddl/delete_range.go

@@ -243,7 +243,7 @@ func insertJobIntoDeleteRangeTable(ctx sessionctx.Context, job *model.Job) error
 		startKey = tablecodec.EncodeTablePrefix(tableID)
 		endKey := tablecodec.EncodeTablePrefix(tableID + 1)
 		return doInsert(s, job.ID, tableID, startKey, endKey, now)
-	case model.ActionDropTablePartition:
+	case model.ActionDropTablePartition, model.ActionTruncateTablePartition:
 		var physicalTableID int64
 		if err := job.DecodeArgs(&physicalTableID); err != nil {
 			return errors.Trace(err)

ddl/partition.go

@@ -279,6 +279,18 @@ func checkDropTablePartition(meta *model.TableInfo, partName string) error {
 	return errors.Trace(ErrDropPartitionNonExistent.GenWithStackByArgs(partName))
 }
 
+func findPartitionByName(meta *model.TableInfo, parName string) (int64, error) {
+	// TODO: MySQL behavior for hash partition is weird, "create table .. partition by hash partition 4",
+	// it use p0, p1, p2, p3 as partition names automatically.
+	parName = strings.ToLower(parName)
+	for _, def := range meta.Partition.Definitions {
+		if strings.EqualFold(def.Name.L, parName) {
+			return def.ID, nil
+		}
+	}
+	return -1, errors.Trace(errUnknownPartition.GenWithStackByArgs(parName, meta.Name.O))
+}
+
 // removePartitionInfo each ddl job deletes a partition.
 func removePartitionInfo(tblInfo *model.TableInfo, partName string) int64 {
 	oldDefs := tblInfo.Partition.Definitions
@@ -326,8 +338,54 @@ func onDropTablePartition(t *meta.Meta, job *model.Job) (ver int64, _ error) {
 	return ver, nil
 }
 
-func checkAddPartitionTooManyPartitions(piDefs int) error {
-	if piDefs > PartitionCountLimit {
+// onDropTablePartition truncates old partition meta.
+func onTruncateTablePartition(t *meta.Meta, job *model.Job) (int64, error) {
+	var ver int64
+	var oldID int64
+	if err := job.DecodeArgs(&oldID); 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)
+	}
+	pi := tblInfo.GetPartitionInfo()
+	if pi == nil {
+		return ver, errors.Trace(ErrPartitionMgmtOnNonpartitioned)
+	}
+
+	var find bool
+	for i := 0; i < len(pi.Definitions); i++ {
+		def := &pi.Definitions[i]
+		if def.ID == oldID {
+			pid, err1 := t.GenGlobalID()
+			if err != nil {
+				return ver, errors.Trace(err1)
+			}
+			def.ID = pid
+			find = true
+			break
+		}
+	}
+	if !find {
+		return ver, errUnknownPartition.GenWithStackByArgs("drop?", tblInfo.Name.O)
+	}
+
+	ver, err = updateVersionAndTableInfo(t, job, tblInfo, true)
+	if err != nil {
+		return ver, errors.Trace(err)
+	}
+
+	// Finish this job.
+	job.FinishTableJob(model.JobStateDone, model.StateNone, ver, tblInfo)
+	// A background job will be created to delete old partition data.
+	job.Args = []interface{}{oldID}
+	return ver, nil
+}
+
+func checkAddPartitionTooManyPartitions(piDefs uint64) error {
+	if piDefs > uint64(PartitionCountLimit) {
 		return ErrTooManyPartitions
 	}
 	return nil

ddl/table.go

@@ -46,7 +46,7 @@ func onCreateTable(d *ddlCtx, t *meta.Meta, job *model.Job) (ver int64, _ error)
 	}
 
 	if tbInfo.Partition != nil {
-		err = checkAddPartitionTooManyPartitions(len(tbInfo.Partition.Definitions))
+		err = checkAddPartitionTooManyPartitions(uint64(len(tbInfo.Partition.Definitions)))
 		if err != nil {
 			job.State = model.JobStateCancelled
 			return ver, errors.Trace(err)
@@ -463,7 +463,7 @@ func onAddTablePartition(t *meta.Meta, job *model.Job) (ver int64, _ error) {
 		job.State = model.JobStateCancelled
 		return ver, errors.Trace(err)
 	}
-	err = checkAddPartitionTooManyPartitions(len(tblInfo.Partition.Definitions) + len(partInfo.Definitions))
+	err = checkAddPartitionTooManyPartitions(uint64(len(tblInfo.Partition.Definitions) + len(partInfo.Definitions)))
 	if err != nil {
 		job.State = model.JobStateCancelled
 		return ver, errors.Trace(err)

go.mod

@@ -80,3 +80,5 @@ require (
 	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
 	gopkg.in/yaml.v2 v2.2.1 // indirect
 )
+
+replace github.com/pingcap/parser => github.com/tiancaiamao/parser v0.0.0-20190116115114-e2ff6aa2040c

go.sum

@@ -118,6 +118,8 @@ github.com/spaolacci/murmur3 v0.0.0-20150829172844-0d12bf811670 h1:hKP4ACPoBBCnB
 github.com/spaolacci/murmur3 v0.0.0-20150829172844-0d12bf811670/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/tiancaiamao/parser v0.0.0-20190116115114-e2ff6aa2040c h1:Jca3Kh29wy4T8etEUU+/SWbYoQHFqDJIzS0kIjuoCXU=
+github.com/tiancaiamao/parser v0.0.0-20190116115114-e2ff6aa2040c/go.mod h1:vqvanuOAAZ9O2rVI51fUrA9P3nV7HoILjLby0/OKOqA=
 github.com/twinj/uuid v0.0.0-20150629100731-70cac2bcd273 h1:YqFyfcgqxQqjpRr0SEG0Z555J/3kPqDL/xmRyeAaX/0=
 github.com/twinj/uuid v0.0.0-20150629100731-70cac2bcd273/go.mod h1:mMgcE1RHFUFqe5AfiwlINXisXfDGro23fWdPUfOMjRY=
 github.com/uber/jaeger-client-go v2.8.0+incompatible h1:7DGH8Hqk6PirD+GE+bvCf0cLnspLuae7N1NcwMeQcyg=