*: Selection can control the conditions of the below scan plan.

executor/builder.go

@@ -471,10 +471,14 @@ func (b *executorBuilder) buildAggregation(v *plan.PhysicalAggregation) Executor
 
 func (b *executorBuilder) buildSelection(v *plan.Selection) Executor {
 	exec := &SelectionExec{
-		Src:       b.build(v.Children()[0]),
-		Condition: expression.ComposeCNFCondition(b.ctx, v.Conditions...),
-		schema:    v.Schema(),
-		ctx:       b.ctx,
+		Src:                 b.build(v.Children()[0]),
+		Condition:           expression.ComposeCNFCondition(b.ctx, v.Conditions...),
+		schema:              v.Schema(),
+		ctx:                 b.ctx,
+		scanController:      v.ScanController,
+		accessConditions:    v.AccessConditions,
+		idxFilterConditions: v.IdxConditions,
+		tblFilterConditions: v.TblConditions,
 	}
 	return exec
 }

executor/executor.go

@@ -461,21 +461,91 @@ func (e *TableDualExec) Close() error {
 	return nil
 }
 
+func substituteCorCol2Constant(expr expression.Expression) (expression.Expression) {
+	switch x := expr.(type) {
+	case *expression.ScalarFunction:
+		newArgs := make([]expression.Expression, 0, len(x.GetArgs()))
+		for _, arg := range x.GetArgs() {
+			newArgs = append(newArgs, substituteCorCol2Constant(arg))
+		}
+		newSf, _ := expression.NewFunction(x.GetCtx(), x.FuncName.L, x.GetType(), newArgs...)
+		return newSf, nil
+	case *expression.CorrelatedColumn:
+		return &expression.Constant{Value: x.Data, RetType: x.GetType()}
+	default:
+		return x.Clone()
+	}
+}
+
 // SelectionExec represents a filter executor.
 type SelectionExec struct {
 	Src       Executor
 	Condition expression.Expression
 	ctx       context.Context
 	schema    *expression.Schema
+
+	// scanController will tell whether this selection need to
+	// control the condition of below scan executor.
+	scanController      bool
+	controllerInit      bool
+	accessConditions    []expression.Expression
+	idxFilterConditions []expression.Expression
+	tblFilterConditions []expression.Expression
 }
 
 // Schema implements the Executor Schema interface.
 func (e *SelectionExec) Schema() *expression.Schema {
 	return e.schema
 }
 
+// initController will init the conditions of the below scan executor.
+func (e *SelectionExec) initController() error {
+	sc := e.ctx.GetSessionVars().StmtCtx
+	client := e.ctx.GetClient()
+	accesses := make([]expression.Expression, 0, len(e.accessConditions))
+	for _, cond := range e.accessConditions {
+		newCond := substituteCorCol2Constant(cond)
+		accesses = append(accesses, newCond)
+	}
+	switch x := e.Src.(type) {
+	case *XSelectTableExec:
+		ranges, err := plan.BuildTableRange(accesses, sc)
+		if err != nil {
+			return errors.Trace(err)
+		}
+		x.ranges = ranges
+		tblFilters := make([]expression.Expression, 0, len(e.tblFilterConditions))
+		for _, cond := range e.tblFilterConditions {
+			newCond := substituteCorCol2Constant(cond)
+			tblFilters = append(tblFilters, newCond)
+		}
+		var conds []expression.Expression
+		x.where, _, conds = plan.ExpressionsToPB(sc, tblFilters, client)
+		e.Condition = expression.ComposeCNFCondition(e.ctx, conds...)
+		return nil
+	case *XSelectIndexExec:
+		x.indexPlan.AccessCondition = accesses
+		err := plan.BuildIndexRange(sc, x.indexPlan)
+		if err != nil {
+			return errors.Trace(err)
+		}
+		x.indexPlan.IndexConditionPBExpr, _, _ = plan.ExpressionsToPB(sc, e.idxFilterConditions, client)
+		x.indexPlan.TableConditionPBExpr, _, _ = plan.ExpressionsToPB(sc, e.tblFilterConditions, client)
+		return nil
+	default:
+		return errors.New("Error type of PhysicalPlan")
+	}
+}
+
 // Next implements the Executor Next interface.
 func (e *SelectionExec) Next() (*Row, error) {
+	if e.scanController && !e.controllerInit {
+		err := e.initController()
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+		e.controllerInit = true
+	}
 	for {
 		srcRow, err := e.Src.Next()
 		if err != nil {
@@ -484,6 +554,9 @@ func (e *SelectionExec) Next() (*Row, error) {
 		if srcRow == nil {
 			return nil, nil
 		}
+		if e.Condition == nil {
+			return srcRow, nil
+		}
 		match, err := expression.EvalBool(e.Condition, srcRow.Data, e.ctx)
 		if err != nil {
 			return nil, errors.Trace(err)
@@ -496,6 +569,9 @@ func (e *SelectionExec) Next() (*Row, error) {
 
 // Close implements the Executor Close interface.
 func (e *SelectionExec) Close() error {
+	if e.scanController {
+		e.controllerInit = false
+	}
 	return e.Src.Close()
 }
 

plan/expr_to_pb.go

@@ -25,7 +25,8 @@ import (
 	"github.com/pingcap/tipb/go-tipb"
 )
 
-func expressionsToPB(sc *variable.StatementContext, exprs []expression.Expression, client kv.Client) (pbExpr *tipb.Expr, pushed []expression.Expression, remained []expression.Expression) {
+// ExpressionsToPB change expression to tipb.Expr.
+func ExpressionsToPB(sc *variable.StatementContext, exprs []expression.Expression, client kv.Client) (pbExpr *tipb.Expr, pushed []expression.Expression, remained []expression.Expression) {
 	pc := pbConverter{client: client, sc: sc}
 	for _, expr := range exprs {
 		v := pc.exprToPB(expr)

plan/logical_plans.go

@@ -146,6 +146,13 @@ type Selection struct {
 
 	// onTable means if this selection's child is a table scan or index scan.
 	onTable bool
+
+	// If ScanController is true, then the child of this selection is a scan,
+	// which use pk or index
+	ScanController   bool
+	AccessConditions []expression.Expression
+	IdxConditions    []expression.Expression
+	TblConditions    []expression.Expression
 }
 
 func (p *Selection) extractCorrelatedCols() []*expression.CorrelatedColumn {