plan: remove other accessPaths if one is unique key and full matched.

cmd/explaintest/r/explain_easy_stats.result

@@ -6,6 +6,8 @@ create table t2 (c1 int unique, c2 int);
 load stats 's/explain_easy_stats_t2.json';
 create table t3 (a bigint, b bigint, c bigint, d bigint);
 load stats 's/explain_easy_stats_t3.json';
+create table index_prune(a bigint(20) NOT NULL, b bigint(20) NOT NULL, c tinyint(4) NOT NULL, primary key(a, b), index idx_b_c_a(b, c, a));
+load stats 's/explain_easy_stats_index_prune.json';
 set @@session.tidb_opt_insubquery_unfold = 1;
 set @@session.tidb_opt_agg_push_down = 1;
 explain select * from t3 where exists (select s.a from t3 s having sum(s.a) = t3.a );
@@ -150,4 +152,11 @@ label = "cop"
 "TableReader_12" -> "Selection_11"
 }
 
-drop table if exists t1, t2, t3;
+explain select * from index_prune WHERE a = 1010010404050976781 AND b = 26467085526790 LIMIT 1;
+id	task	operator info	count
+Limit_9	root	offset:0, count:1	1.00
+└─IndexLookUp_15	root	index:Limit_14, table:TableScan_13	1.00
+  ├─Limit_14	cop	offset:0, count:1	1.00
+  │ └─IndexScan_12	cop	table:index_prune, index:a, b, range:[1010010404050976781 26467085526790,1010010404050976781 26467085526790], keep order:false	1.00
+  └─TableScan_13	cop	table:index_prune, keep order:false	1.00
+drop table if exists t1, t2, t3, index_prune;

cmd/explaintest/t/explain_easy_stats.test

@@ -6,6 +6,8 @@ create table t2 (c1 int unique, c2 int);
 load stats 's/explain_easy_stats_t2.json';
 create table t3 (a bigint, b bigint, c bigint, d bigint);
 load stats 's/explain_easy_stats_t3.json';
+create table index_prune(a bigint(20) NOT NULL, b bigint(20) NOT NULL, c tinyint(4) NOT NULL, primary key(a, b), index idx_b_c_a(b, c, a));
+load stats 's/explain_easy_stats_index_prune.json';
 set @@session.tidb_opt_insubquery_unfold = 1;
 set @@session.tidb_opt_agg_push_down = 1;
 
@@ -45,4 +47,6 @@ explain select 1 in (select c2 from t2) from t1;
 # explain format="dot" select sum(t1.c1 in (select c1 from t2)) from t1;
 explain format="dot" select 1 in (select c2 from t2) from t1;
 
-drop table if exists t1, t2, t3;
+explain select * from index_prune WHERE a = 1010010404050976781 AND b = 26467085526790 LIMIT 1;
+
+drop table if exists t1, t2, t3, index_prune;

plan/logical_plans.go

@@ -334,7 +334,9 @@ type accessPath struct {
 	forced bool
 }
 
