From 23b44b43006db8021e4b82a6b10ff5683d85ad96 Mon Sep 17 00:00:00 2001 From: Rustin Liu Date: Tue, 17 Oct 2023 22:09:29 -0500 Subject: [PATCH] This is an automated cherry-pick of #47454 Signed-off-by: ti-chi-bot --- parser/ast/expressions.go | 2 +- planner/core/plan_test.go | 26 ++++++++++++++++ planner/core/point_get_plan.go | 55 ++++++++++++++++++++++++++++++---- 3 files changed, 77 insertions(+), 6 deletions(-) diff --git a/parser/ast/expressions.go b/parser/ast/expressions.go index 270c46218af61..717e347f2e5f9 100644 --- a/parser/ast/expressions.go +++ b/parser/ast/expressions.go @@ -959,7 +959,7 @@ type ParamMarkerExpr interface { SetOrder(int) } -// ParenthesesExpr is the parentheses expression. +// ParenthesesExpr is the parentheses' expression. type ParenthesesExpr struct { exprNode // Expr is the expression in parentheses. diff --git a/planner/core/plan_test.go b/planner/core/plan_test.go index 2e69205a2b9c6..c0b33338cf519 100644 --- a/planner/core/plan_test.go +++ b/planner/core/plan_test.go @@ -1164,3 +1164,29 @@ func TestIssue40535(t *testing.T) { tk.MustExec("(select /*+ agg_to_cop()*/ locate(t1.c3, t1.c3) as r0, t1.c3 as r1 from t1 where not( IsNull(t1.c1)) order by r0,r1) union all (select concat_ws(',', t2.c2, t2.c1) as r0, t2.c1 as r1 from t2 order by r0, r1) order by 1 limit 273;") require.Empty(t, tk.Session().LastMessage()) } +<<<<<<< HEAD:planner/core/plan_test.go +======= + +func TestIssue47445(t *testing.T) { + store, _ := testkit.CreateMockStoreAndDomain(t) + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test;") + tk.MustExec("CREATE TABLE golang1 ( `fcbpdt` CHAR (8) COLLATE utf8_general_ci NOT NULL, `fcbpsq` VARCHAR (20) COLLATE utf8_general_ci NOT NULL, `procst` char (4) COLLATE utf8_general_ci DEFAULT NULL,`cipstx` VARCHAR (105) COLLATE utf8_general_ci DEFAULT NULL, `cipsst` CHAR (4) COLLATE utf8_general_ci DEFAULT NULL, `dyngtg` VARCHAR(4) COLLATE utf8_general_ci DEFAULT NULL, `blncdt` VARCHAR (8) COLLATE utf8_general_ci DEFAULT NULL, PRIMARY KEY ( fcbpdt, fcbpsq ))") + tk.MustExec("insert into golang1 values('20230925','12023092502158016','abc','','','','')") + tk.MustExec("create table golang2 (`sysgrp` varchar(20) NOT NULL,`procst` varchar(8) NOT NULL,`levlid` int(11) NOT NULL,PRIMARY key (procst));") + tk.MustExec("insert into golang2 VALUES('COMMON','ACSC',90)") + tk.MustExec("insert into golang2 VALUES('COMMON','abc',8)") + tk.MustExec("insert into golang2 VALUES('COMMON','CH02',6)") + tk.MustExec("UPDATE golang1 a SET procst =(CASE WHEN ( SELECT levlid FROM golang2 b WHERE b.sysgrp = 'COMMON' AND b.procst = 'ACSC' ) > ( SELECT levlid FROM golang2 c WHERE c.sysgrp = 'COMMON' AND c.procst = a.procst ) THEN 'ACSC' ELSE a.procst END ), cipstx = 'CI010000', cipsst = 'ACSC', dyngtg = 'EAYT', blncdt= '20230925' WHERE fcbpdt = '20230925' AND fcbpsq = '12023092502158016'") + tk.MustQuery("select * from golang1").Check(testkit.Rows("20230925 12023092502158016 ACSC CI010000 ACSC EAYT 20230925")) + tk.MustExec("UPDATE golang1 a SET procst= (SELECT 1 FROM golang2 c WHERE c.procst = a.procst) WHERE fcbpdt = '20230925' AND fcbpsq = '12023092502158016'") + tk.MustQuery("select * from golang1").Check(testkit.Rows("20230925 12023092502158016 1 CI010000 ACSC EAYT 20230925")) +} + +func TestExplainValuesStatement(t *testing.T) { + store, _ := testkit.CreateMockStoreAndDomain(t) + tk := testkit.NewTestKit(t, store) + + tk.MustMatchErrMsg("EXPLAIN FORMAT = TRADITIONAL ((VALUES ROW ()) ORDER BY 1)", ".*Unknown table ''.*") +} +>>>>>>> 1c185556710 (planner: do not convert update to point get if the expr has sub-query (#47454)):pkg/planner/core/plan_test.go diff --git a/planner/core/point_get_plan.go b/planner/core/point_get_plan.go index 9294b7ac64788..82d2c91db5f3b 100644 --- a/planner/core/point_get_plan.go +++ b/planner/core/point_get_plan.go @@ -19,6 +19,7 @@ import ( "sort" "strconv" "strings" + "sync" "unsafe" "github.com/pingcap/errors" @@ -1511,13 +1512,57 @@ func findInPairs(colName string, pairs []nameValuePair) int { return -1 } -func tryUpdatePointPlan(ctx sessionctx.Context, updateStmt *ast.UpdateStmt) Plan { - // avoid using the point_get when assignment_list contains the subquery in the UPDATE. - for _, list := range updateStmt.List { - if _, ok := list.Expr.(*ast.SubqueryExpr); ok { - return nil +// Use cache to avoid allocating memory every time. +var subQueryCheckerPool = &sync.Pool{New: func() any { return &subQueryChecker{} }} + +type subQueryChecker struct { + hasSubQuery bool +} + +func (s *subQueryChecker) Enter(in ast.Node) (node ast.Node, skipChildren bool) { + if s.hasSubQuery { + return in, true + } + + if _, ok := in.(*ast.SubqueryExpr); ok { + s.hasSubQuery = true + return in, true + } + + return in, false +} + +func (s *subQueryChecker) Leave(in ast.Node) (ast.Node, bool) { + // Before we enter the sub-query, we should keep visiting its children. + return in, !s.hasSubQuery +} + +func isExprHasSubQuery(expr ast.Node) bool { + checker := subQueryCheckerPool.Get().(*subQueryChecker) + defer func() { + // Do not forget to reset the flag. + checker.hasSubQuery = false + subQueryCheckerPool.Put(checker) + }() + expr.Accept(checker) + return checker.hasSubQuery +} + +func checkIfAssignmentListHasSubQuery(list []*ast.Assignment) bool { + for _, a := range list { + if isExprHasSubQuery(a) { + return true } } + return false +} + +func tryUpdatePointPlan(ctx sessionctx.Context, updateStmt *ast.UpdateStmt) Plan { + // Avoid using the point_get when assignment_list contains the sub-query in the UPDATE. + if checkIfAssignmentListHasSubQuery(updateStmt.List) { + return nil + } + selStmt := &ast.SelectStmt{ Fields: &ast.FieldList{}, From: updateStmt.TableRefs,