planner, expression: converting to TableDual only when the empty range is not derived from deferred constants (#7579)

executor/prepared_test.go

@@ -322,3 +322,46 @@ func generateBatchSQL(paramCount int) (sql string, paramSlice []interface{}) {
 	}
 	return "insert into t values " + strings.Join(placeholders, ","), params
 }
+
+func (s *testSuite) TestPreparedIssue7579(c *C) {
+	orgEnable := plannercore.PreparedPlanCacheEnabled()
+	orgCapacity := plannercore.PreparedPlanCacheCapacity
+	defer func() {
+		plannercore.SetPreparedPlanCache(orgEnable)
+		plannercore.PreparedPlanCacheCapacity = orgCapacity
+	}()
+	flags := []bool{false, true}
+	for _, flag := range flags {
+		plannercore.SetPreparedPlanCache(flag)
+		plannercore.PreparedPlanCacheCapacity = 100
+		tk := testkit.NewTestKit(c, s.store)
+		tk.MustExec("use test")
+		tk.MustExec("drop table if exists t")
+		tk.MustExec("create table t (a int, b int, index a_idx(a))")
+		tk.MustExec("insert into t values (1,1), (2,2), (null,3)")
+
+		r := tk.MustQuery("select a, b from t order by b asc;")
+		r.Check(testkit.Rows("1 1", "2 2", "<nil> 3"))
+
+		tk.MustExec(`prepare stmt from 'select a, b from t where ? order by b asc'`)
+
+		r = tk.MustQuery(`execute stmt using @param;`)
+		r.Check(nil)
+
+		tk.MustExec(`set @param = true`)
+		r = tk.MustQuery(`execute stmt using @param;`)
+		r.Check(testkit.Rows("1 1", "2 2", "<nil> 3"))
+
+		tk.MustExec(`set @param = false`)
+		r = tk.MustQuery(`execute stmt using @param;`)
+		r.Check(nil)
+
+		tk.MustExec(`set @param = 1`)
+		r = tk.MustQuery(`execute stmt using @param;`)
+		r.Check(testkit.Rows("1 1", "2 2", "<nil> 3"))
+
+		tk.MustExec(`set @param = 0`)
+		r = tk.MustQuery(`execute stmt using @param;`)
+		r.Check(nil)
+	}
+}

expression/util.go

@@ -191,7 +191,7 @@ func SubstituteCorCol2Constant(expr Expression) (Expression, error) {
 	case *Constant:
 		if x.DeferredExpr != nil {
 			newExpr := FoldConstant(x)
-			return &Constant{Value: newExpr.(*Constant).Value, RetType: x.GetType()}, nil
+			return &Constant{Value: newExpr.(*Constant).Value, RetType: x.GetType(), DeferredExpr: x.DeferredExpr}, nil
 		}
 	}
 	return expr, nil

planner/core/find_best_task.go

@@ -179,7 +179,7 @@ func (ds *DataSource) tryToGetMemTask(prop *property.PhysicalProperty) (task tas
 // tryToGetDualTask will check if the push down predicate has false constant. If so, it will return table dual.
 func (ds *DataSource) tryToGetDualTask() (task, error) {
 	for _, cond := range ds.pushedDownConds {
-		if _, ok := cond.(*expression.Constant); ok {
+		if con, ok := cond.(*expression.Constant); ok && con.DeferredExpr == nil {
 			result, err := expression.EvalBool(ds.ctx, []expression.Expression{cond}, chunk.Row{})
 			if err != nil {
 				return nil, errors.Trace(err)

planner/core/logical_plan_builder.go

@@ -470,7 +470,7 @@ func (b *planBuilder) buildSelection(p LogicalPlan, where ast.ExprNode, AggMappe
 		}
 		cnfItems := expression.SplitCNFItems(expr)
 		for _, item := range cnfItems {
-			if con, ok := item.(*expression.Constant); ok {
+			if con, ok := item.(*expression.Constant); ok && con.DeferredExpr == nil {
 				ret, err := expression.EvalBool(b.ctx, expression.CNFExprs{con}, chunk.Row{})
 				if err != nil || ret {
 					continue