From 809969ba039d5b289d43402fb0f875a84f7d8f83 Mon Sep 17 00:00:00 2001 From: Zhuhe Fang Date: Thu, 16 Apr 2020 22:27:16 +0800 Subject: [PATCH 1/4] cherry pick #16444 to release-3.1 Signed-off-by: sre-bot --- planner/core/logical_plan_test.go | 69 ++++++++++++++++++++++++ planner/core/rule_predicate_push_down.go | 4 ++ 2 files changed, 73 insertions(+) diff --git a/planner/core/logical_plan_test.go b/planner/core/logical_plan_test.go index ac67498b9c3c4..c36bd33eb4c7c 100644 --- a/planner/core/logical_plan_test.go +++ b/planner/core/logical_plan_test.go @@ -2735,3 +2735,72 @@ func (s *testPlanSuite) TestFastPlanContextTables(c *C) { } } } +<<<<<<< HEAD +======= + +func (s *testPlanSuite) TestUpdateEQCond(c *C) { + defer testleak.AfterTest(c)() + tests := []struct { + sql string + best string + }{ + { + sql: "select t1.a from t t1, t t2 where t1.a = t2.a+1", + best: "Join{DataScan(t1)->DataScan(t2)->Projection}(test.t.a,Column#25)->Projection", + }, + } + ctx := context.TODO() + for i, tt := range tests { + comment := Commentf("case:%v sql:%s", i, tt.sql) + stmt, err := s.ParseOneStmt(tt.sql, "", "") + c.Assert(err, IsNil, comment) + Preprocess(s.ctx, stmt, s.is) + builder := NewPlanBuilder(MockContext(), s.is, &hint.BlockHintProcessor{}) + p, err := builder.Build(ctx, stmt) + c.Assert(err, IsNil) + p, err = logicalOptimize(ctx, builder.optFlag, p.(LogicalPlan)) + c.Assert(err, IsNil) + c.Assert(ToString(p), Equals, tt.best, comment) + } +} + +func (s *testPlanSuite) TestConflictedJoinTypeHints(c *C) { + defer testleak.AfterTest(c)() + sql := "select /*+ INL_JOIN(t1) HASH_JOIN(t1) */ * from t t1, t t2 where t1.e = t2.e" + ctx := context.TODO() + stmt, err := s.ParseOneStmt(sql, "", "") + c.Assert(err, IsNil) + Preprocess(s.ctx, stmt, s.is) + builder := NewPlanBuilder(MockContext(), s.is, &hint.BlockHintProcessor{}) + p, err := builder.Build(ctx, stmt) + c.Assert(err, IsNil) + p, err = logicalOptimize(ctx, builder.optFlag, p.(LogicalPlan)) + c.Assert(err, IsNil) + proj, ok := p.(*LogicalProjection) + c.Assert(ok, IsTrue) + join, ok := proj.Children()[0].(*LogicalJoin) + c.Assert(ok, IsTrue) + c.Assert(join.hintInfo, IsNil) + c.Assert(join.preferJoinType, Equals, uint(0)) +} + +func (s *testPlanSuite) TestSimplyOuterJoinWithOnlyOuterExpr(c *C) { + defer testleak.AfterTest(c)() + sql := "select * from t t1 right join t t0 ON TRUE where CONCAT_WS(t0.e=t0.e, 0, NULL) IS NULL" + ctx := context.TODO() + stmt, err := s.ParseOneStmt(sql, "", "") + c.Assert(err, IsNil) + Preprocess(s.ctx, stmt, s.is) + builder := NewPlanBuilder(MockContext(), s.is, &hint.BlockHintProcessor{}) + p, err := builder.Build(ctx, stmt) + c.Assert(err, IsNil) + p, err = logicalOptimize(ctx, builder.optFlag, p.(LogicalPlan)) + c.Assert(err, IsNil) + proj, ok := p.(*LogicalProjection) + c.Assert(ok, IsTrue) + join, ok := proj.Children()[0].(*LogicalJoin) + c.Assert(ok, IsTrue) + // previous wrong JoinType is InnerJoin + c.Assert(join.JoinType, Equals, RightOuterJoin) +} +>>>>>>> e3b635e... planner: cannot simply outer join if a predicate just refers to the outer table (#16444) diff --git a/planner/core/rule_predicate_push_down.go b/planner/core/rule_predicate_push_down.go index 9e9360d8074d5..0276f4c4e5199 100644 --- a/planner/core/rule_predicate_push_down.go +++ b/planner/core/rule_predicate_push_down.go @@ -304,6 +304,10 @@ func simplifyOuterJoin(p *LogicalJoin, predicates []expression.Expression) { // then simplify embedding outer join. canBeSimplified := false for _, expr := range predicates { + // avoid the case where the expr only refers to the schema of outerTable + if expression.ExprFromSchema(expr, outerTable.Schema()) { + continue + } isOk := isNullRejected(p.ctx, innerTable.Schema(), expr) if isOk { canBeSimplified = true From f6fafd85408e74db8476d2404f70f880569624a0 Mon Sep 17 00:00:00 2001 From: Zhuhe Fang Date: Thu, 16 Apr 2020 22:32:48 +0800 Subject: [PATCH 2/4] Update logical_plan_test.go --- planner/core/logical_plan_test.go | 49 ------------------------------- 1 file changed, 49 deletions(-) diff --git a/planner/core/logical_plan_test.go b/planner/core/logical_plan_test.go index c36bd33eb4c7c..14c2b3d54700b 100644 --- a/planner/core/logical_plan_test.go +++ b/planner/core/logical_plan_test.go @@ -2735,54 +2735,6 @@ func (s *testPlanSuite) TestFastPlanContextTables(c *C) { } } } -<<<<<<< HEAD -======= - -func (s *testPlanSuite) TestUpdateEQCond(c *C) { - defer testleak.AfterTest(c)() - tests := []struct { - sql string - best string - }{ - { - sql: "select t1.a from t t1, t t2 where t1.a = t2.a+1", - best: "Join{DataScan(t1)->DataScan(t2)->Projection}(test.t.a,Column#25)->Projection", - }, - } - ctx := context.TODO() - for i, tt := range tests { - comment := Commentf("case:%v sql:%s", i, tt.sql) - stmt, err := s.ParseOneStmt(tt.sql, "", "") - c.Assert(err, IsNil, comment) - Preprocess(s.ctx, stmt, s.is) - builder := NewPlanBuilder(MockContext(), s.is, &hint.BlockHintProcessor{}) - p, err := builder.Build(ctx, stmt) - c.Assert(err, IsNil) - p, err = logicalOptimize(ctx, builder.optFlag, p.(LogicalPlan)) - c.Assert(err, IsNil) - c.Assert(ToString(p), Equals, tt.best, comment) - } -} - -func (s *testPlanSuite) TestConflictedJoinTypeHints(c *C) { - defer testleak.AfterTest(c)() - sql := "select /*+ INL_JOIN(t1) HASH_JOIN(t1) */ * from t t1, t t2 where t1.e = t2.e" - ctx := context.TODO() - stmt, err := s.ParseOneStmt(sql, "", "") - c.Assert(err, IsNil) - Preprocess(s.ctx, stmt, s.is) - builder := NewPlanBuilder(MockContext(), s.is, &hint.BlockHintProcessor{}) - p, err := builder.Build(ctx, stmt) - c.Assert(err, IsNil) - p, err = logicalOptimize(ctx, builder.optFlag, p.(LogicalPlan)) - c.Assert(err, IsNil) - proj, ok := p.(*LogicalProjection) - c.Assert(ok, IsTrue) - join, ok := proj.Children()[0].(*LogicalJoin) - c.Assert(ok, IsTrue) - c.Assert(join.hintInfo, IsNil) - c.Assert(join.preferJoinType, Equals, uint(0)) -} func (s *testPlanSuite) TestSimplyOuterJoinWithOnlyOuterExpr(c *C) { defer testleak.AfterTest(c)() @@ -2803,4 +2755,3 @@ func (s *testPlanSuite) TestSimplyOuterJoinWithOnlyOuterExpr(c *C) { // previous wrong JoinType is InnerJoin c.Assert(join.JoinType, Equals, RightOuterJoin) } ->>>>>>> e3b635e... planner: cannot simply outer join if a predicate just refers to the outer table (#16444) From 95eda93a8a14a45a7a120fec4c9681989a0e0b52 Mon Sep 17 00:00:00 2001 From: Zhuhe Fang Date: Mon, 20 Apr 2020 16:31:31 +0800 Subject: [PATCH 3/4] Update logical_plan_test.go --- planner/core/logical_plan_test.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/planner/core/logical_plan_test.go b/planner/core/logical_plan_test.go index 14c2b3d54700b..3a9d829f00a6b 100644 --- a/planner/core/logical_plan_test.go +++ b/planner/core/logical_plan_test.go @@ -2743,7 +2743,11 @@ func (s *testPlanSuite) TestSimplyOuterJoinWithOnlyOuterExpr(c *C) { stmt, err := s.ParseOneStmt(sql, "", "") c.Assert(err, IsNil) Preprocess(s.ctx, stmt, s.is) - builder := NewPlanBuilder(MockContext(), s.is, &hint.BlockHintProcessor{}) + builder := &PlanBuilder{ + ctx: MockContext(), + is: s.is, + colMapper: make(map[*ast.ColumnNameExpr]int), + } p, err := builder.Build(ctx, stmt) c.Assert(err, IsNil) p, err = logicalOptimize(ctx, builder.optFlag, p.(LogicalPlan)) From 262bba6f51fb06e8965e61cbd683caeacb59cd23 Mon Sep 17 00:00:00 2001 From: Zhuhe Fang Date: Mon, 20 Apr 2020 16:59:56 +0800 Subject: [PATCH 4/4] Update logical_plan_test.go --- planner/core/logical_plan_test.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/planner/core/logical_plan_test.go b/planner/core/logical_plan_test.go index 3a9d829f00a6b..badc0c1741e7f 100644 --- a/planner/core/logical_plan_test.go +++ b/planner/core/logical_plan_test.go @@ -2744,9 +2744,10 @@ func (s *testPlanSuite) TestSimplyOuterJoinWithOnlyOuterExpr(c *C) { c.Assert(err, IsNil) Preprocess(s.ctx, stmt, s.is) builder := &PlanBuilder{ - ctx: MockContext(), - is: s.is, - colMapper: make(map[*ast.ColumnNameExpr]int), + ctx: MockContext(), + is: s.is, + colMapper: make(map[*ast.ColumnNameExpr]int), + hintProcessor: &BlockHintProcessor{}, } p, err := builder.Build(ctx, stmt) c.Assert(err, IsNil)