github.com/whtcorpsinc/MilevaDB-Prod@v0.0.0-20211104133533-f57f4be3b597/allegrosql/request_builder_test.go

// Copyright 2020 WHTCORPS INC, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.

package allegrosql

import (
	"os"
	"testing"

	"github.com/whtcorpsinc/BerolinaSQL/allegrosql"
	. "github.com/whtcorpsinc/check"
	"github.com/whtcorpsinc/fidelpb/go-fidelpb"
	"github.com/whtcorpsinc/milevadb/blockcodec"
	"github.com/whtcorpsinc/milevadb/ekv"
	"github.com/whtcorpsinc/milevadb/schemareplicant"
	"github.com/whtcorpsinc/milevadb/soliton/chunk"
	"github.com/whtcorpsinc/milevadb/soliton/codec"
	"github.com/whtcorpsinc/milevadb/soliton/disk"
	"github.com/whtcorpsinc/milevadb/soliton/logutil"
	"github.com/whtcorpsinc/milevadb/soliton/memory"
	"github.com/whtcorpsinc/milevadb/soliton/mock"
	"github.com/whtcorpsinc/milevadb/soliton/ranger"
	"github.com/whtcorpsinc/milevadb/soliton/testleak"
	"github.com/whtcorpsinc/milevadb/statistics"
	"github.com/whtcorpsinc/milevadb/stochastikctx"
	"github.com/whtcorpsinc/milevadb/stochastikctx/stmtctx"
	"github.com/whtcorpsinc/milevadb/stochastikctx/variable"
	"github.com/whtcorpsinc/milevadb/types"
)

var _ = Suite(&testSuite{})

func TestT(t *testing.T) {
	CustomVerboseFlag = true
	logLevel := os.Getenv("log_level")
	logutil.InitLogger(logutil.NewLogConfig(logLevel, logutil.DefaultLogFormat, "", logutil.EmptyFileLogConfig, false))
	TestingT(t)
}

var _ = Suite(&testSuite{})

type testSuite struct {
	sctx stochastikctx.Context
}

func (s *testSuite) SetUpSuite(c *C) {
	ctx := mock.NewContext()
	ctx.GetStochastikVars().StmtCtx = &stmtctx.StatementContext{
		MemTracker:  memory.NewTracker(-1, -1),
		DiskTracker: disk.NewTracker(-1, -1),
	}
	ctx.CausetStore = &mock.CausetStore{
		Client: &mock.Client{
			MockResponse: &mockResponse{
				ctx:   ctx,
				batch: 1,
				total: 2,
			},
		},
	}
	s.sctx = ctx
}

func (s *testSuite) TearDownSuite(c *C) {
}

func (s *testSuite) SetUpTest(c *C) {
	testleak.BeforeTest()
	ctx := s.sctx.(*mock.Context)
	causetstore := ctx.CausetStore.(*mock.CausetStore)
	causetstore.Client = &mock.Client{
		MockResponse: &mockResponse{
			ctx:   ctx,
			batch: 1,
			total: 2,
		},
	}
}

func (s *testSuite) TearDownTest(c *C) {
	testleak.AfterTest(c)()
}

type handleRange struct {
	start int64
	end   int64
}

func (s *testSuite) getExpectedRanges(tid int64, hrs []*handleRange) []ekv.KeyRange {
	krs := make([]ekv.KeyRange, 0, len(hrs))
	for _, hr := range hrs {
		low := codec.EncodeInt(nil, hr.start)
		high := codec.EncodeInt(nil, hr.end)
		high = ekv.Key(high).PrefixNext()
		startKey := blockcodec.EncodeRowKey(tid, low)
		endKey := blockcodec.EncodeRowKey(tid, high)
		krs = append(krs, ekv.KeyRange{StartKey: startKey, EndKey: endKey})
	}
	return krs
}

func (s *testSuite) TestBlockHandlesToKVRanges(c *C) {
	handles := []ekv.Handle{ekv.IntHandle(0), ekv.IntHandle(2), ekv.IntHandle(3), ekv.IntHandle(4), ekv.IntHandle(5),
		ekv.IntHandle(10), ekv.IntHandle(11), ekv.IntHandle(100), ekv.IntHandle(9223372036854775806), ekv.IntHandle(9223372036854775807)}

	// Build expected key ranges.
	hrs := make([]*handleRange, 0, len(handles))
	hrs = append(hrs, &handleRange{start: 0, end: 0})
	hrs = append(hrs, &handleRange{start: 2, end: 5})
	hrs = append(hrs, &handleRange{start: 10, end: 11})
	hrs = append(hrs, &handleRange{start: 100, end: 100})
	hrs = append(hrs, &handleRange{start: 9223372036854775806, end: 9223372036854775807})

	// Build key ranges.
	expect := s.getExpectedRanges(1, hrs)
	actual := BlockHandlesToKVRanges(1, handles)

	// Compare key ranges and expected key ranges.
	c.Assert(len(actual), Equals, len(expect))
	for i := range actual {
		c.Assert(actual[i].StartKey, DeepEquals, expect[i].StartKey)
		c.Assert(actual[i].EndKey, DeepEquals, expect[i].EndKey)
	}
}

