planner: support join elimination rule

cmd/explaintest/r/explain_easy.result

@@ -385,6 +385,19 @@ Projection_5	8000.00	root	test.ta.a
     └─TableReader_9	10000.00	root	data:TableScan_8
       └─TableScan_8	10000.00	cop	table:ta, range:[-inf,+inf], keep order:false, stats:pseudo
 rollback;
+drop table if exists t1, t2;
+create table t1(a int, b int, c int, primary key(a, b));
+create table t2(a int, b int, c int, primary key(a));
+explain select t1.a, t1.b from t1 left outer join t2 on t1.a = t2.a;
+id	count	task	operator info
+TableReader_7	10000.00	root	data:TableScan_6
+└─TableScan_6	10000.00	cop	table:t1, range:[-inf,+inf], keep order:false, stats:pseudo
+explain select distinct t1.a, t1.b from t1 left outer join t2 on t1.a = t2.a;
+id	count	task	operator info
+StreamAgg_19	8000.00	root	group by:col_2, col_3, funcs:firstrow(col_0), firstrow(col_1)
+└─IndexReader_20	8000.00	root	index:StreamAgg_10
+  └─StreamAgg_10	8000.00	cop	group by:test.t1.a, test.t1.b, funcs:firstrow(test.t1.a), firstrow(test.t1.b)
+    └─IndexScan_18	10000.00	cop	table:t1, index:a, b, range:[NULL,+inf], keep order:true, stats:pseudo
 drop table if exists t;
 create table t(a int, nb int not null, nc int not null);
 explain select ifnull(a, 0) from t;

cmd/explaintest/t/explain_easy.test

@@ -82,6 +82,13 @@ insert tb values ('1');
 explain select * from ta where a = 1;
 rollback;
 
+# outer join elimination
+drop table if exists t1, t2;
+create table t1(a int, b int, c int, primary key(a, b));
+create table t2(a int, b int, c int, primary key(a));
+explain select t1.a, t1.b from t1 left outer join t2 on t1.a = t2.a;
+explain select distinct t1.a, t1.b from t1 left outer join t2 on t1.a = t2.a;
+
 # https://github.com/pingcap/tidb/issues/7918
 drop table if exists t;
 create table t(a int, nb int not null, nc int not null);

planner/core/logical_plan_builder.go

@@ -298,8 +298,12 @@ func (b *PlanBuilder) buildJoin(joinNode *ast.Join) (LogicalPlan, error) {
 	// Set join type.
 	switch joinNode.Tp {
 	case ast.LeftJoin:
+		// left outer join need to be checked elimination
+		b.optFlag = b.optFlag | flagEliminateOuterJoin
 		joinPlan.JoinType = LeftOuterJoin
 	case ast.RightJoin:
+		// right outer join need to be checked elimination
+		b.optFlag = b.optFlag | flagEliminateOuterJoin
 		joinPlan.JoinType = RightOuterJoin
 	default:
 		joinPlan.JoinType = InnerJoin

planner/core/logical_plan_test.go

@@ -2008,3 +2008,49 @@ func (s *testPlanSuite) TestNameResolver(c *C) {
 		}
 	}
 }
+
+func (s *testPlanSuite) TestOuterJoinEliminator(c *C) {
+	defer testleak.AfterTest(c)()
+	tests := []struct {
+		sql  string
+		best string
+	}{
+		// Test left outer join + distinct
+		{
+			sql:  "select distinct t1.a, t1.b from t t1 left outer join t t2 on t1.b = t2.b",
+			best: "DataScan(t1)->Aggr(firstrow(t1.a),firstrow(t1.b))",
+		},
+		// Test right outer join + distinct
+		{
+			sql:  "select distinct t2.a, t2.b from t t1 right outer join t t2 on t1.b = t2.b",
+			best: "DataScan(t2)->Aggr(firstrow(t2.a),firstrow(t2.b))",
+		},
+		// Test left outer join
+		{
+			sql:  "select t1.b from t t1 left outer join t t2 on t1.a = t2.a",
+			best: "DataScan(t1)->Projection",
+		},
+		// Test right outer join
+		{
+			sql:  "select t2.b from t t1 right outer join t t2 on t1.a = t2.a",
+			best: "DataScan(t2)->Projection",
+		},
+	}
+
+	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, false)
+		builder := &PlanBuilder{
+			ctx:       mockContext(),
+			is:        s.is,
+			colMapper: make(map[*ast.ColumnNameExpr]int),
+		}
+		p, err := builder.Build(stmt)
+		c.Assert(err, IsNil)
+		p, err = logicalOptimize(builder.optFlag, p.(LogicalPlan))
+		c.Assert(err, IsNil)
+		c.Assert(ToString(p), Equals, tt.best, comment)
+	}
+}

planner/core/optimizer.go

