planner: remove useless predicates after partition pruning

planner/core/partition_prune.go

@@ -37,7 +37,7 @@ func PartitionPruning(ctx sessionctx.Context, tbl table.PartitionedTable, conds
 	case model.PartitionTypeHash:
 		return s.pruneHashPartition(ctx, tbl, partitionNames, conds, columns, names)
 	case model.PartitionTypeRange:
-		rangeOr, err := s.pruneRangePartition(ctx, pi, tbl, conds, columns, names)
+		rangeOr, _, err := s.pruneRangePartition(ctx, pi, tbl, conds, columns, names, nil)
 		if err != nil {
 			return nil, err
 		}

planner/core/partition_pruner_test.go

@@ -454,3 +454,34 @@ partition by range (a) (
 	tk.MustQuery("select * from t3 where not (a = 1)").Sort().Check(testkit.Rows("11", "12", "13", "2", "3"))
 	tk.MustQuery("select * from t3 where not (a != 1)").Check(testkit.Rows("1"))
 }
+
+//issue 22079
+func (s *testPartitionPruneSuit) TestRangePartitionPredicatePruner(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	tk.MustExec("set @@tidb_partition_prune_mode='" + string(variable.Static) + "'")
+	tk.MustExec("drop database if exists test_partition;")
+	tk.MustExec("create database test_partition")
+	tk.MustExec("use test_partition")
+	tk.MustExec("drop table if exists t")
+	tk.Se.GetSessionVars().EnableClusteredIndex = variable.ClusteredIndexDefModeIntOnly
+	tk.MustExec(`create table t (a int(11) default null) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin
+		partition by range(a) (
+		partition p0 values less than (1), 
+		partition p1 values less than (2), 
+		partition p2 values less than (3), 
+		partition p_max values less than (maxvalue));`)
+
+	var input []string
+	var output []struct {
+		SQL    string
+		Result []string
+	}
+	s.testData.GetTestCases(c, &input, &output)
+	for i, tt := range input {
+		s.testData.OnRecord(func() {
+			output[i].SQL = tt
+			output[i].Result = s.testData.ConvertRowsToStrings(tk.MustQuery(tt).Rows())
+		})
+		tk.MustQuery(tt).Check(testkit.Rows(output[i].Result...))
+	}
+}

planner/core/rule_partition_processor.go

@@ -771,25 +771,26 @@ func intersectionRange(start, end, newStart, newEnd int) (int, int) {
 }
 
 func (s *partitionProcessor) pruneRangePartition(ctx sessionctx.Context, pi *model.PartitionInfo, tbl table.PartitionedTable, conds []expression.Expression,
-	columns []*expression.Column, names types.NameSlice) (partitionRangeOR, error) {
+	columns []*expression.Column, names types.NameSlice, condsToBePruned *[]expression.Expression) (partitionRangeOR, []expression.Expression, error) {
 	partExpr, err := tbl.(partitionTable).PartitionExpr()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	// Partition by range columns.
 	if len(pi.Columns) > 0 {
-		return s.pruneRangeColumnsPartition(ctx, conds, pi, partExpr, columns, names)
+		result, err := s.pruneRangeColumnsPartition(ctx, conds, pi, partExpr, columns, names)
+		return result, nil, err
 	}
 
 	// Partition by range.
 	col, fn, mono, err := makePartitionByFnCol(ctx, columns, names, pi.Expr)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	result := fullRange(len(pi.Definitions))
 	if col == nil {
-		return result, nil
+		return result, nil, nil
 	}
 
 	// Extract the partition column, if the column is not null, it's possible to prune.
@@ -803,14 +804,42 @@ func (s *partitionProcessor) pruneRangePartition(ctx sessionctx.Context, pi *mod
 		monotonous: mono,
 	}
 	result = partitionRangeForCNFExpr(ctx, conds, &pruner, result)
-	return result, nil
+
+	if condsToBePruned == nil {
+		return result, nil, nil
+	}
+	// remove useless predicates after partition pruning
+	newConds := make([]expression.Expression, 0, len(*condsToBePruned))
+	for _, cond := range *condsToBePruned {
+		if dataForPrune, ok := pruner.extractDataForPrune(ctx, cond); ok {
+			switch dataForPrune.op {
+			case ast.EQ:
+				unsigned := mysql.HasUnsignedFlag(pruner.col.RetType.Flag)
+				start, _ := pruneUseBinarySearch(pruner.lessThan, dataForPrune, unsigned)
+				// if the type of partition key is Int
+				if pk, ok := partExpr.Expr.(*expression.Column); ok && pk.RetType.EvalType() == types.ETInt {
+					// see if can be removed
+					// see issue #22079: https://github.com/pingcap/tidb/issues/22079 for details
+					if start > 0 && pruner.lessThan.data[start-1] == dataForPrune.c && (pruner.lessThan.data[start]-1) == dataForPrune.c {
+						continue
+					}
+				}
+			}
+		}
+		newConds = append(newConds, cond)
+	}
+
+	return result, newConds, nil
 }
 
 func (s *partitionProcessor) processRangePartition(ds *DataSource, pi *model.PartitionInfo) (LogicalPlan, error) {
-	used, err := s.pruneRangePartition(ds.ctx, pi, ds.table.(table.PartitionedTable), ds.allConds, ds.TblCols, ds.names)
+	used, prunedConds, err := s.pruneRangePartition(ds.ctx, pi, ds.table.(table.PartitionedTable), ds.allConds, ds.TblCols, ds.names, &ds.pushedDownConds)
 	if err != nil {
 		return nil, err
 	}
+	if prunedConds != nil {
+		ds.pushedDownConds = prunedConds
+	}
 	return s.makeUnionAllChildren(ds, pi, used)
 }
 

planner/core/testdata/partition_pruner_in.json

@@ -501,5 +501,17 @@
         "Pruner": "t1: p0,p1; t2: p0"
       }
     ]