func (s *testSuite) TestBlockRangesToKVRanges(c *C) {
	ranges := []*ranger.Range{
		{
			LowVal:  []types.Causet{types.NewIntCauset(1)},
			HighVal: []types.Causet{types.NewIntCauset(2)},
		},
		{
			LowVal:      []types.Causet{types.NewIntCauset(2)},
			HighVal:     []types.Causet{types.NewIntCauset(4)},
			LowExclude:  true,
			HighExclude: true,
		},
		{
			LowVal:      []types.Causet{types.NewIntCauset(4)},
			HighVal:     []types.Causet{types.NewIntCauset(19)},
			HighExclude: true,
		},
		{
			LowVal:     []types.Causet{types.NewIntCauset(19)},
			HighVal:    []types.Causet{types.NewIntCauset(32)},
			LowExclude: true,
		},
		{
			LowVal:     []types.Causet{types.NewIntCauset(34)},
			HighVal:    []types.Causet{types.NewIntCauset(34)},
			LowExclude: true,
		},
	}

	actual := BlockRangesToKVRanges(13, ranges, nil)
	expect := []ekv.KeyRange{
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x21},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23},
		},
	}
	for i := 0; i < len(actual); i++ {
		c.Assert(actual[i], DeepEquals, expect[i])
	}
}

func (s *testSuite) TestIndexRangesToKVRanges(c *C) {
	ranges := []*ranger.Range{
		{
			LowVal:  []types.Causet{types.NewIntCauset(1)},
			HighVal: []types.Causet{types.NewIntCauset(2)},
		},
		{
			LowVal:      []types.Causet{types.NewIntCauset(2)},
			HighVal:     []types.Causet{types.NewIntCauset(4)},
			LowExclude:  true,
			HighExclude: true,
		},
		{
			LowVal:      []types.Causet{types.NewIntCauset(4)},
			HighVal:     []types.Causet{types.NewIntCauset(19)},
			HighExclude: true,
		},
		{
			LowVal:     []types.Causet{types.NewIntCauset(19)},
			HighVal:    []types.Causet{types.NewIntCauset(32)},
			LowExclude: true,
		},
		{
			LowVal:     []types.Causet{types.NewIntCauset(34)},
			HighVal:    []types.Causet{types.NewIntCauset(34)},
			LowExclude: true,
		},
	}

	expect := []ekv.KeyRange{
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x21},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23},
		},
	}

	actual, err := IndexRangesToKVRanges(new(stmtctx.StatementContext), 12, 15, ranges, nil)
	c.Assert(err, IsNil)
	for i := range actual {
		c.Assert(actual[i], DeepEquals, expect[i])
	}
}

func (s *testSuite) TestRequestBuilder1(c *C) {
	ranges := []*ranger.Range{
		{
			LowVal:  []types.Causet{types.NewIntCauset(1)},
			HighVal: []types.Causet{types.NewIntCauset(2)},
		},
		{
			LowVal:      []types.Causet{types.NewIntCauset(2)},
			HighVal:     []types.Causet{types.NewIntCauset(4)},
			LowExclude:  true,
			HighExclude: true,
		},
		{
			LowVal:      []types.Causet{types.NewIntCauset(4)},
			HighVal:     []types.Causet{types.NewIntCauset(19)},
			HighExclude: true,
		},
		{
			LowVal:     []types.Causet{types.NewIntCauset(19)},
			HighVal:    []types.Causet{types.NewIntCauset(32)},
			LowExclude: true,
		},
		{
			LowVal:     []types.Causet{types.NewIntCauset(34)},
			HighVal:    []types.Causet{types.NewIntCauset(34)},
			LowExclude: true,
		},
	}

	actual, err := (&RequestBuilder{}).SetBlockRanges(12, ranges, nil).
		SetPosetDagRequest(&fidelpb.PosetDagRequest{}).
		SetDesc(false).
		SetKeepOrder(false).
		SetFromStochastikVars(variable.NewStochastikVars()).
		Build()
	c.Assert(err, IsNil)
	expect := &ekv.Request{
		Tp:      103,
		StartTs: 0x0,
		Data:    []uint8{0x18, 0x0, 0x20, 0x0, 0x40, 0x0, 0x5a, 0x0},
		KeyRanges: []ekv.KeyRange{
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x21},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23},
			},
		},
		Cacheable:      true,
		KeepOrder:      false,
		Desc:           false,
		Concurrency:    variable.DefDistALLEGROSQLScanConcurrency,
		IsolationLevel: 0,
		Priority:       0,
		NotFillCache:   false,
		SyncLog:        false,
		Streaming:      false,
		ReplicaRead:    ekv.ReplicaReadLeader,
	}
	c.Assert(actual, DeepEquals, expect)
}

