mirror of
https://github.com/go-gitea/gitea.git
synced 2025-11-04 12:53:43 +01:00
b6a95a8cb3
* Dropped unused codekit config * Integrated dynamic and static bindata for public * Ignore public bindata * Add a general generate make task * Integrated flexible public assets into web command * Updated vendoring, added all missiong govendor deps * Made the linter happy with the bindata and dynamic code * Moved public bindata definition to modules directory * Ignoring the new bindata path now * Updated to the new public modules import path * Updated public bindata command and drop the new prefix
128 lines
3.4 KiB
Go
128 lines
3.4 KiB
Go
// 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)
|
|
}
|