planner: skip the optimizer for the execute statement

executor/compiler.go

@@ -28,6 +28,7 @@ import (
 	"github.com/pingcap/tidb/sessionctx"
 	"github.com/pingcap/tidb/sessiontxn"
 	"github.com/pingcap/tidb/sessiontxn/staleread"
+	"github.com/pingcap/tidb/types"
 )
 
 var (
@@ -77,9 +78,20 @@ func (c *Compiler) Compile(ctx context.Context, stmtNode ast.StmtNode) (*ExecStm
 	})
 
 	is := sessiontxn.GetTxnManager(c.Ctx).GetTxnInfoSchema()
-	finalPlan, names, err := planner.Optimize(ctx, c.Ctx, stmtNode, is)
-	if err != nil {
-		return nil, err
+	var (
+		finalPlan plannercore.Plan
+		names     types.NameSlice
+	)
+	if execAST, ok := stmtNode.(*ast.ExecuteStmt); ok {
+		finalPlan, names, err = planner.OptimizeExecStmt(ctx, c.Ctx, execAST, is)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		finalPlan, names, err = planner.Optimize(ctx, c.Ctx, stmtNode, is)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	failpoint.Inject("assertStmtCtxIsStaleness", func(val failpoint.Value) {

executor/prepared.go

@@ -324,7 +324,7 @@ func CompileExecutePreparedStmt(ctx context.Context, sctx sessionctx.Context,
 	defer func() {
 		sctx.GetSessionVars().DurationCompile = time.Since(startTime)
 	}()
-	execPlan, names, err := planner.Optimize(ctx, sctx, execStmt, is)
+	execPlan, names, err := planner.OptimizeExecStmt(ctx, sctx, execStmt, is)
 	if err != nil {
 		return nil, err
 	}

planner/core/plan_cache.go

@@ -58,6 +58,12 @@ func GetPlanFromSessionPlanCache(ctx context.Context, sctx sessionctx.Context, i
 	// rebuild the plan. So we set this value in rc or for update read. In other cases, let it be 0.
 	var latestSchemaVersion int64
 
+	if prepared.UseCache && prepared.CachedPlan != nil && !ignorePlanCache { // for point query plan
+		if plan, names, ok, err := getPointQueryPlan(prepared, sessVars, stmtCtx); ok {
+			return plan, names, err
+		}
+	}
+
 	if prepared.UseCache {
 		bindSQL, ignorePlanCache = GetBindSQL4PlanCache(sctx, preparedStmt)
 		if sctx.GetSessionVars().IsIsolation(ast.ReadCommitted) || preparedStmt.ForUpdateRead {
@@ -74,12 +80,6 @@ func GetPlanFromSessionPlanCache(ctx context.Context, sctx sessionctx.Context, i
 
 	varsNum, txtVarTypes := parseParamTypes(sctx, txtProtoVars)
 
-	if prepared.UseCache && prepared.CachedPlan != nil && !ignorePlanCache { // for point query plan
-		if plan, names, ok, err := getPointQueryPlan(prepared, sessVars, stmtCtx); ok {
-			return plan, names, err
-		}
-	}
-
 	if prepared.UseCache && !ignorePlanCache { // for general plans
 		if plan, names, ok, err := getGeneralPlan(ctx, sctx, cacheKey, bindSQL, is, preparedStmt,
 			txtVarTypes); err != nil || ok {

planner/optimize.go

@@ -305,31 +305,16 @@ func optimize(ctx context.Context, sctx sessionctx.Context, node ast.Node, is in
 	})
 
 	// build logical plan
-	sctx.GetSessionVars().PlanID = 0
-	sctx.GetSessionVars().PlanColumnID = 0
-	sctx.GetSessionVars().MapHashCode2UniqueID4ExtendedCol = nil
 	hintProcessor := &hint.BlockHintProcessor{Ctx: sctx}
 	node.Accept(hintProcessor)
-
-	failpoint.Inject("mockRandomPlanID", func() {
-		sctx.GetSessionVars().PlanID = rand.Intn(1000) // nolint:gosec
-	})
-
 	builder := planBuilderPool.Get().(*core.PlanBuilder)
 	defer planBuilderPool.Put(builder.ResetForReuse())
-
 	builder.Init(sctx, is, hintProcessor)
-
-	// reset fields about rewrite
-	sctx.GetSessionVars().RewritePhaseInfo.Reset()
-	beginRewrite := time.Now()
-	p, err := builder.Build(ctx, node)
+	p, err := buildLogicalPlan(ctx, sctx, node, builder)
 	if err != nil {
 		return nil, nil, 0, err
 	}
-	sctx.GetSessionVars().RewritePhaseInfo.DurationRewrite = time.Since(beginRewrite)
 
-	sctx.GetSessionVars().StmtCtx.Tables = builder.GetDBTableInfo()
 	activeRoles := sctx.GetSessionVars().ActiveRoles
 	// Check privilege. Maybe it's better to move this to the Preprocess, but
 	// we need the table information to check privilege, which is collected
@@ -371,6 +356,56 @@ func optimize(ctx context.Context, sctx sessionctx.Context, node ast.Node, is in
 	return finalPlan, names, cost, err
 }
 
+// OptimizeExecStmt to handle the "execute" statement
+func OptimizeExecStmt(ctx context.Context, sctx sessionctx.Context,
+	execAst *ast.ExecuteStmt, is infoschema.InfoSchema) (core.Plan, types.NameSlice, error) {
+	builder := planBuilderPool.Get().(*core.PlanBuilder)
+	defer planBuilderPool.Put(builder.ResetForReuse())
+	builder.Init(sctx, is, nil)
+
+	p, err := buildLogicalPlan(ctx, sctx, execAst, builder)
+	if err != nil {
+		return nil, nil, err
+	}
+	if execPlan, ok := p.(*core.Execute); ok {
+		// Because for write stmt, TiFlash has a different results when lock the data in point get plan. We ban the TiFlash
+		// engine in not read only stmt.
+		sessVars := sctx.GetSessionVars()
+		if _, isolationReadContainTiFlash := sessVars.IsolationReadEngines[kv.TiFlash]; isolationReadContainTiFlash && !IsReadOnly(execAst, sessVars) {
+			delete(sessVars.IsolationReadEngines, kv.TiFlash)
+			defer func() {
+				sessVars.IsolationReadEngines[kv.TiFlash] = struct{}{}
+			}()
+		}
+
+		err = execPlan.OptimizePreparedPlan(ctx, sctx, is)
+		return execPlan, execPlan.OutputNames(), err
+	}
+	err = errors.Errorf("invalid result plan type, should be Execute")
+	return nil, nil, err
+}
+
+func buildLogicalPlan(ctx context.Context, sctx sessionctx.Context, node ast.Node, builder *core.PlanBuilder) (core.Plan, error) {
+	sctx.GetSessionVars().PlanID = 0
+	sctx.GetSessionVars().PlanColumnID = 0
+	sctx.GetSessionVars().MapHashCode2UniqueID4ExtendedCol = nil
+
+	failpoint.Inject("mockRandomPlanID", func() {
+		sctx.GetSessionVars().PlanID = rand.Intn(1000) // nolint:gosec
+	})
+
+	// reset fields about rewrite
+	sctx.GetSessionVars().RewritePhaseInfo.Reset()
+	beginRewrite := time.Now()
+	p, err := builder.Build(ctx, node)
+	if err != nil {
+		return nil, err
+	}
+	sctx.GetSessionVars().RewritePhaseInfo.DurationRewrite = time.Since(beginRewrite)
+	sctx.GetSessionVars().StmtCtx.Tables = builder.GetDBTableInfo()
+	return p, nil
+}
+
 // ExtractSelectAndNormalizeDigest extract the select statement and normalize it.
 func ExtractSelectAndNormalizeDigest(stmtNode ast.StmtNode, specifiledDB string) (ast.StmtNode, string, string, error) {
 	switch x := stmtNode.(type) {