planner: check clustered index don't need double read

planner/core/exhaust_physical_plans.go

@@ -847,7 +847,7 @@ func (p *LogicalJoin) constructInnerIndexScanTask(
 		tblCols:     ds.TblCols,
 		keepOrder:   is.KeepOrder,
 	}
-	if !isCoveringIndex(ds.schema.Columns, path.FullIdxCols, path.FullIdxColLens, is.Table.PKIsHandle) {
+	if !ds.isCoveringIndex(ds.schema.Columns, path.FullIdxCols, path.FullIdxColLens, is.Table) {
 		// On this way, it's double read case.
 		ts := PhysicalTableScan{
 			Columns:         ds.Columns,
@@ -864,7 +864,7 @@ func (p *LogicalJoin) constructInnerIndexScanTask(
 		cop.tablePlan = ts
 	}
 	is.initSchema(path.Index, path.FullIdxCols, cop.tablePlan != nil)
-	indexConds, tblConds := splitIndexFilterConditions(filterConds, path.FullIdxCols, path.FullIdxColLens, ds.tableInfo)
+	indexConds, tblConds := ds.splitIndexFilterConditions(filterConds, path.FullIdxCols, path.FullIdxColLens, ds.tableInfo)
 	// Specially handle cases when input rowCount is 0, which can only happen in 2 scenarios:
 	// - estimated row count of outer plan is 0;
 	// - estimated row count of inner "DataSource + filters" is 0;

planner/core/find_best_task.go

@@ -25,7 +25,6 @@ import (
 	"github.com/pingcap/tidb/planner/util"
 	"github.com/pingcap/tidb/sessionctx/stmtctx"
 	"github.com/pingcap/tidb/statistics"
-	"github.com/pingcap/tidb/table/tables"
 	"github.com/pingcap/tidb/types"
 	"github.com/pingcap/tidb/util/chunk"
 	"github.com/pingcap/tidb/util/logutil"
@@ -407,7 +406,7 @@ func (ds *DataSource) skylinePruning(prop *property.PhysicalProperty) []*candida
 		if path.IsTablePath() {
 			currentCandidate = ds.getTableCandidate(path, prop)
 		} else {
-			coveredByIdx := isCoveringIndex(ds.schema.Columns, path.FullIdxCols, path.FullIdxColLens, ds.tableInfo.PKIsHandle)
+			coveredByIdx := ds.isCoveringIndex(ds.schema.Columns, path.FullIdxCols, path.FullIdxColLens, ds.tableInfo)
 			if len(path.AccessConds) > 0 || !prop.IsEmpty() || path.Forced || coveredByIdx {
 				// We will use index to generate physical plan if any of the following conditions is satisfied:
 				// 1. This path's access cond is not nil.
@@ -700,17 +699,19 @@ func (ds *DataSource) buildIndexMergeTableScan(prop *property.PhysicalProperty,
 	return ts, partialCost
 }
 
-func isCoveringIndex(columns, indexColumns []*expression.Column, idxColLens []int, pkIsHandle bool) bool {
+func (ds *DataSource) isCoveringIndex(columns, indexColumns []*expression.Column, idxColLens []int, tblInfo *model.TableInfo) bool {
+	indexCols := append(indexColumns, ds.commonHandleCols...)
+	indexColLens := append(idxColLens, ds.commonHandleLens...)
 	for _, col := range columns {
-		if pkIsHandle && mysql.HasPriKeyFlag(col.RetType.Flag) {
+		if tblInfo.PKIsHandle && mysql.HasPriKeyFlag(col.RetType.Flag) {
 			continue
 		}
 		if col.ID == model.ExtraHandleID {
 			continue
 		}
 		isIndexColumn := false
-		for i, indexCol := range indexColumns {
-			isFullLen := idxColLens[i] == types.UnspecifiedLength || idxColLens[i] == col.RetType.Flen
+		for i, indexCol := range indexCols {
+			isFullLen := indexColLens[i] == types.UnspecifiedLength || indexColLens[i] == col.RetType.Flen
 			// We use col.OrigColName instead of col.ColName.
 			// Related issue: https://github.com/pingcap/tidb/issues/9636.
 			if indexCol != nil && col.Equal(nil, indexCol) && isFullLen {
@@ -774,7 +775,7 @@ func (ds *DataSource) convertToIndexScan(prop *property.PhysicalProperty, candid
 	cop.cst = cost
 	task = cop
 	if candidate.isMatchProp {
-		if cop.tablePlan != nil {
+		if cop.tablePlan != nil && !ds.tableInfo.IsCommonHandle {
 			col, isNew := cop.tablePlan.(*PhysicalTableScan).appendExtraHandleCol(ds)
 			cop.extraHandleCol = col
 			cop.doubleReadNeedProj = isNew
@@ -814,52 +815,50 @@ func (is *PhysicalIndexScan) indexScanRowSize(idx *model.IndexInfo, ds *DataSour
 func (is *PhysicalIndexScan) initSchema(idx *model.IndexInfo, idxExprCols []*expression.Column, isDoubleRead bool) {
 	indexCols := make([]*expression.Column, len(is.IdxCols), len(idx.Columns)+1)
 	copy(indexCols, is.IdxCols)
-	for i := len(is.IdxCols); i < len(idx.Columns); i++ {
-		if idxExprCols[i] != nil {
-			indexCols = append(indexCols, idxExprCols[i])
-		} else {
-			// TODO: try to reuse the col generated when building the DataSource.
-			indexCols = append(indexCols, &expression.Column{
-				ID:       is.Table.Columns[idx.Columns[i].Offset].ID,
-				RetType:  &is.Table.Columns[idx.Columns[i].Offset].FieldType,
-				UniqueID: is.ctx.GetSessionVars().AllocPlanColumnID(),
-			})
-		}
-	}
-	setHandle := len(indexCols) > len(idx.Columns)
-	if !setHandle {
-		for i, col := range is.Columns {
-			if (mysql.HasPriKeyFlag(col.Flag) && is.Table.PKIsHandle) || col.ID == model.ExtraHandleID {
-				indexCols = append(indexCols, is.dataSourceSchema.Columns[i])
-				setHandle = true
-				break
+	is.NeedCommonHandle = is.Table.IsCommonHandle
+
+	if !is.NeedCommonHandle {
+		for i := len(is.IdxCols); i < len(idx.Columns); i++ {
+			if idxExprCols[i] != nil {
+				indexCols = append(indexCols, idxExprCols[i])
+			} else {
+				// TODO: try to reuse the col generated when building the DataSource.
+				indexCols = append(indexCols, &expression.Column{
+					ID:       is.Table.Columns[idx.Columns[i].Offset].ID,
+					RetType:  &is.Table.Columns[idx.Columns[i].Offset].FieldType,
+					UniqueID: is.ctx.GetSessionVars().AllocPlanColumnID(),
+				})
 			}
 		}
-	}
-
-	if is.Table.IsCommonHandle {
-		pkIdx := tables.FindPrimaryIndex(is.Table)
-		for _, col := range pkIdx.Columns {
-			indexCols = append(indexCols, &expression.Column{
-				ID:       is.Table.Columns[col.Offset].ID,
-				RetType:  &is.Table.Columns[col.Offset].FieldType,
-				UniqueID: is.ctx.GetSessionVars().AllocPlanColumnID(),
-			})
+		setHandle := len(indexCols) > len(idx.Columns)
+		if !setHandle {
+			for i, col := range is.Columns {
+				if (mysql.HasPriKeyFlag(col.Flag) && is.Table.PKIsHandle) || col.ID == model.ExtraHandleID {
+					indexCols = append(indexCols, is.dataSourceSchema.Columns[i])
+					setHandle = true
+					break
+				}
+			}
 		}
-		is.NeedCommonHandle = true
-	}
-
-	// If it's double read case, the first index must return handle. So we should add extra handle column
-	// if there isn't a handle column.
-	if isDoubleRead && !setHandle {
-		if !is.Table.IsCommonHandle {
-			indexCols = append(indexCols, &expression.Column{
-				RetType:  types.NewFieldType(mysql.TypeLonglong),
-				ID:       model.ExtraHandleID,
-				UniqueID: is.ctx.GetSessionVars().AllocPlanColumnID(),
-			})
+		// If it's double read case, the first index must return handle. So we should add extra handle column
+		// if there isn't a handle column.
+		if isDoubleRead && !setHandle {
+			if !is.Table.IsCommonHandle {
+				indexCols = append(indexCols, &expression.Column{
+					RetType:  types.NewFieldType(mysql.TypeLonglong),
+					ID:       model.ExtraHandleID,
+					UniqueID: is.ctx.GetSessionVars().AllocPlanColumnID(),
+				})
+			}
+		}
+	} else {
+		if len(is.IdxCols) < len(is.Columns) {
+			for i := len(is.IdxCols); i < len(idxExprCols); i++ {
+				indexCols = append(indexCols, idxExprCols[i])
+			}
 		}
 	}
+
 	is.SetSchema(expression.NewSchema(indexCols...))
 }
 
@@ -922,11 +921,11 @@ func matchIndicesProp(idxCols []*expression.Column, colLens []int, propItems []p
 	return true
 }
 
-func splitIndexFilterConditions(conditions []expression.Expression, indexColumns []*expression.Column, idxColLens []int,
+func (ds *DataSource) splitIndexFilterConditions(conditions []expression.Expression, indexColumns []*expression.Column, idxColLens []int,
 	table *model.TableInfo) (indexConds, tableConds []expression.Expression) {
 	var indexConditions, tableConditions []expression.Expression
 	for _, cond := range conditions {
-		if isCoveringIndex(expression.ExtractColumns(cond), indexColumns, idxColLens, table.PKIsHandle) {
+		if ds.isCoveringIndex(expression.ExtractColumns(cond), indexColumns, idxColLens, table) {
 			indexConditions = append(indexConditions, cond)
 		} else {
 			tableConditions = append(tableConditions, cond)
@@ -1408,7 +1407,7 @@ func (ds *DataSource) getOriginalPhysicalIndexScan(prop *property.PhysicalProper
 		is.Hist = &statsTbl.Indices[idx.ID].Histogram
 	}
 	rowCount := path.CountAfterAccess
-	is.initSchema(idx, path.FullIdxCols, !isSingleScan)
+	is.initSchema(idx, append(path.FullIdxCols, ds.commonHandleCols...), !isSingleScan)
 	// Only use expectedCnt when it's smaller than the count we calculated.
 	// e.g. IndexScan(count1)->After Filter(count2). The `ds.stats.RowCount` is count2. count1 is the one we need to calculate
 	// If expectedCnt and count2 are both zero and we go into the below `if` block, the count1 will be set to zero though it's shouldn't be.

planner/core/logical_plan_builder.go

@@ -2859,6 +2859,15 @@ func (b *PlanBuilder) buildDataSource(ctx context.Context, tn *ast.TableName, as
 	ds.names = names
 	ds.setPreferredStoreType(b.TableHints())
 
+	// Init commonHandleCols and commonHandleLens for data source.
+	if tableInfo.IsCommonHandle {
+		for _, idx := range tableInfo.Indices {
+			if idx.Primary {
+				ds.commonHandleCols, ds.commonHandleLens = expression.IndexInfo2Cols(ds.Columns, ds.schema.Columns, idx)
+				break
+			}
+		}
+	}
 	// Init FullIdxCols, FullIdxColLens for accessPaths.
 	for _, path := range ds.possibleAccessPaths {
 		if !path.IsTablePath() {

planner/core/logical_plans.go

@@ -498,6 +498,9 @@ type DataSource struct {
 	// TblCols contains the original columns of table before being pruned, and it
 	// is used for estimating table scan cost.
 	TblCols []*expression.Column
+	// commonHandleCols and commonHandleLens save the info of primary key which is the clustered index.
+	commonHandleCols []*expression.Column
+	commonHandleLens []int
 	// TblColHists contains the Histogram of all original table columns,
 	// it is converted from statisticTable, and used for IO/network cost estimating.
 	TblColHists *statistics.HistColl
@@ -626,7 +629,7 @@ func (ds *DataSource) Convert2Gathers() (gathers []LogicalPlan) {
 			path.FullIdxCols, path.FullIdxColLens = expression.IndexInfo2Cols(ds.Columns, ds.schema.Columns, path.Index)
 			path.IdxCols, path.IdxColLens = expression.IndexInfo2PrefixCols(ds.Columns, ds.schema.Columns, path.Index)
 			// If index columns can cover all of the needed columns, we can use a IndexGather + IndexScan.
-			if isCoveringIndex(ds.schema.Columns, path.FullIdxCols, path.FullIdxColLens, ds.tableInfo.PKIsHandle) {
+			if ds.isCoveringIndex(ds.schema.Columns, path.FullIdxCols, path.FullIdxColLens, ds.tableInfo) {
 				gathers = append(gathers, ds.buildIndexGather(path))
 			}
 			// TODO: If index columns can not cover the schema, use IndexLookUpGather.
@@ -857,7 +860,7 @@ func (ds *DataSource) deriveIndexPathStats(path *util.AccessPath, conds []expres
 			}
 		}
 	}
-	path.IndexFilters, path.TableFilters = splitIndexFilterConditions(path.TableFilters, path.FullIdxCols, path.FullIdxColLens, ds.tableInfo)
+	path.IndexFilters, path.TableFilters = ds.splitIndexFilterConditions(path.TableFilters, path.FullIdxCols, path.FullIdxColLens, ds.tableInfo)
 	// If the `CountAfterAccess` is less than `stats.RowCount`, there must be some inconsistent stats info.
 	// We prefer the `stats.RowCount` because it could use more stats info to calculate the selectivity.
 	if path.CountAfterAccess < ds.stats.RowCount && !isIm {

planner/core/testdata/integration_suite_in.json

@@ -143,7 +143,9 @@
       "select * from t1",
       "select * from t1 where t1.a >= 1 and t1.a < 4",
       "select * from t1 where t1.a = 1 and t1.b < \"333\"",
-      "select * from t1 where t1.c = 3.3"
+      "select * from t1 where t1.c = 3.3",
+      "select t1.b, t1.c from t1 where t1.c = 2.2",
+      "select /*+ use_index(t1, c) */ * from t1"
     ]
   }
 ]

planner/core/testdata/integration_suite_out.json

@@ -682,13 +682,34 @@
       {
         "SQL": "select * from t1 where t1.c = 3.3",
         "Plan": [
-          "TableReader_7 1.00 root  data:Selection_6",
-          "└─Selection_6 1.00 cop[tikv]  eq(test.t1.c, 3.3)",
-          "  └─TableFullScan_5 3.00 cop[tikv] table:t1 keep order:false"
+          "IndexReader_6 1.00 root  index:IndexRangeScan_5",
+          "└─IndexRangeScan_5 1.00 cop[tikv] table:t1, index:c(c) range:[3.3000000000,3.3000000000], keep order:false"
         ],
         "Res": [
           "3 333 3.3000000000"
         ]
+      },
+      {
+        "SQL": "select t1.b, t1.c from t1 where t1.c = 2.2",
+        "Plan": [
+          "IndexReader_6 1.00 root  index:IndexRangeScan_5",
+          "└─IndexRangeScan_5 1.00 cop[tikv] table:t1, index:c(c) range:[2.2000000000,2.2000000000], keep order:false"
+        ],
+        "Res": [
+          "222 2.2000000000"
+        ]
+      },
+      {
+        "SQL": "select /*+ use_index(t1, c) */ * from t1",
+        "Plan": [
+          "IndexReader_5 3.00 root  index:IndexFullScan_4",
+          "└─IndexFullScan_4 3.00 cop[tikv] table:t1, index:c(c) keep order:false"
+        ],
+        "Res": [
+          "1 111 1.1000000000",
+          "2 222 2.2000000000",
+          "3 333 3.3000000000"
+        ]
       }
     ]
   }