+  },
+  {
+    "name": "TestRangePartitionPredicatePruner",
+    "cases": [
+      "explain format = 'brief' select * from t where a = 1",
+      "explain format = 'brief' select * from t where a = 2",
+      "explain format = 'brief' select * from t where a = 10",
+      "explain format = 'brief' select * from t where a = -1",
+      "explain format = 'brief' select * from t where a is NULL",
+      "explain format = 'brief' select * from t where a = 1.5",
+      "explain format = 'brief' select * from t where a in (2)"
+    ]
   }
 ]

planner/core/testdata/partition_pruner_out.json

@@ -2827,5 +2827,73 @@
         ]
       }
     ]
+  },
+  {
+    "Name": "TestRangePartitionPredicatePruner",
+    "Cases": [
+      {
+        "SQL": "explain format = 'brief' select * from t where a = 1",
+        "Result": [
+          "TableReader 10000.00 root  data:TableFullScan",
+          "└─TableFullScan 10000.00 cop[tikv] table:t, partition:p1 keep order:false, stats:pseudo"
+        ]
+      },
+      {
+        "SQL": "explain format = 'brief' select * from t where a = 2",
+        "Result": [
+          "TableReader 10000.00 root  data:TableFullScan",
+          "└─TableFullScan 10000.00 cop[tikv] table:t, partition:p2 keep order:false, stats:pseudo"
+        ]
+      },
+      {
+        "SQL": "explain format = 'brief' select * from t where a = 10",
+        "Result": [
+          "TableReader 10.00 root  data:Selection",
+          "└─Selection 10.00 cop[tikv]  eq(test_partition.t.a, 10)",
+          "  └─TableFullScan 10000.00 cop[tikv] table:t, partition:p_max keep order:false, stats:pseudo"         
+        ]
+      },
+      {
+        "SQL": "explain format = 'brief' select * from t where a = -1",
+        "Result": [
+          "TableReader 10.00 root  data:Selection",
+          "└─Selection 10.00 cop[tikv]  eq(test_partition.t.a, -1)",
+          "  └─TableFullScan 10000.00 cop[tikv] table:t, partition:p0 keep order:false, stats:pseudo"         
+        ]
+      },
+      {
+        "SQL": "explain format = 'brief' select * from t where a is NULL",
+        "Result": [
+          "TableReader 10.00 root  data:Selection",
+          "└─Selection 10.00 cop[tikv]  isnull(test_partition.t.a)",
+          "  └─TableFullScan 10000.00 cop[tikv] table:t, partition:p0 keep order:false, stats:pseudo"
+        ]
+      },
+      {
+        "SQL": "explain format = 'brief' select * from t where a = 1.5",
+        "Result": [
+          "PartitionUnion 32000.00 root  ",
+          "├─TableReader 8000.00 root  data:Selection",
+          "│ └─Selection 8000.00 cop[tikv]  eq(cast(test_partition.t.a, decimal(20,0) BINARY), 1.5)",
+          "│   └─TableFullScan 10000.00 cop[tikv] table:t, partition:p0 keep order:false, stats:pseudo",
+          "├─TableReader 8000.00 root  data:Selection",
+          "│ └─Selection 8000.00 cop[tikv]  eq(cast(test_partition.t.a, decimal(20,0) BINARY), 1.5)",
+          "│   └─TableFullScan 10000.00 cop[tikv] table:t, partition:p1 keep order:false, stats:pseudo",
+          "├─TableReader 8000.00 root  data:Selection",
+          "│ └─Selection 8000.00 cop[tikv]  eq(cast(test_partition.t.a, decimal(20,0) BINARY), 1.5)",
+          "│   └─TableFullScan 10000.00 cop[tikv] table:t, partition:p2 keep order:false, stats:pseudo",
+          "└─TableReader 8000.00 root  data:Selection",
+          "  └─Selection 8000.00 cop[tikv]  eq(cast(test_partition.t.a, decimal(20,0) BINARY), 1.5)",
+          "    └─TableFullScan 10000.00 cop[tikv] table:t, partition:p_max keep order:false, stats:pseudo"
+        ]
+      },
+      {
+        "SQL": "explain format = 'brief' select * from t where a in (2)",
+        "Result": [
+          "TableReader 10000.00 root  data:TableFullScan",
+          "└─TableFullScan 10000.00 cop[tikv] table:t, partition:p2 keep order:false, stats:pseudo"
+        ]
+      }
+    ]
   }
 ]