@@ -42,6 +42,7 @@ const (
 	flagPartitionProcessor
 	flagPushDownAgg
 	flagPushDownTopN
+	flagEliminateOuterJoin
 )
 
 var optRuleList = []logicalOptRule{
@@ -55,6 +56,7 @@ var optRuleList = []logicalOptRule{
 	&partitionProcessor{},
 	&aggregationPushDownSolver{},
 	&pushDownTopNOptimizer{},
+	&outerJoinEliminator{},
 }
 
 // logicalOptRule means a logical optimizing rule, which contains decorrelate, ppd, column pruning, etc.

planner/core/rule_join_elimination.go

@@ -0,0 +1,148 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package core
+
+import (
+	"github.com/pingcap/tidb/ast"
+	"github.com/pingcap/tidb/expression"
+)
+
+type outerJoinEliminator struct {
+	hasDistinct int
+	cols        [][]*expression.Column
+	schemas     []*expression.Schema
+}
+
+// tryToEliminateOuterJoin will eliminate outer join plan base on the following rules
+// 1. outer join elimination: For example left outer join, if the parent only use the
+//    columns from left table and the join key of right table(the inner table) is a unique
+//    key of the right table. the left outer join can be eliminated.
+// 2. outer join elimination with distinct: For example left outer join. If the parent
+//    only use the columns from left table with 'distinct' label. The left outer join can
+//    be eliminated.
+func (o *outerJoinEliminator) tryToEliminateOuterJoin(p *LogicalJoin) LogicalPlan {
+	if len(p.children) != 2 {
+		return nil
+	}
+	switch p.JoinType {
+	case LeftOuterJoin:
+		return o.doEliminate(p, 1)
+	case RightOuterJoin:
+		return o.doEliminate(p, 0)
+	default:
+		return nil
+	}
+}
+
+func (o *outerJoinEliminator) doEliminate(p *LogicalJoin, isLeft int) LogicalPlan {
+	// outer join elimination with distinct
+	if o.hasDistinct > 0 {
+		cols := o.cols[o.hasDistinct-1]
+		allColsInSchema := true
+		for _, col := range cols {
+			if !p.children[1^isLeft].Schema().Contains(col) {
+				allColsInSchema = false
+				break
+			}
+		}
+		if allColsInSchema == true {
+			return p.children[1^isLeft]
+		}
+	}
+
+	// outer join elimination without distinct
+	// first, check whether the parent's schema columns are all in left or right
+	if len(o.schemas) < 1 {
+		return nil
+	}
+	for _, col := range o.schemas[len(o.schemas)-1].Columns {
+		columnName := &ast.ColumnName{Schema: col.DBName, Table: col.TblName, Name: col.ColName}
+		if c, _ := p.children[1^isLeft].Schema().FindColumn(columnName); c == nil {
+			return nil
+		}
+	}
+	// second, check whether the other side join keys are unique keys
+	for _, keyInfo := range p.children[isLeft].Schema().Keys {
+		keyInfoContainAllCols := true
+		var joinKeys []*expression.Column
+		if isLeft > 0 {
+			joinKeys = p.RightJoinKeys
+		} else {
+			joinKeys = p.LeftJoinKeys
+		}
+		for _, col := range joinKeys {
+			columnName := &ast.ColumnName{Schema: col.DBName, Table: col.TblName, Name: col.ColName}
+			if c, _ := expression.NewSchema(keyInfo...).FindColumn(columnName); c == nil {
+				keyInfoContainAllCols = false
+				break
+			}
+		}
+		if keyInfoContainAllCols {
+			return p.children[1^isLeft]
+		}
+	}
+
+	return nil
+}
+
+func (o *outerJoinEliminator) optimize(p LogicalPlan) (LogicalPlan, error) {
+	// check the distinct
+	if agg, ok := p.(*LogicalAggregation); ok && len(agg.groupByCols) > 0 {
+		isDistinctAgg := true
+		for _, aggDesc := range agg.AggFuncs {
+			if aggDesc.Name != ast.AggFuncFirstRow {
+				isDistinctAgg = false
+				break
+			}
+			if len(aggDesc.Args) != 1 {
+				isDistinctAgg = false
+				break
+			}
+			if _, ok := aggDesc.Args[0].(*expression.Column); !ok {
+				isDistinctAgg = false
+				break
+			}
+		}
+		if isDistinctAgg {
+			o.hasDistinct++
+			o.cols = append(o.cols, agg.groupByCols)
+			defer func() {
+				o.hasDistinct--
+				o.cols = o.cols[:o.hasDistinct]
+			}()
+		}
+	}
+
+	newChildren := make([]LogicalPlan, 0, len(p.Children()))
+	for _, child := range p.Children() {
+		// if child is logical join, then save the parent schema
+		if _, ok := child.(*LogicalJoin); ok {
+			o.schemas = append(o.schemas, p.Schema())
+			defer func() {
+				o.schemas = o.schemas[:len(o.schemas)-1]
+			}()
+		}
+		newChild, _ := o.optimize(child)
+		newChildren = append(newChildren, newChild)
+	}
+	p.SetChildren(newChildren...)
+	join, ok := p.(*LogicalJoin)
+	if !ok {
+		return p, nil
+	}
+	if proj := o.tryToEliminateOuterJoin(join); proj != nil {
+		return proj, nil
+	}
+	return p, nil
+}