tidb: github.com/pingcap/tidb/planner/memo Index | Files

package memo

import "github.com/pingcap/tidb/planner/memo"

Index

Package Files

expr_iterator.go group.go group_expr.go implementation.go pattern.go

type ExprIter Uses

type ExprIter struct {
    // Group and Element solely identify a Group expression.
    *Group
    *list.Element

    // Operand is the node of the pattern tree. The Operand type of the Group
    // expression must be matched with it.
    Operand

    // Children is used to iterate the child expressions.
    Children []*ExprIter
    // contains filtered or unexported fields
}

ExprIter enumerates all the equivalent expressions in the Group according to the expression pattern.

func NewExprIterFromGroupElem Uses

func NewExprIterFromGroupElem(elem *list.Element, p *Pattern) *ExprIter

NewExprIterFromGroupElem creates the iterator on the Group Element.

func (*ExprIter) GetExpr Uses

func (iter *ExprIter) GetExpr() *GroupExpr

GetExpr returns the root GroupExpr of the iterator.

func (*ExprIter) Matched Uses

func (iter *ExprIter) Matched() bool

Matched returns whether the iterator founds a Group expression matches the pattern.

func (*ExprIter) Next Uses

func (iter *ExprIter) Next() (found bool)

Next returns the next Group expression matches the pattern.

func (*ExprIter) Reset Uses

func (iter *ExprIter) Reset() (findMatch bool)

Reset resets the iterator to the first matched Group expression.

type Group Uses

type Group struct {
    Equivalents *list.List

    FirstExpr    map[Operand]*list.Element
    Fingerprints map[string]*list.Element

    Explored        bool
    SelfFingerprint string

    ImplMap map[string]Implementation
    Prop    *property.LogicalProperty
}

Group is short for expression Group, which is used to store all the logically equivalent expressions. It's a set of GroupExpr.

func NewGroupWithSchema Uses

func NewGroupWithSchema(e *GroupExpr, s *expression.Schema) *Group

NewGroupWithSchema creates a new Group with given schema.

func (*Group) Delete Uses

func (g *Group) Delete(e *GroupExpr)

Delete an existing Group expression.

func (*Group) Exists Uses

func (g *Group) Exists(e *GroupExpr) bool

Exists checks whether a Group expression existed in a Group.

func (*Group) FingerPrint Uses

func (g *Group) FingerPrint() string

FingerPrint returns the unique fingerprint of the Group.

func (*Group) GetFirstElem Uses

func (g *Group) GetFirstElem(operand Operand) *list.Element

GetFirstElem returns the first Group expression which matches the Operand. Return a nil pointer if there isn't.

func (*Group) GetImpl Uses

func (g *Group) GetImpl(prop *property.PhysicalProperty) Implementation

GetImpl returns the best Implementation satisfy the physical property.

func (*Group) Insert Uses

func (g *Group) Insert(e *GroupExpr) bool

Insert a nonexistent Group expression.

func (*Group) InsertImpl Uses

func (g *Group) InsertImpl(prop *property.PhysicalProperty, impl Implementation)

InsertImpl inserts the best Implementation satisfy the physical property.

type GroupExpr Uses

type GroupExpr struct {
    ExprNode plannercore.LogicalPlan
    Children []*Group
    Explored bool
    Group    *Group
    // contains filtered or unexported fields
}

GroupExpr is used to store all the logically equivalent expressions which have the same root operator. Different from a normal expression, the Children of a Group expression are expression Groups, not expressions. Another property of Group expression is that the child Group references will never be changed once the Group expression is created.

func NewGroupExpr Uses

func NewGroupExpr(node plannercore.LogicalPlan) *GroupExpr

NewGroupExpr creates a GroupExpr based on a logical plan node.

func (*GroupExpr) FingerPrint Uses

func (e *GroupExpr) FingerPrint() string

FingerPrint gets the unique fingerprint of the Group expression.

type Implementation Uses

type Implementation interface {
    CalcCost(outCount float64, childCosts []float64, children ...*Group) float64
    SetCost(cost float64)
    GetCost() float64
    GetPlan() plannercore.PhysicalPlan
}

Implementation defines the interface for cost of physical plan.

type Operand Uses

type Operand int

Operand is the node of a pattern tree, it represents a logical expression operator. Different from logical plan operator which holds the full information about an expression operator, Operand only stores the type information. An Operand may correspond to a concrete logical plan operator, or it can has special meaning, e.g, a placeholder for any logical plan operator.

const (
    // OperandAny is a placeholder for any Operand.
    OperandAny Operand = iota
    // OperandJoin for LogicalJoin.
    OperandJoin
    // OperandAggregation for LogicalAggregation.
    OperandAggregation
    // OperandProjection for LogicalProjection.
    OperandProjection
    // OperandSelection for LogicalSelection.
    OperandSelection
    // OperandApply for LogicalApply.
    OperandApply
    // OperandMaxOneRow for LogicalMaxOneRow.
    OperandMaxOneRow
    // OperandTableDual for LogicalTableDual.
    OperandTableDual
    // OperandDataSource for DataSource.
    OperandDataSource
    // OperandUnionScan for LogicalUnionScan.
    OperandUnionScan
    // OperandUnionAll for LogicalUnionAll.
    OperandUnionAll
    // OperandSort for LogicalSort.
    OperandSort
    // OperandTopN for LogicalTopN.
    OperandTopN
    // OperandLock for LogicalLock.
    OperandLock
    // OperandLimit for LogicalLimit.
    OperandLimit
    // OperandTableGather for TableGather.
    OperandTableGather
    // OperandTableScan for TableScan.
    OperandTableScan
    // OperandUnsupported is upper bound of defined Operand yet.
    OperandUnsupported
)

func GetOperand Uses

func GetOperand(p plannercore.LogicalPlan) Operand

GetOperand maps logical plan operator to Operand.

func (Operand) Match Uses

func (o Operand) Match(t Operand) bool

Match checks if current Operand matches specified one.

type Pattern Uses

type Pattern struct {
    Operand
    Children []*Pattern
}

Pattern defines the Match pattern for a rule. It describes a piece of logical expression. It's a tree-like structure and each node in the tree is an Operand.

func BuildPattern Uses

func BuildPattern(operand Operand, children ...*Pattern) *Pattern

BuildPattern builds a Pattern from Operand and child Patterns. Used in GetPattern() of Transformation interface to generate a Pattern.

func NewPattern Uses

func NewPattern(operand Operand) *Pattern

NewPattern creats a pattern node according to the Operand.

func (*Pattern) SetChildren Uses

func (p *Pattern) SetChildren(children ...*Pattern)

SetChildren sets the Children information for a pattern node.

Package memo imports 5 packages (graph) and is imported by 4 packages. Updated 2019-09-16. Refresh now. Tools for package owners.