bench-forgejo/vendor/github.com/pingcap/tidb/optimizer/plan/plan.go

128 lines
3.4 KiB
Go
Raw Normal View History

// Copyright 2015 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 plan
import (
"math"
"github.com/pingcap/tidb/ast"
)
// Plan is a description of an execution flow.
// It is created from ast.Node first, then optimized by optimizer,
// then used by executor to create a Cursor which executes the statement.
type Plan interface {
// Accept a visitor, implementation should call Visitor.Enter first,
// then call children Accept methods, finally call Visitor.Leave.
Accept(v Visitor) (out Plan, ok bool)
// Fields returns the result fields of the plan.
Fields() []*ast.ResultField
// SetFields sets the results fields of the plan.
SetFields(fields []*ast.ResultField)
// The cost before returning fhe first row.
StartupCost() float64
// The cost after returning all the rows.
TotalCost() float64
// The expected row count.
RowCount() float64
// SetLimit is used to push limit to upstream to estimate the cost.
SetLimit(limit float64)
}
// WithSrcPlan is a Plan has a source Plan.
type WithSrcPlan interface {
Plan
Src() Plan
SetSrc(src Plan)
}
// Visitor visits a Plan.
type Visitor interface {
// Enter is called before visit children.
// The out plan should be of exactly the same type as the in plan.
// if skipChildren is true, the children should not be visited.
Enter(in Plan) (out Plan, skipChildren bool)
// Leave is called after children has been visited, the out Plan can
// be another type, this is different than ast.Visitor Leave, because
// Plans only contain children plans as Plan interface type, so it is safe
// to return a different type of plan.
Leave(in Plan) (out Plan, ok bool)
}
// basePlan implements base Plan interface.
// Should be used as embedded struct in Plan implementations.
type basePlan struct {
fields []*ast.ResultField
startupCost float64
totalCost float64
rowCount float64
limit float64
}
// StartupCost implements Plan StartupCost interface.
func (p *basePlan) StartupCost() float64 {
return p.startupCost
}
// TotalCost implements Plan TotalCost interface.
func (p *basePlan) TotalCost() float64 {
return p.totalCost
}
// RowCount implements Plan RowCount interface.
func (p *basePlan) RowCount() float64 {
if p.limit == 0 {
return p.rowCount
}
return math.Min(p.rowCount, p.limit)
}
// SetLimit implements Plan SetLimit interface.
func (p *basePlan) SetLimit(limit float64) {
p.limit = limit
}
// Fields implements Plan Fields interface.
func (p *basePlan) Fields() []*ast.ResultField {
return p.fields
}
// SetFields implements Plan SetFields interface.
func (p *basePlan) SetFields(fields []*ast.ResultField) {
p.fields = fields
}
// srcPlan implements base PlanWithSrc interface.
type planWithSrc struct {
basePlan
src Plan
}
// Src implements PlanWithSrc interface.
func (p *planWithSrc) Src() Plan {
return p.src
}
// SetSrc implements PlanWithSrc interface.
func (p *planWithSrc) SetSrc(src Plan) {
p.src = src
}
// SetLimit implements Plan interface.
func (p *planWithSrc) SetLimit(limit float64) {
p.limit = limit
p.src.SetLimit(limit)
}