func (s *testSuite) TestRequestBuilder2(c *C) {
	ranges := []*ranger.Range{
		{
			LowVal:  []types.Causet{types.NewIntCauset(1)},
			HighVal: []types.Causet{types.NewIntCauset(2)},
		},
		{
			LowVal:      []types.Causet{types.NewIntCauset(2)},
			HighVal:     []types.Causet{types.NewIntCauset(4)},
			LowExclude:  true,
			HighExclude: true,
		},
		{
			LowVal:      []types.Causet{types.NewIntCauset(4)},
			HighVal:     []types.Causet{types.NewIntCauset(19)},
			HighExclude: true,
		},
		{
			LowVal:     []types.Causet{types.NewIntCauset(19)},
			HighVal:    []types.Causet{types.NewIntCauset(32)},
			LowExclude: true,
		},
		{
			LowVal:     []types.Causet{types.NewIntCauset(34)},
			HighVal:    []types.Causet{types.NewIntCauset(34)},
			LowExclude: true,
		},
	}

	actual, err := (&RequestBuilder{}).SetIndexRanges(new(stmtctx.StatementContext), 12, 15, ranges).
		SetPosetDagRequest(&fidelpb.PosetDagRequest{}).
		SetDesc(false).
		SetKeepOrder(false).
		SetFromStochastikVars(variable.NewStochastikVars()).
		Build()
	c.Assert(err, IsNil)
	expect := &ekv.Request{
		Tp:      103,
		StartTs: 0x0,
		Data:    []uint8{0x18, 0x0, 0x20, 0x0, 0x40, 0x0, 0x5a, 0x0},
		KeyRanges: []ekv.KeyRange{
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x14},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x21},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x23},
			},
		},
		Cacheable:      true,
		KeepOrder:      false,
		Desc:           false,
		Concurrency:    variable.DefDistALLEGROSQLScanConcurrency,
		IsolationLevel: 0,
		Priority:       0,
		NotFillCache:   false,
		SyncLog:        false,
		Streaming:      false,
		ReplicaRead:    ekv.ReplicaReadLeader,
	}
	c.Assert(actual, DeepEquals, expect)
}

func (s *testSuite) TestRequestBuilder3(c *C) {
	handles := []ekv.Handle{ekv.IntHandle(0), ekv.IntHandle(2), ekv.IntHandle(3), ekv.IntHandle(4),
		ekv.IntHandle(5), ekv.IntHandle(10), ekv.IntHandle(11), ekv.IntHandle(100)}

	actual, err := (&RequestBuilder{}).SetBlockHandles(15, handles).
		SetPosetDagRequest(&fidelpb.PosetDagRequest{}).
		SetDesc(false).
		SetKeepOrder(false).
		SetFromStochastikVars(variable.NewStochastikVars()).
		Build()
	c.Assert(err, IsNil)
	expect := &ekv.Request{
		Tp:      103,
		StartTs: 0x0,
		Data:    []uint8{0x18, 0x0, 0x20, 0x0, 0x40, 0x0, 0x5a, 0x0},
		KeyRanges: []ekv.KeyRange{
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc},
			},
			{
				StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x64},
				EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x65},
			},
		},
		Cacheable:      true,
		KeepOrder:      false,
		Desc:           false,
		Concurrency:    variable.DefDistALLEGROSQLScanConcurrency,
		IsolationLevel: 0,
		Priority:       0,
		NotFillCache:   false,
		SyncLog:        false,
		Streaming:      false,
		ReplicaRead:    ekv.ReplicaReadLeader,
	}
	c.Assert(actual, DeepEquals, expect)
}

