*: split index region with lower upper syntax

executor/builder.go

@@ -194,7 +194,7 @@ func (b *executorBuilder) build(p plannercore.Plan) Executor {
 		return b.buildWindow(v)
 	case *plannercore.SQLBindPlan:
 		return b.buildSQLBindExec(v)
-	case *plannercore.SplitIndexRegion:
+	case *plannercore.SplitRegion:
 		return b.buildSplitIndexRegion(v)
 	default:
 		if mp, ok := p.(MockPhysicalPlan); ok {
@@ -1255,13 +1255,16 @@ func (b *executorBuilder) buildUnionAll(v *plannercore.PhysicalUnionAll) Executo
 	return e
 }
 
-func (b *executorBuilder) buildSplitIndexRegion(v *plannercore.SplitIndexRegion) Executor {
+func (b *executorBuilder) buildSplitIndexRegion(v *plannercore.SplitRegion) Executor {
 	base := newBaseExecutor(b.ctx, nil, v.ExplainID())
 	base.initCap = chunk.ZeroCapacity
 	return &SplitIndexRegionExec{
 		baseExecutor: base,
-		table:        v.Table,
+		tableInfo:    v.TableInfo,
 		indexInfo:    v.IndexInfo,
+		min:          v.Min,
+		max:          v.Max,
+		num:          v.Num,
 		valueLists:   v.ValueLists,
 	}
 }

executor/executor.go

@@ -1388,7 +1388,7 @@ func ResetContextOfStmt(ctx sessionctx.Context, s ast.StmtNode) (err error) {
 			sc.InShowWarning = true
 			sc.SetWarnings(vars.StmtCtx.GetWarnings())
 		}
-	case *ast.SplitIndexRegionStmt:
+	case *ast.SplitRegionStmt:
 		sc.IgnoreTruncate = false
 		sc.IgnoreZeroInDate = true
 		sc.AllowInvalidDate = vars.SQLMode.HasAllowInvalidDatesMode()

executor/executor_test.go

@@ -3757,6 +3757,27 @@ func (s *testSuite) TestSplitIndexRegion(c *C) {
 	c.Assert(err, NotNil)
 	terr := errors.Cause(err).(*terror.Error)
 	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.WarnDataTruncated))
+
+	// Check min value is more than max value.
+	tk.MustExec(`split table t index idx1 min (0) max (1000000000) num 10`)
+	_, err = tk.Exec(`split table t index idx1 min (2) max (1) num 10`)
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, "Split index region `idx1` min value [{1 0 0 0 2 [] <nil>}] should less than the max value [{1 0 0 0 1 [] <nil>}]")
+
+	// Check min value is invalid.
+	_, err = tk.Exec(`split table t index idx1 min () max (1) num 10`)
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, "Split index region `idx1` min value count should more than 0")
+
+	// Check max value is invalid.
+	_, err = tk.Exec(`split table t index idx1 min (1) max () num 10`)
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, "Split index region `idx1` max value count should more than 0")
+
+	// Check pre-split region num is too large.
+	_, err = tk.Exec(`split table t index idx1 min (0) max (1000000000) num 10000`)
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, "Split index region num is exceed the limit 1000")
 }
 
 func (s *testSuite) TestUnsignedFeedback(c *C) {

executor/split.go

@@ -14,13 +14,16 @@
 package executor
 
 import (
+	"bytes"
 	"context"
+	"encoding/binary"
 	"math"
 
+	"github.com/pingcap/errors"
 	"github.com/pingcap/parser/model"
 	"github.com/pingcap/tidb/kv"
-	"github.com/pingcap/tidb/table"
 	"github.com/pingcap/tidb/table/tables"
+	"github.com/pingcap/tidb/tablecodec"
 	"github.com/pingcap/tidb/types"
 	"github.com/pingcap/tidb/util/chunk"
 	"github.com/pingcap/tidb/util/logutil"
@@ -31,8 +34,11 @@ import (
 type SplitIndexRegionExec struct {
 	baseExecutor
 
-	table      table.Table
+	tableInfo  *model.TableInfo
 	indexInfo  *model.IndexInfo
+	min        []types.Datum
+	max        []types.Datum
+	num        int
 	valueLists [][]types.Datum
 }
 
@@ -48,18 +54,16 @@ func (e *SplitIndexRegionExec) Next(ctx context.Context, _ *chunk.RecordBatch) e
 	if !ok {
 		return nil
 	}
-	regionIDs := make([]uint64, 0, len(e.valueLists))
-	index := tables.NewIndex(e.table.Meta().ID, e.table.Meta(), e.indexInfo)
-	for _, values := range e.valueLists {
-		idxKey, _, err := index.GenIndexKey(e.ctx.GetSessionVars().StmtCtx, values, math.MinInt64, nil)
-		if err != nil {
-			return err
-		}
-
+	splitIdxKeys, err := e.getSplitIdxKeys()
+	if err != nil {
+		return err
+	}
+	regionIDs := make([]uint64, 0, len(splitIdxKeys))
+	for _, idxKey := range splitIdxKeys {
 		regionID, err := s.SplitRegionAndScatter(idxKey)
 		if err != nil {
 			logutil.Logger(context.Background()).Warn("split table index region failed",
-				zap.String("table", e.table.Meta().Name.L),
+				zap.String("table", e.tableInfo.Name.L),
 				zap.String("index", e.indexInfo.Name.L),
 				zap.Error(err))
 			continue
@@ -75,10 +79,107 @@ func (e *SplitIndexRegionExec) Next(ctx context.Context, _ *chunk.RecordBatch) e
 		if err != nil {
 			logutil.Logger(context.Background()).Warn("wait scatter region failed",
 				zap.Uint64("regionID", regionID),
-				zap.String("table", e.table.Meta().Name.L),
+				zap.String("table", e.tableInfo.Name.L),
 				zap.String("index", e.indexInfo.Name.L),
 				zap.Error(err))
 		}
 	}
 	return nil
 }
+
+func (e *SplitIndexRegionExec) getSplitIdxKeys() ([][]byte, error) {
+	var idxKeys [][]byte
+	if e.num > 0 {
+		idxKeys = make([][]byte, 0, e.num)
+	} else {
+		idxKeys = make([][]byte, 0, len(e.valueLists)+1)
+	}
+	// Split in the start of the index key.
+	startIdxKey := tablecodec.EncodeTableIndexPrefix(e.tableInfo.ID, e.indexInfo.ID)
+	idxKeys = append(idxKeys, startIdxKey)
+
+	index := tables.NewIndex(e.tableInfo.ID, e.tableInfo, e.indexInfo)
+	// Split index regions by user specified value lists.
+	if len(e.valueLists) > 0 {
+		for _, v := range e.valueLists {
+			idxKey, _, err := index.GenIndexKey(e.ctx.GetSessionVars().StmtCtx, v, math.MinInt64, nil)
+			if err != nil {
+				return nil, err
+			}
+			idxKeys = append(idxKeys, idxKey)
+		}
+		return idxKeys, nil
+	}
+	// Split index regions by min, max value and calculate the step by (max - min)/num.
+	minIdxKey, _, err := index.GenIndexKey(e.ctx.GetSessionVars().StmtCtx, e.min, math.MinInt64, nil)
+	if err != nil {
+		return nil, err
+	}
+	maxIdxKey, _, err := index.GenIndexKey(e.ctx.GetSessionVars().StmtCtx, e.max, math.MinInt64, nil)
+	if err != nil {
+		return nil, err
+	}
+	if bytes.Compare(minIdxKey, maxIdxKey) >= 0 {
+		return nil, errors.Errorf("Split index region `%v` min value %v should less than the max value %v", e.indexInfo.Name, e.min, e.max)
+	}
+	return getValuesList(minIdxKey, maxIdxKey, e.num, idxKeys), nil
+}
+
+// longestCommonPrefixLen gets the longest common prefix byte length.
+func longestCommonPrefixLen(s1, s2 []byte) int {
+	l := len(s1)
+	if len(s2) < len(s1) {
+		l = len(s2)
+	}
+	i := 0
+	for ; i < l; i++ {
+		if s1[i] != s2[i] {
+			break
+		}
+	}
+	return i
+}
+
+// getStepValue gets the step of between the min and max value. step = (max-min)/num.
+// convert byte slice to uint64 first.
+func getStepValue(min, max []byte, num int) uint64 {
+	minUint := getUint64FromBytes(min, 0)
+	maxUint := getUint64FromBytes(max, 0xff)
+	return (maxUint - minUint) / uint64(num)
+}
+
+// getUint64FromBytes gets a uint64 from the `bs` byte slice.
+// If len(bs) < 8, then padding with `pad`.
+func getUint64FromBytes(bs []byte, pad byte) uint64 {
+	buf := bs
+	if len(buf) < 8 {
+		buf = make([]byte, 0, 8)
+		buf = append(buf, bs...)
+		for i := len(buf); i < 8; i++ {
+			buf = append(buf, pad)
+		}
+	}
+	return binary.BigEndian.Uint64(buf)
+}
+
+// getValuesList is used to get `num` values between min and max value.
+// To Simplify the explain, suppose min and max value type is int64, and min=0, max=100, num=10,
+// then calculate the step=(max-min)/num=10, then the function should return 0+10, 10+10, 20+10... all together 9 (num-1) values.
+// then the function will return [10,20,30,40,50,60,70,80,90].
+// The difference is the value type of max,min is []byte, So I use getUint64FromBytes to convert []byte to uint64.
+func getValuesList(min, max []byte, num int, valuesList [][]byte) [][]byte {
+	commonPrefixIdx := longestCommonPrefixLen(min, max)
+	step := getStepValue(min[commonPrefixIdx:], max[commonPrefixIdx:], num)
+	startV := getUint64FromBytes(min[commonPrefixIdx:], 0)
+	// To get `num` regions, only need to split `num-1` idx keys.
+	buf := make([]byte, 8)
+	for i := 0; i < num-1; i++ {
+		value := make([]byte, 0, commonPrefixIdx+8)
+		value = append(value, min[:commonPrefixIdx]...)
+		startV += step
+		binary.BigEndian.PutUint64(buf, startV)
+		value = append(value, buf...)
+		valuesList = append(valuesList, value)
+	}
+	return valuesList
+}