planner,expression: use constraint propagation in partition pruning

expression/constraint_propagation.go

@@ -250,7 +250,7 @@ func ruleColumnOPConst(ctx sessionctx.Context, i, j int, exprs *exprSet) {
 			return
 		}
 	}
-	if !col1.Equal(ctx, col2) {
+	if col1.ColName.L != col2.ColName.L {
 		return
 	}
 	v, isNull, err := compareConstant(ctx, negOP(OP2), fc1, con2)
@@ -302,3 +302,8 @@ func compareConstant(ctx sessionctx.Context, fn string, c1, c2 Expression) (int6
 	}
 	return cmp.EvalInt(ctx, chunk.Row{})
 }
+
+// NewPartitionPruneSolver returns a constraintSolver for partition pruning.
+func NewPartitionPruneSolver() constraintSolver {
+	return newConstraintSolver(ruleColumnOPConst)
+}

planner/core/logical_plans.go

@@ -300,6 +300,8 @@ type DataSource struct {
 
 	// pushedDownConds are the conditions that will be pushed down to coprocessor.
 	pushedDownConds []expression.Expression
+	// allConds include those conditions that can be pushed down and can't be.
+	allConds []expression.Expression
 
 	// relevantIndices means the indices match the push down conditions
 	relevantIndices []bool

planner/core/partition_pruning_test.go

@@ -0,0 +1,59 @@
+// Copyright 2018 PingCAP, 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 core_test
+
+import (
+	. "github.com/pingcap/check"
+	"github.com/pingcap/parser"
+	"github.com/pingcap/parser/ast"
+	"github.com/pingcap/tidb/ddl"
+	"github.com/pingcap/tidb/expression"
+	"github.com/pingcap/tidb/planner/core"
+	"github.com/pingcap/tidb/util/mock"
+)
+
+var _ = Suite(&testPartitionPruningSuite{})
+
+type testPartitionPruningSuite struct{}
+
+func (s *testPartitionPruningSuite) TestCanBePrune(c *C) {
+	p := parser.New()
+	stmt, err := p.ParseOneStmt("create table t (d datetime not null)", "", "")
+	c.Assert(err, IsNil)
+	tblInfo, err := ddl.BuildTableInfoFromAST(stmt.(*ast.CreateTableStmt))
+	c.Assert(err, IsNil)
+
+	// For the following case:
+	// CREATE TABLE t1 ( recdate  DATETIME NOT NULL )
+	// PARTITION BY RANGE( TO_DAYS(recdate) ) (
+	// 	PARTITION p0 VALUES LESS THAN ( TO_DAYS('2007-03-08') ),
+	// 	PARTITION p1 VALUES LESS THAN ( TO_DAYS('2007-04-01') )
+	// );
+	// SELECT * FROM t1 WHERE recdate < '2007-03-08 00:00:00';
+	// SELECT * FROM t1 WHERE recdate > '2018-03-08 00:00:00';
+
+	ctx := mock.NewContext()
+	partitionExpr, err := expression.ParseSimpleExprWithTableInfo(ctx, "to_days(d) < to_days('2007-03-08') and to_days(d) >= to_days('2007-03-07')", tblInfo)
+	c.Assert(err, IsNil)
+	queryExpr, err := expression.ParseSimpleExprWithTableInfo(ctx, "d < '2000-03-08 00:00:00'", tblInfo)
+	c.Assert(err, IsNil)
+	succ, err := core.CanBePruned(ctx, partitionExpr, []expression.Expression{queryExpr})
+	c.Assert(err, IsNil)
+	c.Assert(succ, IsTrue)
+
+	queryExpr, err = expression.ParseSimpleExprWithTableInfo(ctx, "d > '2018-03-08 00:00:00'", tblInfo)
+	c.Assert(err, IsNil)
+	succ, err = core.CanBePruned(ctx, partitionExpr, []expression.Expression{queryExpr})
+	c.Assert(err, IsNil)
+	c.Assert(succ, IsTrue)
+}

planner/core/planbuilder_test.go

@@ -17,8 +17,16 @@ import (
 	. "github.com/pingcap/check"
 	"github.com/pingcap/parser/ast"
 	"github.com/pingcap/parser/model"
+	"github.com/pingcap/tidb/expression"
+	"github.com/pingcap/tidb/sessionctx"
 )
 
+// CanBePruned is provided for testing.
+func CanBePruned(sctx sessionctx.Context, partitionExpr expression.Expression, filterExprs []expression.Expression) (bool, error) {
+	var s partitionProcessor
+	return s.canBePruned(sctx, nil, partitionExpr, filterExprs)
+}
+
 var _ = Suite(&testPlanBuilderSuite{})
 
 func (s *testPlanBuilderSuite) SetUpSuite(c *C) {

planner/core/rule_partition_processor.go

@@ -17,6 +17,7 @@ import (
 	"github.com/pingcap/tidb/expression"
 	"github.com/pingcap/tidb/sessionctx"
 	"github.com/pingcap/tidb/table/tables"
+	"github.com/pingcap/tidb/util/chunk"
 	"github.com/pingcap/tidb/util/ranger"
 )
 
@@ -37,9 +38,6 @@ import (
 type partitionProcessor struct{}
 
 func (s *partitionProcessor) optimize(lp LogicalPlan) (LogicalPlan, error) {
-	// NOTE: partitionProcessor will assume all filter conditions are pushed down to
-	// DataSource, there will not be a Selection->DataSource case, so the rewrite just
-	// handle the DataSource node.
 	return s.rewriteDataSource(lp)
 }
 
@@ -87,15 +85,13 @@ func (s *partitionProcessor) prune(ds *DataSource) (LogicalPlan, error) {
 	// partitions according to the filter conditions pushed to the DataSource.
 	children := make([]LogicalPlan, 0, len(pi.Definitions))
 	for i, expr := range partitionExprs {
-		if col != nil {
-			// If the selection condition would never be satisified, prune that partition.
-			prune, err := s.canBePrune(ds.context(), col, expr, ds.pushedDownConds)
-			if err != nil {
-				return nil, errors.Trace(err)
-			}
-			if prune {
-				continue
-			}
+		// If the selection condition would never be satisified, prune that partition.
+		prune, err := s.canBePruned(ds.context(), col, expr, ds.allConds)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+		if prune {
+			continue
 		}
 
 		// Not a deep copy.
@@ -126,17 +122,37 @@ func (s *partitionProcessor) prune(ds *DataSource) (LogicalPlan, error) {
 	return unionAll, nil
 }
 
-// canBePrune checks if partition expression will never meets the selection condition.
+var solver = expression.NewPartitionPruneSolver()
+
+// canBePruned checks if partition expression will never meets the selection condition.
 // For example, partition by column a > 3, and select condition is a < 3, then canBePrune returns true.
-func (s *partitionProcessor) canBePrune(ctx sessionctx.Context, col *expression.Column, partitionCond expression.Expression, copConds []expression.Expression) (bool, error) {
-	conds := make([]expression.Expression, 0, 1+len(copConds))
-	conds = append(conds, partitionCond)
-	conds = append(conds, copConds...)
-	conds = expression.PropagateConstant(ctx, conds)
+func (s *partitionProcessor) canBePruned(sctx sessionctx.Context, partCol *expression.Column, partitionExpr expression.Expression, filterExprs []expression.Expression) (bool, error) {
+	conds := make([]expression.Expression, 0, 1+len(filterExprs))
+	conds = append(conds, partitionExpr)
+	conds = append(conds, filterExprs...)
+	conds = expression.PropagateConstant(sctx, conds)
+	conds = solver.Solve(sctx, conds)
+
+	if len(conds) == 1 {
+		// Constant false.
+		if con, ok := conds[0].(*expression.Constant); ok && con.DeferredExpr == nil {
+			ret, err := expression.EvalBool(sctx, expression.CNFExprs{con}, chunk.Row{})
+			if err == nil && ret == false {
+				return true, nil
+			}
+		}
+	}
+
+	if partCol == nil {
+		return false, nil
+	}
 
 	// Calculate the column range to prune.
-	accessConds := ranger.ExtractAccessConditionsForColumn(conds, col.UniqueID)
-	r, err := ranger.BuildColumnRange(accessConds, ctx.GetSessionVars().StmtCtx, col.RetType)
+	// TODO: Remove prune by calculating range. Current constraint propagate doesn't
+	// handle the null condition, while calculate range can prune something like:
+	// "select * from t where t is null"
+	accessConds := ranger.ExtractAccessConditionsForColumn(conds, partCol.UniqueID)
+	r, err := ranger.BuildColumnRange(accessConds, sctx.GetSessionVars().StmtCtx, partCol.RetType)
 	if err != nil {
 		return false, errors.Trace(err)
 	}

planner/core/rule_predicate_push_down.go

@@ -99,6 +99,7 @@ func (p *LogicalUnionScan) PredicatePushDown(predicates []expression.Expression)
 
 // PredicatePushDown implements LogicalPlan PredicatePushDown interface.
 func (ds *DataSource) PredicatePushDown(predicates []expression.Expression) ([]expression.Expression, LogicalPlan) {
+	ds.allConds = predicates
 	_, ds.pushedDownConds, predicates = expression.ExpressionsToPB(ds.ctx.GetSessionVars().StmtCtx, predicates, ds.ctx.GetClient())
 	return predicates, ds
 }