func (s *testSuite) TestRequestBuilder4(c *C) {
	keyRanges := []ekv.KeyRange{
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x64},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x65},
		},
	}

	actual, err := (&RequestBuilder{}).SetKeyRanges(keyRanges).
		SetPosetDagRequest(&fidelpb.PosetDagRequest{}).
		SetDesc(false).
		SetKeepOrder(false).
		SetStreaming(true).
		SetFromStochastikVars(variable.NewStochastikVars()).
		Build()
	c.Assert(err, IsNil)
	expect := &ekv.Request{
		Tp:             103,
		StartTs:        0x0,
		Data:           []uint8{0x18, 0x0, 0x20, 0x0, 0x40, 0x0, 0x5a, 0x0},
		KeyRanges:      keyRanges,
		Cacheable:      true,
		KeepOrder:      false,
		Desc:           false,
		Concurrency:    variable.DefDistALLEGROSQLScanConcurrency,
		IsolationLevel: 0,
		Priority:       0,
		Streaming:      true,
		NotFillCache:   false,
		SyncLog:        false,
		ReplicaRead:    ekv.ReplicaReadLeader,
	}
	c.Assert(actual, DeepEquals, expect)
}

func (s *testSuite) TestRequestBuilder5(c *C) {
	keyRanges := []ekv.KeyRange{
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc},
		},
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x64},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x65},
		},
	}

	actual, err := (&RequestBuilder{}).SetKeyRanges(keyRanges).
		SetAnalyzeRequest(&fidelpb.AnalyzeReq{}).
		SetKeepOrder(true).
		SetConcurrency(15).
		Build()
	c.Assert(err, IsNil)
	expect := &ekv.Request{
		Tp:             104,
		StartTs:        0x0,
		Data:           []uint8{0x8, 0x0, 0x18, 0x0, 0x20, 0x0},
		KeyRanges:      keyRanges,
		KeepOrder:      true,
		Desc:           false,
		Concurrency:    15,
		IsolationLevel: ekv.RC,
		Priority:       1,
		NotFillCache:   true,
		SyncLog:        false,
		Streaming:      false,
	}
	c.Assert(actual, DeepEquals, expect)
}

func (s *testSuite) TestRequestBuilder6(c *C) {
	keyRanges := []ekv.KeyRange{
		{
			StartKey: ekv.Key{0x00, 0x01},
			EndKey:   ekv.Key{0x02, 0x03},
		},
	}

	concurrency := 10

	actual, err := (&RequestBuilder{}).SetKeyRanges(keyRanges).
		SetChecksumRequest(&fidelpb.ChecksumRequest{}).
		SetConcurrency(concurrency).
		Build()
	c.Assert(err, IsNil)

	expect := &ekv.Request{
		Tp:             105,
		StartTs:        0x0,
		Data:           []uint8{0x10, 0x0, 0x18, 0x0},
		KeyRanges:      keyRanges,
		KeepOrder:      false,
		Desc:           false,
		Concurrency:    concurrency,
		IsolationLevel: 0,
		Priority:       0,
		NotFillCache:   true,
		SyncLog:        false,
		Streaming:      false,
	}

	c.Assert(actual, DeepEquals, expect)
}

func (s *testSuite) TestRequestBuilder7(c *C) {
	vars := variable.NewStochastikVars()
	vars.SetReplicaRead(ekv.ReplicaReadFollower)

	concurrency := 10

	actual, err := (&RequestBuilder{}).
		SetFromStochastikVars(vars).
		SetConcurrency(concurrency).
		Build()
	c.Assert(err, IsNil)

	expect := &ekv.Request{
		Tp:             0,
		StartTs:        0x0,
		KeepOrder:      false,
		Desc:           false,
		Concurrency:    concurrency,
		IsolationLevel: 0,
		Priority:       0,
		NotFillCache:   false,
		SyncLog:        false,
		Streaming:      false,
		ReplicaRead:    ekv.ReplicaReadFollower,
	}

	c.Assert(actual, DeepEquals, expect)
}

func (s *testSuite) TestRequestBuilder8(c *C) {
	sv := variable.NewStochastikVars()
	sv.SnapshotschemaReplicant = schemareplicant.MockSchemaReplicantWithSchemaVer(nil, 10000)
	actual, err := (&RequestBuilder{}).
		SetFromStochastikVars(sv).
		Build()
	c.Assert(err, IsNil)
	expect := &ekv.Request{
		Tp:             0,
		StartTs:        0x0,
		Data:           []uint8(nil),
		Concurrency:    variable.DefDistALLEGROSQLScanConcurrency,
		IsolationLevel: 0,
		Priority:       0,
		MemTracker:     (*memory.Tracker)(nil),
		ReplicaRead:    0x1,
		SchemaVar:      10000,
	}
	c.Assert(actual, DeepEquals, expect)
}

