planner: support the transformation framework of the cascades planner

planner/cascades/expr_iterator.go

@@ -0,0 +1,139 @@
+// 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 cascades
+
+import (
+	"container/list"
+)
+
+// ExprIter enumerates all the equivalent expressions in the group according to
+// the expression pattern.
+type ExprIter struct {
+	// The group and element field solely identify a group expression.
+	group   *Group
+	element *list.Element
+
+	// Indicates whether the current group expression binded by the iterator
+	// matches the pattern after the creation or iteration of the group.
+	foundMatch bool
+
+	// operand is the node of the pattern tree. The operand type of the group
+	// expression must be matched with it, otherwise the group expression is
+	// ignored during the iteration.
+	operand Operand
+
+	// children is used to iterate the child expressions.
+	children []*ExprIter
+}
+
+// Next returns the next group expression matches the pattern.
+func (iter *ExprIter) Next() {
+	// Iterate child firstly.
+	for i := range iter.children {
+		iter.children[i].Next()
+		if iter.children[i].OK() {
+			iter.foundMatch = true
+			return
+		}
+	}
+
+	// It's root node.
+	if iter.group == nil {
+		iter.foundMatch = false
+		return
+	}
+
+	// Otherwise, iterate itself to find more matched equivalent expressions.
+	for iter.element.Next(); iter.element != nil; iter.element.Next() {
+		expr := iter.element.Value.(*GroupExpr)
+		exprOperand := GetOperand(expr.exprNode)
+
+		if !iter.operand.match(exprOperand) {
+			continue
+		}
+
+		iter.foundMatch = true
+		for i := range iter.children {
+			if !iter.children[i].Reset(expr.children[i]) {
+				iter.foundMatch = false
+				break
+			}
+		}
+		if iter.foundMatch {
+			return
+		}
+	}
+	iter.foundMatch = false
+	return
+}
+
+// OK returns whether the iterator founds a group expression matches the pattern.
+func (iter *ExprIter) OK() bool {
+	return iter.foundMatch
+}
+
+// Reset resets the iterator to the first matched group expression.
+func (iter *ExprIter) Reset(g *Group) bool {
+	for elem := g.equivalents.Front(); elem != nil; elem.Next() {
+		expr := elem.Value.(*GroupExpr)
+		if !iter.operand.match(GetOperand(expr.exprNode)) {
+			continue
+		}
+
+		allMatched := true
+		for i := range expr.children {
+			if !iter.children[i].Reset(expr.children[i]) {
+				allMatched = false
+				break
+			}
+		}
+		if allMatched {
+			iter.group = g
+			iter.element = elem
+			return true
+		}
+	}
+	return false
+}
+
+// NewExprIter creates the iterator on the group which iterates the group
+// expressions matches the pattern.
+func NewExprIter(expr *GroupExpr, p *Pattern) *ExprIter {
+	if !p.operand.match(GetOperand(expr.exprNode)) {
+		return nil
+	}
+
+	iter := &ExprIter{operand: p.operand, foundMatch: true}
+	for i := range p.children {
+		childIter := newChildExprIter(expr.children[i], p.children[i])
+		if childIter == nil {
+			return nil
+		}
+		iter.children = append(iter.children, childIter)
+	}
+	return iter
+}
+
+func newChildExprIter(childGroup *Group, childPattern *Pattern) *ExprIter {
+	for elem := childGroup.equivalents.Front(); elem != nil; elem = elem.Next() {
+		childIter := NewExprIter(elem.Value.(*GroupExpr), childPattern)
+		if childIter == nil {
+			continue
+		}
+		childIter.group = childGroup
+		childIter.element = elem
+		return childIter
+	}
+	return nil
+}

planner/cascades/optimize.go

