plan: add hint to force to choose hash join.

executor/join_test.go

@@ -148,6 +148,10 @@ func (s *testSuite) TestJoin(c *C) {
 	// Test that two conflict hints will return error.
 	_, err = tk.Exec("select /*+ TIDB_INLJ(t) TIDB_SMJ(t) */ * from t join t1 on t.a=t1.a")
 	c.Assert(err, NotNil)
+	_, err = tk.Exec("select /*+ TIDB_INLJ(t) TIDB_HJ(t) */ from t join t1 on t.a=t1.a")
+	c.Assert(err, NotNil)
+	_, err = tk.Exec("select /*+ TIDB_SMJ(t) TIDB_HJ(t) */ from t join t1 on t.a=t1.a")
+	c.Assert(err, NotNil)
 
 	tk.MustExec("drop table if exists t")
 	tk.MustExec("create table t(a int)")

parser/misc.go

@@ -442,6 +442,7 @@ var tokenMap = map[string]int{
 	"THAN":                     than,
 	"THEN":                     then,
 	"TIDB":                     tidb,
+	"TIDB_HJ":                  tidbHJ,
 	"TIDB_INLJ":                tidbINLJ,
 	"TIDB_SMJ":                 tidbSMJ,
 	"TIME":                     timeType,

parser/parser.y

@@ -422,6 +422,7 @@ import (
 	statsHistograms "STATS_HISTOGRAMS"
 	statsBuckets    "STATS_BUCKETS"
 	tidb		"TIDB"
+	tidbHJ		"TIDB_HJ"
 	tidbSMJ		"TIDB_SMJ"
 	tidbINLJ	"TIDB_INLJ"
 
@@ -2500,7 +2501,7 @@ UnReservedKeyword:
 | "MAX_USER_CONNECTIONS" | "REPLICATION" | "CLIENT" | "SLAVE" | "RELOAD" | "TEMPORARY" | "ROUTINE" | "EVENT" | "ALGORITHM" | "DEFINER" | "INVOKER" | "MERGE" | "TEMPTABLE" | "UNDEFINED" | "SECURITY" | "CASCADED"
 
 TiDBKeyword:
-"ADMIN" | "CANCEL" | "DDL" | "JOBS" | "STATS" | "STATS_META" | "STATS_HISTOGRAMS" | "STATS_BUCKETS" | "TIDB" | "TIDB_SMJ" | "TIDB_INLJ"
+"ADMIN" | "CANCEL" | "DDL" | "JOBS" | "STATS" | "STATS_META" | "STATS_HISTOGRAMS" | "STATS_BUCKETS" | "TIDB" | "TIDB_HJ" | "TIDB_SMJ" | "TIDB_INLJ"
 
 NotKeywordToken:
  "ADDDATE" | "BIT_AND" | "BIT_OR" | "BIT_XOR" | "CAST" | "COUNT" | "CURTIME" | "DATE_ADD" | "DATE_SUB" | "EXTRACT" | "GET_FORMAT" | "GROUP_CONCAT" | "MIN" | "MAX" | "NOW" | "POSITION"
@@ -4299,6 +4300,10 @@ TableOptimizerHintOpt:
 	{
 		$$ = &ast.TableOptimizerHint{HintName: model.NewCIStr($1), Tables: $3.([]model.CIStr)}
 	}
+|	tidbHJ '(' HintTableList ')'
+	{
+		$$ = &ast.TableOptimizerHint{HintName: model.NewCIStr($1), Tables: $3.([]model.CIStr)}
+	}
 
 SelectStmtCalcFoundRows:
 	{

parser/parser_test.go

@@ -1589,6 +1589,21 @@ func (s *testParserSuite) TestOptimizerHints(c *C) {
 	c.Assert(hints[1].HintName.L, Equals, "tidb_inlj")
 	c.Assert(hints[1].Tables[0].L, Equals, "t3")
 	c.Assert(hints[1].Tables[1].L, Equals, "t4")
+
+	stmt, err = parser.Parse("select /*+ TIDB_HJ(t1, T2) tidb_hj(t3, t4) */ c1, c2 from t1, t2 where t1.c1 = t2.c1", "", "")
+	c.Assert(err, IsNil)
+	selectStmt = stmt[0].(*ast.SelectStmt)
+
+	hints = selectStmt.TableHints
+	c.Assert(len(hints), Equals, 2)
+	c.Assert(hints[0].HintName.L, Equals, "tidb_hj")
+	c.Assert(len(hints[0].Tables), Equals, 2)
+	c.Assert(hints[0].Tables[0].L, Equals, "t1")
+	c.Assert(hints[0].Tables[1].L, Equals, "t2")
+
+	c.Assert(hints[1].HintName.L, Equals, "tidb_hj")
+	c.Assert(hints[1].Tables[0].L, Equals, "t3")
+	c.Assert(hints[1].Tables[1].L, Equals, "t4")
 }
 
 func (s *testParserSuite) TestType(c *C) {

plan/dag_plan_test.go

@@ -226,6 +226,11 @@ func (s *testPlanSuite) TestDAGPlanBuilderJoin(c *C) {
 			sql:  "select * from t t1 join t t2 on t1.b = t2.a order by t1.a limit 1",
 			best: "IndexJoin{TableReader(Table(t))->TableReader(Table(t))}(t1.b,t2.a)->Limit",
 		},
+		// Test hash join's hint.
+		{
+			sql:  "select /*+ TIDB_HJ(t1, t2) */ * from t t1 join t t2 on t1.b = t2.a order by t1.a limit 1",
+			best: "LeftHashJoin{TableReader(Table(t))->TableReader(Table(t))}(t1.b,t2.a)->TopN([t1.a],0,1)",
+		},
 		{
 			sql:  "select * from t t1 left join t t2 on t1.b = t2.a where 1 = 1 limit 1",
 			best: "IndexJoin{TableReader(Table(t)->Limit)->TableReader(Table(t))}(t1.b,t2.a)->Limit",

plan/gen_physical_plans.go

@@ -126,6 +126,20 @@ func (p *LogicalJoin) getHashSemiJoin() PhysicalPlan {
 	return semiJoin
 }
 
+func (p *LogicalJoin) getHashJoins() []PhysicalPlan {
+	joins := make([]PhysicalPlan, 0, 2)
+	switch p.JoinType {
+	case SemiJoin, AntiSemiJoin, LeftOuterSemiJoin, AntiLeftOuterSemiJoin, LeftOuterJoin:
+		joins = append(joins, p.getHashJoin(1))
+	case RightOuterJoin:
+		joins = append(joins, p.getHashJoin(0))
+	case InnerJoin:
+		joins = append(joins, p.getHashJoin(1))
+		joins = append(joins, p.getHashJoin(0))
+	}
+	return joins
+}
+
 func (p *LogicalJoin) getHashJoin(smallTable int) PhysicalPlan {
 	hashJoin := PhysicalHashJoin{
 		EqualConditions: p.EqualConditions,
@@ -252,8 +266,8 @@ func (p *LogicalJoin) tryToGetIndexJoin() ([]PhysicalPlan, bool) {
 		return nil, false
 	}
 	plans := make([]PhysicalPlan, 0, 2)
-	leftOuter := (p.preferINLJ & preferLeftAsOuter) > 0
-	rightOuter := (p.preferINLJ & preferRightAsOuter) > 0
+	leftOuter := (p.preferJoinType & preferLeftAsIndexOuter) > 0
+	rightOuter := (p.preferJoinType & preferRightAsIndexOuter) > 0
 	switch p.JoinType {
 	case SemiJoin, AntiSemiJoin, LeftOuterSemiJoin, AntiLeftOuterSemiJoin, LeftOuterJoin:
 		join := p.getIndexJoinByOuterIdx(0)
@@ -296,7 +310,7 @@ func (p *LogicalJoin) tryToGetIndexJoin() ([]PhysicalPlan, bool) {
 
 func (p *LogicalJoin) generatePhysicalPlans() []PhysicalPlan {
 	mergeJoins := p.getMergeJoin()
-	if p.preferMergeJoin && len(mergeJoins) > 0 {
+	if (p.preferJoinType&preferMergeJoin) > 0 && len(mergeJoins) > 0 {
 		return mergeJoins
 	}
 	joins := make([]PhysicalPlan, 0, 5)
@@ -308,15 +322,11 @@ func (p *LogicalJoin) generatePhysicalPlans() []PhysicalPlan {
 	}
 	joins = append(joins, indexJoins...)
 
-	switch p.JoinType {
-	case SemiJoin, AntiSemiJoin, LeftOuterSemiJoin, AntiLeftOuterSemiJoin, LeftOuterJoin:
-		joins = append(joins, p.getHashJoin(1))
-	case RightOuterJoin:
-		joins = append(joins, p.getHashJoin(0))
-	case InnerJoin:
-		joins = append(joins, p.getHashJoin(1))
-		joins = append(joins, p.getHashJoin(0))
+	hashJoins := p.getHashJoins()
+	if (p.preferJoinType & preferHashJoin) > 0 {
+		return hashJoins
 	}
+	joins = append(joins, hashJoins...)
 	return joins
 }
 

plan/join_reorder.go

@@ -14,6 +14,7 @@
 package plan
 
 import (
+	"math/bits"
 	"sort"
 
 	log "github.com/Sirupsen/logrus"
@@ -27,9 +28,8 @@ func tryToGetJoinGroup(j *LogicalJoin) ([]LogicalPlan, bool) {
 	// Ignore reorder if:
 	// 1. already reordered
 	// 2. not inner join
-	// 3. forced merge join
-	// 4. forced index nested loop join
-	if j.reordered || !j.cartesianJoin || j.preferMergeJoin || j.preferINLJ > 0 {
+	// 3. forced to choose join type
+	if j.reordered || !j.cartesianJoin || bits.OnesCount(j.preferJoinType) > 0 {
 		return nil, false
 	}
 	lChild := j.children[0].(LogicalPlan)

plan/logical_plan_builder.go

@@ -16,6 +16,7 @@ package plan
 import (
 	"fmt"
 	"math"
+	"math/bits"
 	"reflect"
 	"strings"
 	"unicode"
@@ -42,6 +43,8 @@ const (
 	TiDBMergeJoin = "tidb_smj"
 	// TiDBIndexNestedLoopJoin is hint enforce index nested loop join.
 	TiDBIndexNestedLoopJoin = "tidb_inlj"
+	// TiDBHashJoin is hint enforce hash join.
+	TiDBHashJoin = "tidb_hj"
 )
 
 const (
@@ -257,15 +260,21 @@ func (b *planBuilder) buildJoin(join *ast.Join) LogicalPlan {
 	if b.TableHints() != nil {
 		leftAlias := extractTableAlias(leftPlan)
 		rightAlias := extractTableAlias(rightPlan)
-		joinPlan.preferMergeJoin = b.TableHints().ifPreferMergeJoin(leftAlias, rightAlias)
+		if b.TableHints().ifPreferMergeJoin(leftAlias, rightAlias) {
+			joinPlan.preferJoinType |= preferMergeJoin
+		}
+		if b.TableHints().ifPreferHashJoin(leftAlias, rightAlias) {
+			joinPlan.preferJoinType |= preferHashJoin
+		}
 		if b.TableHints().ifPreferINLJ(leftAlias) {
-			joinPlan.preferINLJ = joinPlan.preferINLJ | preferLeftAsOuter
+			joinPlan.preferJoinType |= preferLeftAsIndexOuter
 		}
 		if b.TableHints().ifPreferINLJ(rightAlias) {
-			joinPlan.preferINLJ = joinPlan.preferINLJ | preferRightAsOuter
+			joinPlan.preferJoinType |= preferRightAsIndexOuter
 		}
-		if joinPlan.preferMergeJoin && joinPlan.preferINLJ > 0 {
-			b.err = errors.New("Optimizer Hints is conflict")
+		// If there're multiple join type and one of them is not the index join hints, then is conflict.
+		if bits.OnesCount(joinPlan.preferJoinType) > 1 && (joinPlan.preferJoinType^preferRightAsIndexOuter^preferLeftAsIndexOuter) > 0 {
+			b.err = errors.New("Join hints are conflict, you can only specify one type of join")
 			return nil
 		}
 	}
@@ -1411,21 +1420,24 @@ func (b *planBuilder) unfoldWildStar(p LogicalPlan, selectFields []*ast.SelectFi
 }
 
 func (b *planBuilder) pushTableHints(hints []*ast.TableOptimizerHint) bool {
-	var sortMergeTables, INLJTables []model.CIStr
+	var sortMergeTables, INLJTables, hashJoinTables []model.CIStr
 	for _, hint := range hints {
 		switch hint.HintName.L {
 		case TiDBMergeJoin:
 			sortMergeTables = append(sortMergeTables, hint.Tables...)
 		case TiDBIndexNestedLoopJoin:
 			INLJTables = append(INLJTables, hint.Tables...)
+		case TiDBHashJoin:
+			hashJoinTables = append(hashJoinTables, hint.Tables...)
 		default:
 			// ignore hints that not implemented
 		}
 	}
-	if len(sortMergeTables) != 0 || len(INLJTables) != 0 {
+	if len(sortMergeTables)+len(INLJTables)+len(hashJoinTables) > 0 {
 		b.tableHintInfo = append(b.tableHintInfo, tableHintInfo{
 			sortMergeJoinTables:       sortMergeTables,
 			indexNestedLoopJoinTables: INLJTables,
+			hashJoinTables:            hashJoinTables,
 		})
 		return true
 	}
@@ -1800,10 +1812,20 @@ func (b *planBuilder) buildSemiJoin(outerPlan, innerPlan LogicalPlan, onConditio
 	if b.TableHints() != nil {
 		outerAlias := extractTableAlias(outerPlan)
 		innerAlias := extractTableAlias(innerPlan)
-		joinPlan.preferMergeJoin = b.TableHints().ifPreferMergeJoin(outerAlias, innerAlias)
+		if b.TableHints().ifPreferMergeJoin(outerAlias, innerAlias) {
+			joinPlan.preferJoinType |= preferMergeJoin
+		}
+		if b.TableHints().ifPreferHashJoin(outerAlias, innerAlias) {
+			joinPlan.preferJoinType |= preferHashJoin
+		}
 		// semi join's outer is always the left side.
 		if b.TableHints().ifPreferINLJ(outerAlias) {
-			joinPlan.preferINLJ = preferLeftAsOuter
+			joinPlan.preferJoinType = preferLeftAsIndexOuter
+		}
+		// If there're multiple join hints, they're conflict.
+		if bits.OnesCount(joinPlan.preferJoinType) > 1 {
+			b.err = errors.New("Join hints are conflict, you can only specify one type of join")
+			return nil
 		}
 	}
 	return joinPlan

plan/logical_plans.go

@@ -80,20 +80,21 @@ func (tp JoinType) String() string {
 }
 
 const (
-	preferLeftAsOuter = 1 << iota
-	preferRightAsOuter
+	preferLeftAsIndexOuter = 1 << iota
+	preferRightAsIndexOuter
+	preferHashJoin
+	preferMergeJoin
 )
 
 // LogicalJoin is the logical join plan.
 type LogicalJoin struct {
 	*basePlan
 	baseLogicalPlan
 
-	JoinType        JoinType
-	reordered       bool
-	cartesianJoin   bool
-	preferINLJ      int
-	preferMergeJoin bool
+	JoinType       JoinType
+	reordered      bool
+	cartesianJoin  bool
+	preferJoinType uint
 
 	EqualConditions []*expression.ScalarFunction
 	LeftConditions  expression.CNFExprs

plan/planbuilder.go

@@ -86,35 +86,35 @@ type visitInfo struct {
 type tableHintInfo struct {
 	indexNestedLoopJoinTables []model.CIStr
 	sortMergeJoinTables       []model.CIStr
+	hashJoinTables            []model.CIStr
 }
 
 func (info *tableHintInfo) ifPreferMergeJoin(tableNames ...*model.CIStr) bool {
-	// Only need either side matches one on the list.
-	// Even though you can put 2 tables on the list,
-	// it doesn't mean optimizer will reorder to make them
-	// join directly.
-	// Which it joins on with depend on sequence of traverse
-	// and without reorder, user might adjust themselves.
-	// This is similar to MySQL hints.
-	for _, tableName := range tableNames {
-		if tableName == nil {
-			continue
-		}
-		for _, curEntry := range info.sortMergeJoinTables {
-			if curEntry.L == tableName.L {
-				return true
-			}
-		}
-	}
-	return false
+	return info.matchTableName(tableNames, info.sortMergeJoinTables)
+}
+
+func (info *tableHintInfo) ifPreferHashJoin(tableNames ...*model.CIStr) bool {
+	return info.matchTableName(tableNames, info.hashJoinTables)
 }
 
 func (info *tableHintInfo) ifPreferINLJ(tableNames ...*model.CIStr) bool {
-	for _, tableName := range tableNames {
+	return info.matchTableName(tableNames, info.indexNestedLoopJoinTables)
+}
+
+// matchTableName checks whether the hint hit the need.
+// Only need either side matches one on the list.
+// Even though you can put 2 tables on the list,
+// it doesn't mean optimizer will reorder to make them
+// join directly.
+// Which it joins on with depend on sequence of traverse
+// and without reorder, user might adjust themselves.
+// This is similar to MySQL hints.
+func (info *tableHintInfo) matchTableName(tables []*model.CIStr, tablesInHints []model.CIStr) bool {
+	for _, tableName := range tables {
 		if tableName == nil {
 			continue
 		}
-		for _, curEntry := range info.indexNestedLoopJoinTables {
+		for _, curEntry := range tablesInHints {
 			if curEntry.L == tableName.L {
 				return true
 			}