planner : refactor the usage of int set. (pingcap#59346)

ref pingcap#51664

Author: AilinKid

pkg/planner/cascades/old/BUILD.bazel

@@ -30,8 +30,8 @@ go_library(
         "//pkg/planner/util/coreusage",
         "//pkg/types",
         "//pkg/util/dbterror/plannererrors",
+        "//pkg/util/intset",
         "//pkg/util/ranger",
-        "//pkg/util/set",
         "@com_github_pingcap_errors//:errors",
     ],
 )

pkg/planner/cascades/old/transformation_rules.go

@@ -32,8 +32,8 @@ import (
 	"github.com/pingcap/tidb/pkg/planner/util"
 	"github.com/pingcap/tidb/pkg/planner/util/coreusage"
 	"github.com/pingcap/tidb/pkg/types"
+	"github.com/pingcap/tidb/pkg/util/intset"
 	"github.com/pingcap/tidb/pkg/util/ranger"
-	"github.com/pingcap/tidb/pkg/util/set"
 )
 
 // Transformation defines the interface for the transformation rules.
@@ -1876,7 +1876,7 @@ func (r *PushLimitDownTiKVSingleGather) OnTransform(old *memo.ExprIter) (newExpr
 type outerJoinEliminator struct {
 }
 
-func (*outerJoinEliminator) prepareForEliminateOuterJoin(joinExpr *memo.GroupExpr) (ok bool, innerChildIdx int, outerGroup *memo.Group, innerGroup *memo.Group, outerUniqueIDs set.Int64Set) {
+func (*outerJoinEliminator) prepareForEliminateOuterJoin(joinExpr *memo.GroupExpr) (ok bool, innerChildIdx int, outerGroup *memo.Group, innerGroup *memo.Group, outerUniqueIDs intset.FastIntSet) {
 	join := joinExpr.ExprNode.(*logicalop.LogicalJoin)
 
 	switch join.JoinType {
@@ -1891,9 +1891,9 @@ func (*outerJoinEliminator) prepareForEliminateOuterJoin(joinExpr *memo.GroupExp
 	outerGroup = joinExpr.Children[1^innerChildIdx]
 	innerGroup = joinExpr.Children[innerChildIdx]
 
-	outerUniqueIDs = set.NewInt64Set()
+	outerUniqueIDs = intset.NewFastIntSet()
 	for _, outerCol := range outerGroup.Prop.Schema.Columns {
-		outerUniqueIDs.Insert(outerCol.UniqueID)
+		outerUniqueIDs.Insert(int(outerCol.UniqueID))
 	}
 
 	ok = true
@@ -1956,7 +1956,7 @@ func (r *EliminateOuterJoinBelowAggregation) OnTransform(old *memo.ExprIter) (ne
 	}
 
 	// only when agg only use the columns from outer table can eliminate outer join.
-	if !plannercore.IsColsAllFromOuterTable(agg.GetUsedCols(), outerUniqueIDs) {
+	if !ruleutil.IsColsAllFromOuterTable(agg.GetUsedCols(), &outerUniqueIDs) {
 		return nil, false, false, nil
 	}
 	// outer join elimination with duplicate agnostic aggregate functions.
@@ -2018,7 +2018,7 @@ func (r *EliminateOuterJoinBelowProjection) OnTransform(old *memo.ExprIter) (new
 	}
 
 	// only when proj only use the columns from outer table can eliminate outer join.
-	if !plannercore.IsColsAllFromOuterTable(proj.GetUsedCols(), outerUniqueIDs) {
+	if !ruleutil.IsColsAllFromOuterTable(proj.GetUsedCols(), &outerUniqueIDs) {
 		return nil, false, false, nil
 	}
 

pkg/planner/core/rule/util/BUILD.bazel

@@ -13,5 +13,6 @@ go_library(
         "//pkg/meta/model",
         "//pkg/parser/mysql",
         "//pkg/planner/core/base",
+        "//pkg/util/intset",
     ],
 )

pkg/planner/core/rule/util/misc.go

@@ -16,6 +16,7 @@ package util
 
 import (
 	"github.com/pingcap/tidb/pkg/expression"
+	"github.com/pingcap/tidb/pkg/util/intset"
 )
 
 // ResolveExprAndReplace replaces columns fields of expressions by children logical plans.
@@ -42,5 +43,21 @@ func ResolveColumnAndReplace(origin *expression.Column, replace map[string]*expr
 	}
 }
 
+// IsColsAllFromOuterTable check whether the cols all from outer plan
+func IsColsAllFromOuterTable(cols []*expression.Column, outerUniqueIDs *intset.FastIntSet) bool {
+	// There are two cases "return false" here:
+	// 1. If cols represents aggCols, then "len(cols) == 0" means not all aggregate functions are duplicate agnostic before.
+	// 2. If cols represents parentCols, then "len(cols) == 0" means no parent logical plan of this join plan.
+	if len(cols) == 0 {
+		return false
+	}
+	for _, col := range cols {
+		if !outerUniqueIDs.Has(int(col.UniqueID)) {
+			return false
+		}
+	}
+	return true
+}
+
 // SetPredicatePushDownFlag is a hook for other packages to set rule flag.
 var SetPredicatePushDownFlag func(uint64) uint64

pkg/planner/core/rule_join_elimination.go

@@ -24,8 +24,9 @@ import (
 	"github.com/pingcap/tidb/pkg/parser/ast"
 	"github.com/pingcap/tidb/pkg/planner/core/base"
 	"github.com/pingcap/tidb/pkg/planner/core/operator/logicalop"
+	ruleutil "github.com/pingcap/tidb/pkg/planner/core/rule/util"
 	"github.com/pingcap/tidb/pkg/planner/util/optimizetrace"
-	"github.com/pingcap/tidb/pkg/util/set"
+	"github.com/pingcap/tidb/pkg/util/intset"
 )
 
 // OuterJoinEliminator is used to eliminate outer join.
@@ -52,24 +53,24 @@ func (o *OuterJoinEliminator) tryToEliminateOuterJoin(p *logicalop.LogicalJoin,
 
 	outerPlan := p.Children()[1^innerChildIdx]
 	innerPlan := p.Children()[innerChildIdx]
-	outerUniqueIDs := set.NewInt64Set()
+	outerUniqueIDs := intset.NewFastIntSet()
 	for _, outerCol := range outerPlan.Schema().Columns {
-		outerUniqueIDs.Insert(outerCol.UniqueID)
+		outerUniqueIDs.Insert(int(outerCol.UniqueID))
 	}
 
 	// in case of count(*) FROM R LOJ S, the parentCols is empty, but
 	// still need to proceed to check whether we can eliminate outer join.
 	// In fact, we only care about whether there is any column from inner
 	// table, if there is none, we are good.
 	if len(parentCols) > 0 {
-		matched := IsColsAllFromOuterTable(parentCols, outerUniqueIDs)
+		matched := ruleutil.IsColsAllFromOuterTable(parentCols, &outerUniqueIDs)
 		if !matched {
 			return p, false, nil
 		}
 	}
 
 	// outer join elimination with duplicate agnostic aggregate functions
-	matched := IsColsAllFromOuterTable(aggCols, outerUniqueIDs)
+	matched := ruleutil.IsColsAllFromOuterTable(aggCols, &outerUniqueIDs)
 	if matched {
 		appendOuterJoinEliminateAggregationTraceStep(p, outerPlan, aggCols, opt)
 		return outerPlan, true, nil
@@ -105,22 +106,6 @@ func (*OuterJoinEliminator) extractInnerJoinKeys(join *logicalop.LogicalJoin, in
 	return expression.NewSchema(joinKeys...)
 }
 
-// IsColsAllFromOuterTable check whether the cols all from outer plan
-func IsColsAllFromOuterTable(cols []*expression.Column, outerUniqueIDs set.Int64Set) bool {
-	// There are two cases "return false" here:
-	// 1. If cols represents aggCols, then "len(cols) == 0" means not all aggregate functions are duplicate agnostic before.
-	// 2. If cols represents parentCols, then "len(cols) == 0" means no parent logical plan of this join plan.
-	if len(cols) == 0 {
-		return false
-	}
-	for _, col := range cols {
-		if !outerUniqueIDs.Exist(col.UniqueID) {
-			return false
-		}
-	}
-	return true
-}
-
 // check whether one of unique keys sets is contained by inner join keys
 func (*OuterJoinEliminator) isInnerJoinKeysContainUniqueKey(innerPlan base.LogicalPlan, joinKeys *expression.Schema) (bool, error) {
 	for _, keyInfo := range innerPlan.Schema().PKOrUK {