Integrate public as bindata optionally (#293)

* 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

vendor/github.com/pingcap/tidb/optimizer/plan/plan.go

@@ -0,0 +1,127 @@
+// 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)
+}