func (s *testSuite) TestBlockRangesToKVRangesWithFbs(c *C) {
	ranges := []*ranger.Range{
		{
			LowVal:  []types.Causet{types.NewIntCauset(1)},
			HighVal: []types.Causet{types.NewIntCauset(4)},
		},
	}
	hist := statistics.NewHistogram(1, 30, 30, 0, types.NewFieldType(allegrosql.TypeLonglong), chunk.InitialCapacity, 0)
	for i := 0; i < 10; i++ {
		hist.Bounds.AppendInt64(0, int64(i))
		hist.Bounds.AppendInt64(0, int64(i+2))
		hist.Buckets = append(hist.Buckets, statistics.Bucket{Repeat: 10, Count: int64(i + 30)})
	}
	fb := statistics.NewQueryFeedback(0, hist, 0, false)
	lower, upper := types.NewIntCauset(2), types.NewIntCauset(3)
	fb.Feedback = []statistics.Feedback{
		{Lower: &lower, Upper: &upper, Count: 1, Repeat: 1},
	}
	actual := BlockRangesToKVRanges(0, ranges, fb)
	expect := []ekv.KeyRange{
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0x72, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5},
		},
	}
	for i := 0; i < len(actual); i++ {
		c.Assert(actual[i], DeepEquals, expect[i])
	}
}

func (s *testSuite) TestIndexRangesToKVRangesWithFbs(c *C) {
	ranges := []*ranger.Range{
		{
			LowVal:  []types.Causet{types.NewIntCauset(1)},
			HighVal: []types.Causet{types.NewIntCauset(4)},
		},
	}
	hist := statistics.NewHistogram(1, 30, 30, 0, types.NewFieldType(allegrosql.TypeLonglong), chunk.InitialCapacity, 0)
	for i := 0; i < 10; i++ {
		hist.Bounds.AppendInt64(0, int64(i))
		hist.Bounds.AppendInt64(0, int64(i+2))
		hist.Buckets = append(hist.Buckets, statistics.Bucket{Repeat: 10, Count: int64(i + 30)})
	}
	fb := statistics.NewQueryFeedback(0, hist, 0, false)
	lower, upper := types.NewIntCauset(2), types.NewIntCauset(3)
	fb.Feedback = []statistics.Feedback{
		{Lower: &lower, Upper: &upper, Count: 1, Repeat: 1},
	}
	actual, err := IndexRangesToKVRanges(new(stmtctx.StatementContext), 0, 0, ranges, fb)
	c.Assert(err, IsNil)
	expect := []ekv.KeyRange{
		{
			StartKey: ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
			EndKey:   ekv.Key{0x74, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0x69, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5},
		},
	}
	for i := 0; i < len(actual); i++ {
		c.Assert(actual[i], DeepEquals, expect[i])
	}
}

func (s *testSuite) TestScanLimitConcurrency(c *C) {
	vars := variable.NewStochastikVars()
	for _, tt := range []struct {
		tp          fidelpb.InterDircType
		limit       uint64
		concurrency int
	}{
		{fidelpb.InterDircType_TypeBlockScan, 1, 1},
		{fidelpb.InterDircType_TypeIndexScan, 1, 1},
		{fidelpb.InterDircType_TypeBlockScan, 1000000, vars.Concurrency.DistALLEGROSQLScanConcurrency()},
		{fidelpb.InterDircType_TypeIndexScan, 1000000, vars.Concurrency.DistALLEGROSQLScanConcurrency()},
	} {
		firstInterDirc := &fidelpb.InterlockingDirectorate{Tp: tt.tp}
		switch tt.tp {
		case fidelpb.InterDircType_TypeBlockScan:
			firstInterDirc.TblScan = &fidelpb.BlockScan{}
		case fidelpb.InterDircType_TypeIndexScan:
			firstInterDirc.IdxScan = &fidelpb.IndexScan{}
		}
		limitInterDirc := &fidelpb.InterlockingDirectorate{Tp: fidelpb.InterDircType_TypeLimit, Limit: &fidelpb.Limit{Limit: tt.limit}}
		posetPosetDag := &fidelpb.PosetDagRequest{InterlockingDirectorates: []*fidelpb.InterlockingDirectorate{firstInterDirc, limitInterDirc}}
		actual, err := (&RequestBuilder{}).
			SetPosetDagRequest(posetPosetDag).
			SetFromStochastikVars(vars).
			Build()
		c.Assert(err, IsNil)
		c.Assert(actual.Concurrency, Equals, tt.concurrency)
	}
}