expression, session: handle CASE WHEN specially when folding constant during outerJoin Simplification

expression/constant_fold.go

@@ -15,6 +15,7 @@ package expression
 
 import (
 	"github.com/pingcap/parser/ast"
+	"github.com/pingcap/tidb/types"
 	"github.com/pingcap/tidb/util/chunk"
 	"github.com/pingcap/tidb/util/logutil"
 	"go.uber.org/zap"
@@ -27,6 +28,7 @@ func init() {
 	specialFoldHandler = map[string]func(*ScalarFunction) (Expression, bool){
 		ast.If:     ifFoldHandler,
 		ast.Ifnull: ifNullFoldHandler,
+		ast.Case:   caseWhenHandler,
 	}
 }
 
@@ -78,6 +80,52 @@ func ifNullFoldHandler(expr *ScalarFunction) (Expression, bool) {
 	return expr, isDeferredConst
 }
 
+func caseWhenHandler(expr *ScalarFunction) (Expression, bool) {
+	args, l := expr.GetArgs(), len(expr.GetArgs())
+	isFirstCondition := true
+	isDeferredConst := false
+	for i := 0; i < l-1; i += 2 {
+		foldedArg, isDeferred := foldConstant(args[i])
+		expr.GetArgs()[i] = foldedArg
+		isDeferredConst = isDeferredConst || isDeferred
+		if _, isConst := foldedArg.(*Constant); isConst {
+			condition, isNull, err := args[i].EvalInt(expr.GetCtx(), chunk.Row{})
+			if err != nil {
+				return expr, false
+			}
+			if isFirstCondition && condition != 0 && !isNull {
+				return retProcess(args[i+1], expr.GetType(), isDeferredConst)
+			}
+		} else {
+			isFirstCondition = false
+		}
+		foldedArg1, isDeferred1 := foldConstant(args[i+1])
+		expr.GetArgs()[i+1] = foldedArg1
+		isDeferredConst = isDeferredConst || isDeferred1
+	}
+
+	if l%2 == 1 && isFirstCondition {
+		return retProcess(args[l-1], expr.GetType(), isDeferredConst)
+	} else if l%2 == 1 {
+		foldedArg, isDeferred := foldConstant(args[l-1])
+		expr.GetArgs()[l-1] = foldedArg
+		isDeferredConst = isDeferredConst || isDeferred
+	}
+
+	return expr, isDeferredConst
+}
+
+func retProcess(expr Expression, retType *types.FieldType, isDeferredConst bool) (Expression, bool) {
+	foldedExpr, isDeferred := foldConstant(expr)
+	isDeferredConst = isDeferredConst || isDeferred
+	if fc, isConst := foldedExpr.(*Constant); isConst {
+		fc.RetType = retType
+		return fc, isDeferredConst
+	}
+
+	return foldedExpr, isDeferredConst
+}
+
 func foldConstant(expr Expression) (Expression, bool) {
 	switch x := expr.(type) {
 	case *ScalarFunction:

session/session_test.go

@@ -2722,3 +2722,16 @@ func (s *testSessionSuite) TestLoadClientInteractive(c *C) {
 	tk.Se.GetSessionVars().ClientCapability = tk.Se.GetSessionVars().ClientCapability | mysql.ClientInteractive
 	tk.MustQuery("select @@wait_timeout").Check(testkit.Rows("28800"))
 }
+
+func (s *testSessionSuite) TestFuncCaseWithLeftJoin(c *C) {
+	tk := testkit.NewTestKitWithInit(c, s.store)
+
+	tk.MustExec("create table kankan1(id int, name text)")
+	tk.MustExec("insert into kankan1 values(1, 'a')")
+	tk.MustExec("insert into kankan1 values(2, 'a')")
+
+	tk.MustExec("create table kankan2(id int, h1 text)")
+	tk.MustExec("insert into kankan2 values(2, 'z')")
+
+	tk.MustQuery("select t1.id from kankan1 t1 left join kankan2 t2 on t1.id = t2.id where (case  when t1.name='b' then 'case2' when t1.name='a' then 'case1' else NULL end) = 'case1' order by t1.id").Check(testkit.Rows("1", "2"))
+}