-func (ds *DataSource) deriveTablePathStats(path *accessPath) error {
+// deriveTablePathStats will fulfill the information that the accessPath need.
+// And it will check whether the primary key is covered only by point query.
+func (ds *DataSource) deriveTablePathStats(path *accessPath) (bool, error) {
 	var err error
 	sc := ds.ctx.GetSessionVars().StmtCtx
 	path.countAfterAccess = float64(ds.statisticTable.Count)
@@ -347,11 +349,11 @@ func (ds *DataSource) deriveTablePathStats(path *accessPath) error {
 	}
 	if pkCol == nil {
 		path.ranges = ranger.FullIntRange(false)
-		return nil
+		return false, nil
 	}
 	path.ranges = ranger.FullIntRange(mysql.HasUnsignedFlag(pkCol.RetType.Flag))
 	if len(ds.pushedDownConds) == 0 {
-		return nil
+		return false, nil
 	}
 	path.accessConds, path.tableFilters = ranger.DetachCondsForTableRange(ds.ctx, ds.pushedDownConds, pkCol)
 	// If there's no access cond, we try to find that whether there's expression containing correlated column that
@@ -387,17 +389,28 @@ func (ds *DataSource) deriveTablePathStats(path *accessPath) error {
 	}
 	if corColInAccessConds {
 		path.countAfterAccess = 1
-		return nil
+		return true, nil
 	}
 	path.ranges, err = ranger.BuildTableRange(path.accessConds, sc, pkCol.RetType)
 	if err != nil {
-		return errors.Trace(err)
+		return false, errors.Trace(err)
 	}
 	path.countAfterAccess, err = ds.statisticTable.GetRowCountByIntColumnRanges(sc, pkCol.ID, path.ranges)
-	return errors.Trace(err)
+	// Check whether the primary key is covered by point query.
+	noIntervalRange := true
+	for _, ran := range path.ranges {
+		if !ran.IsPoint(sc) {
+			noIntervalRange = false
+			break
+		}
+	}
+	return noIntervalRange, errors.Trace(err)
 }
 
-func (ds *DataSource) deriveIndexPathStats(path *accessPath) error {
+// deriveIndexPathStats will fulfill the information that the accessPath need.
+// And it will check whether this index is full matched by point query. We will use this check to
+// determine whether we remove other paths or not.
+func (ds *DataSource) deriveIndexPathStats(path *accessPath) (bool, error) {
 	var err error
 	sc := ds.ctx.GetSessionVars().StmtCtx
 	path.ranges = ranger.FullRange()
@@ -406,11 +419,11 @@ func (ds *DataSource) deriveIndexPathStats(path *accessPath) error {
 	if len(path.idxCols) != 0 {
 		path.ranges, path.accessConds, path.tableFilters, path.eqCondCount, err = ranger.DetachCondAndBuildRangeForIndex(ds.ctx, ds.pushedDownConds, path.idxCols, path.idxColLens)
 		if err != nil {
-			return errors.Trace(err)
+			return false, errors.Trace(err)
 		}
 		path.countAfterAccess, err = ds.statisticTable.GetRowCountByIndexRanges(sc, path.index.ID, path.ranges)
 		if err != nil {
-			return errors.Trace(err)
+			return false, errors.Trace(err)
 		}
 	} else {
 		path.tableFilters = ds.pushedDownConds
@@ -441,7 +454,27 @@ func (ds *DataSource) deriveIndexPathStats(path *accessPath) error {
 		}
 		path.countAfterIndex = math.Max(path.countAfterAccess*selectivity, ds.statsAfterSelect.count)
 	}
-	return nil
+	// Check whether there's only point query.
+	noIntervalRanges := true
+	haveNullVal := false
+	for _, ran := range path.ranges {
+		// Not point or the not full matched.
+		if !ran.IsPoint(sc) || len(ran.HighVal) != len(path.index.Columns) {
+			noIntervalRanges = false
+			break
+		}
+		// Check whether there's null value.
+		for i := 0; i < len(path.index.Columns); i++ {
+			if ran.HighVal[i].IsNull() {
+				haveNullVal = true
+				break
+			}
+		}
+		if haveNullVal {
+			break
+		}
+	}
+	return noIntervalRanges && !haveNullVal, nil
 }
 
 func (path *accessPath) splitCorColAccessCondFromFilters() (access, remained []expression.Expression) {

plan/stats.go

@@ -128,16 +128,28 @@ func (ds *DataSource) deriveStats() (*statsInfo, error) {
 	ds.statsAfterSelect = ds.getStatsByFilter(ds.pushedDownConds)
 	for _, path := range ds.possibleAccessPaths {
 		if path.isTablePath {
-			err := ds.deriveTablePathStats(path)
+			noIntervalRanges, err := ds.deriveTablePathStats(path)
 			if err != nil {
 				return nil, errors.Trace(err)
 			}
+			// If there's only point range. Just remove other possible paths.
+			if noIntervalRanges {
+				ds.possibleAccessPaths[0] = path
+				ds.possibleAccessPaths = ds.possibleAccessPaths[:1]
+				break
+			}
 			continue
 		}
-		err := ds.deriveIndexPathStats(path)
+		noIntervalRanges, err := ds.deriveIndexPathStats(path)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
+		// If there's only point range and this index is unique key. Just remove other possible paths.
+		if noIntervalRanges && path.index.Unique {
+			ds.possibleAccessPaths[0] = path
+			ds.possibleAccessPaths = ds.possibleAccessPaths[:1]
+			break
+		}
 	}
 	return ds.statsAfterSelect, nil
 }

statistics/selectivity_test.go

@@ -205,8 +205,8 @@ func (s *testSelectivitySuite) TestPseudoSelectivity(c *C) {
 	testKit.MustExec("drop table if exists t, t1")
 	testKit.MustExec("create table t(a int, b int, unique key idx(a,b))")
 	testKit.MustQuery("explain select * from t where a = 1 and b = 1").Check(testkit.Rows(
-		"IndexReader_9 root index:IndexScan_8 1.00",
-		"└─IndexScan_8 cop table:t, index:a, b, range:[1 1,1 1], keep order:false 1.00"))
+		"IndexReader_6 root index:IndexScan_5 1.00",
+		"└─IndexScan_5 cop table:t, index:a, b, range:[1 1,1 1], keep order:false 1.00"))
 
 	testKit.MustExec("create table t1(a int, b int, primary key(a))")
 	testKit.MustQuery("explain select b from t1 where a = 1").Check(testkit.Rows(