refactor show clause. (pingcap#1940)

executor/builder.go

@@ -23,7 +23,6 @@ import (
 	"github.com/pingcap/tidb/infoschema"
 	"github.com/pingcap/tidb/kv"
 	"github.com/pingcap/tidb/model"
-	"github.com/pingcap/tidb/parser/opcode"
 	"github.com/pingcap/tidb/plan"
 	"github.com/pingcap/tidb/sessionctx/autocommit"
 	"github.com/pingcap/tidb/sessionctx/variable"
@@ -64,9 +63,6 @@ func (b *executorBuilder) build(p plan.Plan) Executor {
 		return b.buildExecute(v)
 	case *plan.Explain:
 		return b.buildExplain(v)
-	case *plan.Filter:
-		src := b.build(v.GetChildByIndex(0))
-		return b.buildFilter(src, v.Conditions)
 	case *plan.Insert:
 		return b.buildInsert(v)
 	case *plan.LoadData:
@@ -123,21 +119,10 @@ func (b *executorBuilder) build(p plan.Plan) Executor {
 	}
 }
 
-func (b *executorBuilder) buildFilter(src Executor, conditions []ast.ExprNode) Executor {
-	if len(conditions) == 0 {
-		return src
-	}
-	return &FilterExec{
-		Src:       src,
-		Condition: b.joinConditions(conditions),
-		ctx:       b.ctx,
-	}
-}
-
 func (b *executorBuilder) buildShowDDL(v *plan.ShowDDL) Executor {
 	return &ShowDDLExec{
-		fields: v.Fields(),
 		ctx:    b.ctx,
+		schema: v.GetSchema(),
 	}
 }
 
@@ -155,22 +140,6 @@ func (b *executorBuilder) buildDeallocate(v *plan.Deallocate) Executor {
 	}
 }
 
-func (b *executorBuilder) joinConditions(conditions []ast.ExprNode) ast.ExprNode {
-	if len(conditions) == 0 {
-		return nil
-	}
-	if len(conditions) == 1 {
-		return conditions[0]
-	}
-	condition := &ast.BinaryOperationExpr{
-		Op: opcode.AndAnd,
-		L:  conditions[0],
-		R:  b.joinConditions(conditions[1:]),
-	}
-	ast.MergeChildrenFlags(condition, condition.L, condition.R)
-	return condition
-}
-
 func (b *executorBuilder) buildSelectLock(v *plan.SelectLock) Executor {
 	src := b.build(v.GetChildByIndex(0))
 	if autocommit.ShouldAutocommit(b.ctx) {
@@ -235,7 +204,7 @@ func (b *executorBuilder) buildShow(v *plan.Show) Executor {
 		GlobalScope: v.GlobalScope,
 		ctx:         b.ctx,
 		is:          b.is,
-		fields:      v.Fields(),
+		schema:      v.GetSchema(),
 	}
 	if e.Tp == ast.ShowGrants && len(e.User) == 0 {
 		e.User = variable.GetSessionVars(e.ctx).User

executor/executor.go

@@ -118,19 +118,19 @@ type Executor interface {
 
 // ShowDDLExec represents a show DDL executor.
 type ShowDDLExec struct {
-	fields []*ast.ResultField
+	schema expression.Schema
 	ctx    context.Context
 	done   bool
 }
 
 // Schema implements the Executor Schema interface.
 func (e *ShowDDLExec) Schema() expression.Schema {
-	return nil
+	return e.schema
 }
 
 // Fields implements the Executor Fields interface.
 func (e *ShowDDLExec) Fields() []*ast.ResultField {
-	return e.fields
+	return nil
 }
 
 // Next implements the Executor Next interface.
@@ -178,9 +178,6 @@ func (e *ShowDDLExec) Next() (*Row, error) {
 		bgOwner,
 		bgJob,
 	)
-	for i, f := range e.fields {
-		f.Expr.SetValue(row.Data[i].GetValue())
-	}
 	e.done = true
 
 	return row, nil

executor/show.go

@@ -46,7 +46,7 @@ type ShowExec struct {
 	// Used by show variables
 	GlobalScope bool
 
-	fields []*ast.ResultField
+	schema expression.Schema
 	ctx    context.Context
 	is     infoschema.InfoSchema
 
@@ -57,12 +57,12 @@ type ShowExec struct {
 
 // Schema implements the Executor Schema interface.
 func (e *ShowExec) Schema() expression.Schema {
-	return nil
+	return e.schema
 }
 
 // Fields implements the Executor Fields interface.
 func (e *ShowExec) Fields() []*ast.ResultField {
-	return e.fields
+	return nil
 }
 
 // Next implements Execution Next interface.
@@ -77,9 +77,6 @@ func (e *ShowExec) Next() (*Row, error) {
 		return nil, nil
 	}
 	row := e.rows[e.cursor]
-	for i, field := range e.fields {
-		field.Expr.SetValue(row.Data[i].GetValue())
-	}
 	e.cursor++
 	return row, nil
 }

expression/expression.go

@@ -513,3 +513,27 @@ func EvaluateExprWithNull(schema Schema, expr Expression) (Expression, error) {
 		return x.Clone(), nil
 	}
 }
+
+// ResultFieldsToSchema converts slice of result fields to schema.
+func ResultFieldsToSchema(fields []*ast.ResultField) Schema {
+	schema := make(Schema, 0, len(fields))
+	for i, field := range fields {
+		colName := field.ColumnAsName
+		if colName.L == "" {
+			colName = field.Column.Name
+		}
+		tblName := field.TableAsName
+		if tblName.L == "" {
+			tblName = field.Table.Name
+		}
+		col := &Column{
+			ColName:  colName,
+			TblName:  tblName,
+			DBName:   field.DBName,
+			RetType:  &field.Column.FieldType,
+			Position: i,
+		}
+		schema = append(schema, col)
+	}
+	return schema
+}

plan/match_property.go

@@ -311,3 +311,8 @@ func (p *PhysicalDummyScan) matchProperty(_ *requiredProperty, _ ...*physicalPla
 func (p *Delete) matchProperty(_ *requiredProperty, _ ...*physicalPlanInfo) *physicalPlanInfo {
 	panic("You can't call this function!")
 }
+
+// matchProperty implements PhysicalPlan matchProperty interface.
+func (p *Show) matchProperty(_ *requiredProperty, _ ...*physicalPlanInfo) *physicalPlanInfo {
+	panic("You can't call this function!")
+}

plan/physical_plans.go

@@ -699,6 +699,12 @@ func (p *Delete) Copy() PhysicalPlan {
 	return &np
 }
 
+// Copy implements the PhysicalPlan Copy interface.
+func (p *Show) Copy() PhysicalPlan {
+	np := *p
+	return &np
+}
+
 // Copy implements the PhysicalPlan Copy interface.
 func (p *PhysicalUnionScan) Copy() PhysicalPlan {
 	np := *p

plan/plan.go

@@ -238,24 +238,28 @@ func newBaseLogicalPlan(tp string, a *idAllocator) baseLogicalPlan {
 // PredicatePushDown implements LogicalPlan PredicatePushDown interface.
 func (p *baseLogicalPlan) PredicatePushDown(predicates []expression.Expression) ([]expression.Expression, LogicalPlan, error) {
 	if len(p.GetChildren()) == 0 {
-		return predicates, nil, nil
+		return predicates, p, nil
 	}
 	child := p.GetChildByIndex(0).(LogicalPlan)
 	rest, _, err := child.PredicatePushDown(predicates)
 	if err != nil {
-		return nil, nil, errors.Trace(err)
+		return nil, p, errors.Trace(err)
 	}
 	if len(rest) > 0 {
 		err = addSelection(p, child, rest, p.allocator)
 		if err != nil {
-			return nil, nil, errors.Trace(err)
+			return nil, p, errors.Trace(err)
 		}
 	}
-	return nil, nil, nil
+	return nil, p, nil
 }
 
 // PruneColumnsAndResolveIndices implements LogicalPlan PruneColumnsAndResolveIndices interface.
 func (p *baseLogicalPlan) PruneColumnsAndResolveIndices(parentUsedCols []*expression.Column) ([]*expression.Column, error) {
+	if len(p.children) == 0 {
+		p.schema.InitIndices()
+		return nil, nil
+	}
 	outer, err := p.GetChildByIndex(0).(LogicalPlan).PruneColumnsAndResolveIndices(parentUsedCols)
 	p.SetSchema(p.GetChildByIndex(0).GetSchema())
 	return outer, errors.Trace(err)