@@ -0,0 +1,124 @@
+// 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 cascades
+
+import (
+	plannercore "github.com/pingcap/tidb/planner/core"
+	"github.com/pingcap/tidb/sessionctx"
+	"github.com/pkg/errors"
+)
+
+// FindBestPlan is the optimization entrance of the cascades planner. The
+// optimization is composed of 2 phases: exploration and implementation.
+func FindBestPlan(sctx sessionctx.Context, logical plannercore.LogicalPlan) (plannercore.Plan, error) {
+	rootGroup := convert2Group(logical)
+
+	err := onPhaseExploration(sctx, rootGroup)
+	if err != nil {
+		return nil, err
+	}
+
+	best, err := onPhaseImplementation(sctx, rootGroup)
+	return best, err
+}
+
+// convert2Group converts a logical plan to expression groups.
+func convert2Group(node plannercore.LogicalPlan) *Group {
+	e := NewGroupExpr(node)
+	e.children = make([]*Group, 0, len(node.Children()))
+	for _, child := range node.Children() {
+		childGroup := convert2Group(child)
+		e.children = append(e.children, childGroup)
+	}
+	return NewGroup(e)
+}
+
+func onPhaseExploration(sctx sessionctx.Context, g *Group) error {
+	for !g.explored {
+		err := exploreGroup(g)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func exploreGroup(g *Group) error {
+	if g.explored {
+		return nil
+	}
+
+	g.explored = true
+	for elem := g.equivalents.Front(); elem != nil; elem.Next() {
+		curExpr := elem.Value.(*GroupExpr)
+		if curExpr.explored {
+			continue
+		}
+
+		// Explore child groups firstly.
+		curExpr.explored = true
+		for _, childGroup := range curExpr.children {
+			exploreGroup(childGroup)
+			curExpr.explored = curExpr.explored && childGroup.explored
+		}
+
+		eraseCur, err := findMoreEquiv(curExpr, g)
+		if err != nil {
+			return err
+		}
+		if eraseCur {
+			g.Delete(curExpr)
+		}
+
+		g.explored = g.explored && curExpr.explored
+	}
+	return nil
+}
+
+// Find and apply the matched transformation rules.
+func findMoreEquiv(expr *GroupExpr, g *Group) (eraseCur bool, err error) {
+	for _, rule := range GetTransformationRules(expr.exprNode) {
+		pattern := rule.GetPattern()
+		// Create a binding of the current group expression and the pattern of
+		// the transformation rule to enumerate all the possible expressions.
+		for iter := NewExprIter(expr, pattern); iter != nil && iter.OK(); iter.Next() {
+			matched, err := rule.Match(iter)
+			if err != nil {
+				return false, err
+			}
+
+			if !matched {
+				continue
+			}
+
+			newExpr, erase, err := rule.OnTransform(iter)
+			eraseCur = eraseCur || erase
+			if !g.Insert(newExpr) {
+				continue
+			}
+
+			// If the new group expression is successfully inserted into the
+			// current group, we mark the group expression and the group as
+			// unexplored to enable the exploration on the new group expression
+			// and all the antecedent groups.
+			newExpr.explored = false
+			g.explored = false
+		}
+	}
+	return eraseCur, nil
+}
+
+func onPhaseImplementation(sctx sessionctx.Context, g *Group) (plannercore.Plan, error) {
+	return nil, errors.New("the onPhaseImplementation() of the cascades planner is not implemented")
+}

planner/cascades/pattern.go

@@ -60,38 +60,38 @@ const (
 )
 
 // GetOperand maps logical plan operator to Operand.
-func GetOperand(p plannercore.LogicalPlan) (Operand, error) {
-	switch x := p.(type) {
+func GetOperand(p plannercore.LogicalPlan) Operand {
+	switch p.(type) {
 	case *plannercore.LogicalJoin:
-		return OperandJoin, nil
+		return OperandJoin
 	case *plannercore.LogicalAggregation:
-		return OperandAggregation, nil
+		return OperandAggregation
 	case *plannercore.LogicalProjection:
-		return OperandProjection, nil
+		return OperandProjection
 	case *plannercore.LogicalSelection:
-		return OperandSelection, nil
+		return OperandSelection
 	case *plannercore.LogicalApply:
-		return OperandApply, nil
+		return OperandApply
 	case *plannercore.LogicalMaxOneRow:
-		return OperandMaxOneRow, nil
+		return OperandMaxOneRow
 	case *plannercore.LogicalTableDual:
-		return OperandTableDual, nil
+		return OperandTableDual
 	case *plannercore.DataSource:
-		return OperandDataSource, nil
+		return OperandDataSource
 	case *plannercore.LogicalUnionScan:
-		return OperandUnionScan, nil
+		return OperandUnionScan
 	case *plannercore.LogicalUnionAll:
-		return OperandUnionAll, nil
+		return OperandUnionAll
 	case *plannercore.LogicalSort:
-		return OperandSort, nil
+		return OperandSort
 	case *plannercore.LogicalTopN:
-		return OperandTopN, nil
+		return OperandTopN
 	case *plannercore.LogicalLock:
-		return OperandLock, nil
+		return OperandLock
 	case *plannercore.LogicalLimit:
-		return OperandLimit, nil
+		return OperandLimit
 	default:
-		return OperandUnsupported, plannercore.ErrUnsupportedType.GenWithStack("Unsupported LogicalPlan(%T) for GetOperand", x)
+		return OperandUnsupported
 	}
 }
 

planner/cascades/transformation_rules.go

@@ -0,0 +1,42 @@
+// 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 cascades
+
+import (
+	plannercore "github.com/pingcap/tidb/planner/core"
+)
+
+// Transformation defines the interface for the transformation rules.
+type Transformation interface {
+	GetPattern() *Pattern
+	Match(expr *ExprIter) (matched bool, err error)
+	OnTransform(old *ExprIter) (new *GroupExpr, eraseOld bool, err error)
+}
+
+// GetTransformationRules gets the all the candidate transformation rules based
+// on the logical plan node.
+func GetTransformationRules(node plannercore.LogicalPlan) []Transformation {
+	return transformationMap[GetOperand(node)]
+}
+
+var transformationMap = map[Operand][]Transformation{
+	/**
+	operandSelect: []Transformation{
+		nil,
+	},
+	operandProject: []Transformation{
+		nil,
+	},
+	*/
+}

planner/optimize.go

@@ -16,6 +16,7 @@ package planner
 import (
 	"github.com/pingcap/tidb/ast"
 	"github.com/pingcap/tidb/infoschema"
+	"github.com/pingcap/tidb/planner/cascades"
 	plannercore "github.com/pingcap/tidb/planner/core"
 	"github.com/pingcap/tidb/privilege"
 	"github.com/pingcap/tidb/sessionctx"
@@ -62,7 +63,7 @@ func Optimize(ctx sessionctx.Context, node ast.Node, is infoschema.InfoSchema) (
 
 	// Handle the logical plan statement, use cascades planner if enabled.
 	if ctx.GetSessionVars().EnableCascadesPlanner {
-		return nil, errors.New("the cascades planner is not implemented yet")
+		return cascades.FindBestPlan(ctx, logic)
 	}
 	return plannercore.DoOptimize(builder.GetOptFlag(), logic)
 }