planner, executor: split the range for unsigned pk of partition table when limit is used

executor/builder.go

@@ -4325,7 +4325,7 @@ func (builder *dataReaderBuilder) buildTableReaderBase(ctx context.Context, e *T
 		SetDAGRequest(e.dagPB).
 		SetStartTS(startTS).
 		SetDesc(e.desc).
-		SetKeepOrder(e.keepOrder).
+		SetKeepOrder(e.keepOrder == plannercore.KeepOrderBetweenRequest).
 		SetTxnScope(e.txnScope).
 		SetReadReplicaScope(e.readReplicaScope).
 		SetIsStaleness(e.isStaleness).

executor/partition_table_test.go

@@ -728,6 +728,17 @@ func TestOrderByAndLimit(t *testing.T) {
 	}
 }
 
+func TestOrderByOnUnsignedPk(t *testing.T) {
+	store := testkit.CreateMockStore(t)
+
+	tk := testkit.NewTestKit(t, store)
+	tk.MustExec("use test")
+	tk.MustExec("create table tunsigned_hash(a bigint unsigned primary key) partition by hash(a) partitions 6")
+	tk.MustExec("insert into tunsigned_hash values(25), (9279808998424041135)")
+	tk.MustQuery("select min(a) from tunsigned_hash").Check(testkit.Rows("25"))
+	tk.MustQuery("select max(a) from tunsigned_hash").Check(testkit.Rows("9279808998424041135"))
+}
+
 func TestBatchGetandPointGetwithHashPartition(t *testing.T) {
 	store := testkit.CreateMockStore(t)
 

executor/table_reader.go

@@ -103,7 +103,7 @@ type TableReaderExecutor struct {
 	memTracker       *memory.Tracker
 	selectResultHook // for testing
 
-	keepOrder bool
+	keepOrder plannercore.KeepOrderTypeForTableReader
 	desc      bool
 	paging    bool
 	storeType kv.StoreType
@@ -184,7 +184,7 @@ func (e *TableReaderExecutor) Open(ctx context.Context) error {
 			e.feedback.Invalidate()
 		}
 	}
-	firstPartRanges, secondPartRanges := distsql.SplitRangesAcrossInt64Boundary(e.ranges, e.keepOrder, e.desc, e.table.Meta() != nil && e.table.Meta().IsCommonHandle)
+	firstPartRanges, secondPartRanges := distsql.SplitRangesAcrossInt64Boundary(e.ranges, e.keepOrder != plannercore.NoOrder, e.desc, e.table.Meta() != nil && e.table.Meta().IsCommonHandle)
 
 	// Treat temporary table as dummy table, avoid sending distsql request to TiKV.
 	// Calculate the kv ranges here, UnionScan rely on this kv ranges.
@@ -343,7 +343,7 @@ func (e *TableReaderExecutor) buildKVReqSeparately(ctx context.Context, ranges [
 			SetDAGRequest(e.dagPB).
 			SetStartTS(e.startTS).
 			SetDesc(e.desc).
-			SetKeepOrder(e.keepOrder).
+			SetKeepOrder(e.keepOrder == plannercore.KeepOrderBetweenRequest).
 			SetTxnScope(e.txnScope).
 			SetReadReplicaScope(e.readReplicaScope).
 			SetFromSessionVars(e.ctx.GetSessionVars()).
@@ -384,7 +384,7 @@ func (e *TableReaderExecutor) buildKVReqForPartitionTableScan(ctx context.Contex
 		SetDAGRequest(e.dagPB).
 		SetStartTS(e.startTS).
 		SetDesc(e.desc).
-		SetKeepOrder(e.keepOrder).
+		SetKeepOrder(e.keepOrder == plannercore.KeepOrderBetweenRequest).
 		SetTxnScope(e.txnScope).
 		SetReadReplicaScope(e.readReplicaScope).
 		SetFromSessionVars(e.ctx.GetSessionVars()).
@@ -432,7 +432,7 @@ func (e *TableReaderExecutor) buildKVReq(ctx context.Context, ranges []*ranger.R
 		SetDAGRequest(e.dagPB).
 		SetStartTS(e.startTS).
 		SetDesc(e.desc).
-		SetKeepOrder(e.keepOrder).
+		SetKeepOrder(e.keepOrder == plannercore.KeepOrderBetweenRequest).
 		SetTxnScope(e.txnScope).
 		SetReadReplicaScope(e.readReplicaScope).
 		SetIsStaleness(e.isStaleness).

planner/cascades/implementation_rules.go

@@ -198,7 +198,7 @@ func (*ImplTableScan) OnImplement(expr *memo.GroupExpr, reqProp *property.Physic
 	logicalScan := expr.ExprNode.(*plannercore.LogicalTableScan)
 	ts := logicalScan.GetPhysicalScan(logicProp.Schema, logicProp.Stats.ScaleByExpectCnt(reqProp.ExpectedCnt))
 	if !reqProp.IsSortItemEmpty() {
-		ts.KeepOrder = true
+		ts.KeepOrder = plannercore.KeepOrderBetweenRequest
 		ts.Desc = reqProp.SortItems[0].Desc
 	}
 	tblCols, tblColHists := logicalScan.Source.TblCols, logicalScan.Source.TblColHists

planner/core/exhaust_physical_plans.go

@@ -983,6 +983,10 @@ func (p *LogicalJoin) constructInnerTableScanTask(
 	if keepOrder && ds.tableInfo.GetPartitionInfo() != nil {
 		return nil
 	}
+	var keepOrderStatus = NoOrder
+	if keepOrder {
+		keepOrderStatus = KeepOrderBetweenRequest
+	}
 	ts := PhysicalTableScan{
 		Table:           ds.tableInfo,
 		Columns:         ds.Columns,
@@ -991,7 +995,7 @@ func (p *LogicalJoin) constructInnerTableScanTask(
 		filterCondition: ds.pushedDownConds,
 		Ranges:          ranges,
 		rangeInfo:       rangeInfo,
-		KeepOrder:       keepOrder,
+		KeepOrder:       keepOrderStatus,
 		Desc:            desc,
 		physicalTableID: ds.physicalTableID,
 		isPartition:     ds.isPartition,
@@ -1025,7 +1029,7 @@ func (p *LogicalJoin) constructInnerTableScanTask(
 		tablePlan:         ts,
 		indexPlanFinished: true,
 		tblColHists:       ds.TblColHists,
-		keepOrder:         ts.KeepOrder,
+		keepOrder:         ts.KeepOrder == KeepOrderBetweenRequest,
 	}
 	copTask.partitionInfo = PartitionInfo{
 		PruningConds:   ds.allConds,

planner/core/explain.go

@@ -205,7 +205,7 @@ func (p *PhysicalTableScan) OperatorInfo(normalized bool) string {
 		}
 	}
 	buffer.WriteString("keep order:")
-	buffer.WriteString(strconv.FormatBool(p.KeepOrder))
+	buffer.WriteString(strconv.FormatBool(p.KeepOrder == KeepOrderBetweenRequest))
 	if p.Desc {
 		buffer.WriteString(", desc")
 	}

planner/core/find_best_task.go

@@ -42,6 +42,22 @@ import (
 	"go.uber.org/zap"
 )
 
+// We need three status for the KEEP ORDER of the table reader.
+// It's very strange problem.
+// At the very beginning time, TiKV stores the unsigned pk at a wrong order: [MaxInt64+1, MaxUint64] is the beginning, then following [0, MaxInt64].
+// So if we just directly KEEP ORDER, we will get data of [MaxInt64+1, MaxUint64] first, then [0, MaxInt64].
+// We need to specially handle this case.
+// And then we have the func pushTopNDownToDynamicPartition. It pushes part of the order property down to the partition table.
+// It does not need KEEP ORDER between the request. But only need to nodify that each request itself should read the data in correct order.
+// So we introduce the third type KeepOrderInRequest.
+type KeepOrderTypeForTableReader uint
+
+const (
+	NoOrder KeepOrderTypeForTableReader = iota
+	KeepOrderInRequest
+	KeepOrderBetweenRequest
+)
+
 const (
 	// SelectionFactor is the default factor of the selectivity.
 	// For example, If we have no idea how to estimate the selectivity
@@ -1976,7 +1992,7 @@ func (ds *DataSource) convertToTableScan(prop *property.PhysicalProperty, candid
 		return invalidTask, nil
 	}
 	ts, _ := ds.getOriginalPhysicalTableScan(prop, candidate.path, candidate.isMatchProp)
-	if ts.KeepOrder && ts.StoreType == kv.TiFlash && (ts.Desc || ds.SCtx().GetSessionVars().TiFlashFastScan) {
+	if ts.KeepOrder != NoOrder && ts.StoreType == kv.TiFlash && (ts.Desc || ds.SCtx().GetSessionVars().TiFlashFastScan) {
 		// TiFlash fast mode(https://github.com/pingcap/tidb/pull/35851) does not keep order in TableScan
 		return invalidTask, nil
 	}
@@ -1998,7 +2014,7 @@ func (ds *DataSource) convertToTableScan(prop *property.PhysicalProperty, candid
 	isDisaggregatedTiFlashPath := config.GetGlobalConfig().DisaggregatedTiFlash && ts.StoreType == kv.TiFlash
 	canMppConvertToRootForDisaggregatedTiFlash := isDisaggregatedTiFlashPath && prop.TaskTp == property.RootTaskType && ds.SCtx().GetSessionVars().IsMPPAllowed()
 	if prop.TaskTp == property.MppTaskType || canMppConvertToRootForDisaggregatedTiFlash {
-		if ts.KeepOrder {
+		if ts.KeepOrder != NoOrder {
 			return invalidTask, nil
 		}
 		if prop.MPPPartitionTp != property.AnyType || ts.isPartition {
@@ -2352,7 +2368,7 @@ func (ds *DataSource) getOriginalPhysicalTableScan(prop *property.PhysicalProper
 	ts.stats = ds.tableStats.ScaleByExpectCnt(rowCount)
 	if isMatchProp {
 		ts.Desc = prop.SortItems[0].Desc
-		ts.KeepOrder = true
+		ts.KeepOrder = KeepOrderBetweenRequest
 	}
 	return ts, rowCount
 }

planner/core/initialize.go

@@ -427,7 +427,7 @@ func (p *PhysicalTableReader) adjustReadReqType(ctx sessionctx.Context) {
 		// and all table scans contained are not keepOrder, try to use batch cop.
 		if len(tableScans) > 0 {
 			for _, tableScan := range tableScans {
-				if tableScan.KeepOrder {
+				if !(tableScan.KeepOrder == NoOrder) {
 					return
 				}
 			}

planner/core/physical_plans.go

@@ -820,7 +820,7 @@ type PhysicalTableScan struct {
 	// works on the whole partition table, and `isPartition` is not used.
 	isPartition bool
 	// KeepOrder is true, if sort data by scanning pkcol,
-	KeepOrder bool
+	KeepOrder KeepOrderTypeForTableReader
 	Desc      bool
 
 	isChildOfIndexLookUp bool

planner/core/plan_to_pb.go

@@ -187,7 +187,7 @@ func (p *PhysicalTableScan) ToPB(ctx sessionctx.Context, storeType kv.StoreType)
 	}
 	tsExec := tables.BuildTableScanFromInfos(p.Table, p.Columns)
 	tsExec.Desc = p.Desc
-	keepOrder := p.KeepOrder
+	keepOrder := !(p.KeepOrder == NoOrder)
 	tsExec.KeepOrder = &keepOrder
 	tsExec.IsFastScan = &(ctx.GetSessionVars().TiFlashFastScan)
 

planner/core/task.go

@@ -1072,7 +1072,6 @@ func (p *PhysicalTopN) pushTopNDownToDynamicPartition(copTsk *copTask) (task, bo
 		if !propMatched {
 			return nil, false
 		}
-
 		idxScan.Desc = isDesc
 		childProfile := copTsk.plan().statsInfo()
 		newCount := p.Offset + p.Count
@@ -1100,6 +1099,8 @@ func (p *PhysicalTopN) pushTopNDownToDynamicPartition(copTsk *copTask) (task, bo
 			}
 		}
 		tblScan.Desc = isDesc
+		// SplitRangesAcrossInt64Boundary needs the KeepOrder flag. See that func and the struct tableResultHandler for more details.
+		tblScan.KeepOrder = KeepOrderInRequest
 		childProfile := copTsk.plan().statsInfo()
 		newCount := p.Offset + p.Count
 		stats := deriveLimitStats(childProfile, float64(newCount))