plan: remove unionscan schema. (pingcap#5119)

plan/column_pruning.go

@@ -156,17 +156,22 @@ func (p *Union) PruneColumns(parentUsedCols []*expression.Column) {
 	}
 }
 
+// PruneColumns implements LogicalPlan interface.
+func (p *LogicalUnionScan) PruneColumns(parentUsedCols []*expression.Column) {
+	for _, col := range p.schema.TblID2Handle {
+		parentUsedCols = append(parentUsedCols, col[0])
+	}
+	p.children[0].(LogicalPlan).PruneColumns(parentUsedCols)
+	p.SetSchema(p.children[0].Schema())
+}
+
 // PruneColumns implements LogicalPlan interface.
 func (p *DataSource) PruneColumns(parentUsedCols []*expression.Column) {
 	used := getUsedList(parentUsedCols, p.schema)
-	p.pruneUnionScanSchema(used)
 	handleIdx := -1 // -1 for not found.
 	for _, col := range p.schema.TblID2Handle {
 		handleIdx = col[0].Index
 	}
-	if p.unionScanSchema != nil {
-		used[handleIdx] = true
-	}
 	firstCol, firstColInfo := p.schema.Columns[0], p.Columns[0]
 	for i := len(used) - 1; i >= 0; i-- {
 		if !used[i] {
@@ -186,17 +191,6 @@ func (p *DataSource) PruneColumns(parentUsedCols []*expression.Column) {
 	}
 }
 
-func (p *DataSource) pruneUnionScanSchema(usedMask []bool) {
-	if p.unionScanSchema == nil {
-		return
-	}
-	for i := p.unionScanSchema.Len() - 1; i >= 0; i-- {
-		if !usedMask[i] {
-			p.unionScanSchema.Columns = append(p.unionScanSchema.Columns[:i], p.unionScanSchema.Columns[i+1:]...)
-		}
-	}
-}
-
 // PruneColumns implements LogicalPlan interface.
 func (p *TableDual) PruneColumns(_ []*expression.Column) {
 }

plan/dag_plan_test.go

@@ -666,7 +666,7 @@ func (s *testPlanSuite) TestDAGPlanBuilderUnionScan(c *C) {
 		},
 		{
 			sql:  "select c from t where c = 1",
-			best: "IndexReader(Index(t.c_d_e)[[1,1]])->UnionScan([eq(test.t.c, 1)])",
+			best: "IndexReader(Index(t.c_d_e)[[1,1]])->UnionScan([eq(test.t.c, 1)])->Projection",
 		},
 	}
 	for _, tt := range tests {

plan/initialize.go

@@ -116,6 +116,12 @@ func (p Selection) init(ctx context.Context) *Selection {
 	return &p
 }
 
+func (p LogicalUnionScan) init(ctx context.Context) *LogicalUnionScan {
+	p.basePlan = newBasePlan(TypeUnionScan, ctx, &p)
+	p.baseLogicalPlan = newBaseLogicalPlan(p.basePlan)
+	return &p
+}
+
 func (p Projection) init(ctx context.Context) *Projection {
 	p.basePlan = newBasePlan(TypeProj, ctx, &p)
 	p.baseLogicalPlan = newBaseLogicalPlan(p.basePlan)

plan/logical_plan_builder.go

@@ -126,8 +126,7 @@ func (b *planBuilder) buildResultSetNode(node ast.ResultSetNode) LogicalPlan {
 		case *ast.TableName:
 			p = b.buildDataSource(v)
 		default:
-			b.err = ErrUnsupportedType.Gen("unsupported table source type %T", v)
-			return nil
+			b.err = ErrUnsupportedType.GenByArgs(v)
 		}
 		if b.err != nil {
 			return nil
@@ -218,15 +217,8 @@ func extractOnCondition(conditions []expression.Expression, left LogicalPlan, ri
 }
 
 func extractTableAlias(p LogicalPlan) *model.CIStr {
-	if dataSource, ok := p.(*DataSource); ok {
-		if dataSource.TableAsName.L != "" {
-			return dataSource.TableAsName
-		}
-		return &dataSource.tableInfo.Name
-	} else if len(p.Schema().Columns) > 0 {
-		if p.Schema().Columns[0].TblName.L != "" {
-			return &(p.Schema().Columns[0].TblName)
-		}
+	if p.Schema().Len() > 0 && p.Schema().Columns[0].TblName.L != "" {
+		return &(p.Schema().Columns[0].TblName)
 	}
 	return nil
 }
@@ -1566,7 +1558,7 @@ func (b *planBuilder) buildDataSource(tn *ast.TableName) LogicalPlan {
 		statisticTable = handle.GetTableStats(tableInfo.ID)
 	}
 
-	p := DataSource{
+	ds := DataSource{
 		indexHints:     tn.IndexHints,
 		tableInfo:      tableInfo,
 		statisticTable: statisticTable,
@@ -1582,37 +1574,26 @@ func (b *planBuilder) buildDataSource(tn *ast.TableName) LogicalPlan {
 	} else {
 		columns = tbl.Cols()
 	}
-	var pkCol *expression.Column
-	p.Columns = make([]*model.ColumnInfo, 0, len(columns))
+	var handleCol *expression.Column
+	ds.Columns = make([]*model.ColumnInfo, 0, len(columns))
 	schema := expression.NewSchema(make([]*expression.Column, 0, len(columns))...)
 	for i, col := range columns {
-		p.Columns = append(p.Columns, col.ToInfo())
+		ds.Columns = append(ds.Columns, col.ToInfo())
 		schema.Append(&expression.Column{
-			FromID:   p.id,
+			FromID:   ds.id,
 			ColName:  col.Name,
 			TblName:  tableInfo.Name,
 			DBName:   schemaName,
 			RetType:  &col.FieldType,
 			Position: i,
 			ID:       col.ID})
 		if tableInfo.PKIsHandle && mysql.HasPriKeyFlag(col.Flag) {
-			pkCol = schema.Columns[schema.Len()-1]
-		}
-	}
-	needUnionScan := b.ctx.Txn() != nil && !b.ctx.Txn().IsReadOnly()
-	if b.needColHandle == 0 && !needUnionScan {
-		p.SetSchema(schema)
-		return b.projectVirtualColumns(p, columns)
-	}
-	if needUnionScan {
-		p.unionScanSchema = expression.NewSchema(make([]*expression.Column, 0, len(tableInfo.Columns))...)
-		for _, col := range schema.Columns {
-			p.unionScanSchema.Append(col)
+			handleCol = schema.Columns[schema.Len()-1]
 		}
 	}
-	if pkCol == nil {
-		idCol := &expression.Column{
-			FromID:   p.id,
+	if handleCol == nil {
+		handleCol = &expression.Column{
+			FromID:   ds.id,
 			DBName:   schemaName,
 			TblName:  tableInfo.Name,
 			ColName:  model.NewCIStr("_rowid"),
@@ -1621,30 +1602,35 @@ func (b *planBuilder) buildDataSource(tn *ast.TableName) LogicalPlan {
 			Index:    schema.Len(),
 			ID:       model.ExtraHandleID,
 		}
-		if needUnionScan && b.needColHandle > 0 {
-			p.unionScanSchema.Columns = append(p.unionScanSchema.Columns, idCol)
-			p.unionScanSchema.TblID2Handle[tableInfo.ID] = []*expression.Column{idCol}
-		}
-		p.Columns = append(p.Columns, &model.ColumnInfo{
+		ds.Columns = append(ds.Columns, &model.ColumnInfo{
 			ID:   model.ExtraHandleID,
 			Name: model.NewCIStr("_rowid"),
 		})
-		schema.Append(idCol)
-		schema.TblID2Handle[tableInfo.ID] = []*expression.Column{idCol}
-	} else {
-		if needUnionScan && b.needColHandle > 0 {
-			p.unionScanSchema.TblID2Handle[tableInfo.ID] = []*expression.Column{pkCol}
-		}
-		schema.TblID2Handle[tableInfo.ID] = []*expression.Column{pkCol}
+		schema.Append(handleCol)
 	}
-	p.SetSchema(schema)
-	return b.projectVirtualColumns(p, columns)
+	schema.TblID2Handle[tableInfo.ID] = []*expression.Column{handleCol}
+	ds.SetSchema(schema)
+	// make plan as DS -> US -> Proj
+	var result LogicalPlan = ds
+	if b.ctx.Txn() != nil && !b.ctx.Txn().IsReadOnly() {
+		ds.NeedColHandle = true
+		us := LogicalUnionScan{}.init(b.ctx)
+		us.SetSchema(ds.Schema().Clone())
+		setParentAndChildren(us, result)
+		result = us
+	}
+	proj := b.projectVirtualColumns(ds, columns)
+	if proj != nil {
+		setParentAndChildren(proj, result)
+		result = proj
+	}
+	return result
 }
 
 // projectVirtualColumns is only for DataSource. If some table has virtual generated columns,
 // we add a projection on the original DataSource, and calculate those columns in the projection
 // so that plans above it can reference generated columns by their name.
-func (b *planBuilder) projectVirtualColumns(ds *DataSource, columns []*table.Column) LogicalPlan {
+func (b *planBuilder) projectVirtualColumns(ds *DataSource, columns []*table.Column) *Projection {
 	var hasVirtualGeneratedColumn = false
 	for _, column := range columns {
 		if column.IsGenerated() && !column.GeneratedStored {
@@ -1653,7 +1639,7 @@ func (b *planBuilder) projectVirtualColumns(ds *DataSource, columns []*table.Col
 		}
 	}
 	if !hasVirtualGeneratedColumn {
-		return ds
+		return nil
 	}
 	var proj = Projection{
 		Exprs:            make([]expression.Expression, 0, len(columns)),
@@ -1683,7 +1669,6 @@ func (b *planBuilder) projectVirtualColumns(ds *DataSource, columns []*table.Col
 		proj.Exprs = append(proj.Exprs, expr)
 	}
 	proj.SetSchema(ds.Schema().Clone())
-	setParentAndChildren(proj, ds)
 	return proj
 }
 

plan/logical_plan_test.go

@@ -1544,8 +1544,8 @@ func (s *testPlanSuite) TestTopNPushDown(c *C) {
 			is:        s.is,
 			colMapper: make(map[*ast.ColumnNameExpr]int),
 		}
-		p := builder.build(stmt).(LogicalPlan)
 		c.Assert(builder.err, IsNil)
+		p := builder.build(stmt).(LogicalPlan)
 		p, err = logicalOptimize(builder.optFlag, p.(LogicalPlan), builder.ctx)
 		c.Assert(err, IsNil)
 		c.Assert(ToString(p), Equals, tt.best, comment)

plan/logical_plans.go

@@ -277,6 +277,14 @@ type TableDual struct {
 	RowCount int
 }
 
+// LogicalUnionScan is only used in non read-only txn.
+type LogicalUnionScan struct {
+	*basePlan
+	baseLogicalPlan
+
+	conditions []expression.Expression
+}
+
 // DataSource represents a tablescan without condition push down.
 type DataSource struct {
 	*basePlan
@@ -298,9 +306,6 @@ type DataSource struct {
 
 	// NeedColHandle is used in execution phase.
 	NeedColHandle bool
-
-	// This is schema the PhysicalUnionScan should be.
-	unionScanSchema *expression.Schema
 }
 
 func (p *DataSource) getPKIsHandleCol() *expression.Column {
@@ -320,14 +325,6 @@ func (p *DataSource) TableInfo() *model.TableInfo {
 	return p.tableInfo
 }
 
-// Schema implements the plan interface.
-func (p *DataSource) Schema() *expression.Schema {
-	if p.unionScanSchema != nil {
-		return p.unionScanSchema
-	}
-	return p.schema
-}
-
 // Union represents Union plan.
 type Union struct {
 	*basePlan

plan/physical_plan_builder.go

@@ -69,6 +69,16 @@ func (p *requiredProp) enforceProperty(task task, ctx context.Context) task {
 	return sort.attach2Task(task)
 }
 
+func (p *PhysicalUnionScan) getChildrenPossibleProps(prop *requiredProp) [][]*requiredProp {
+	return [][]*requiredProp{{prop}}
+}
+
+func (p *LogicalUnionScan) generatePhysicalPlans() []PhysicalPlan {
+	us := PhysicalUnionScan{Conditions: p.conditions}.init(p.ctx)
+	us.SetSchema(p.schema)
+	return []PhysicalPlan{us}
+}
+
 // getChildrenPossibleProps will check if this sort property can be pushed or not.
 // When a sort column will be replaced by scalar function, we refuse it.
 // When a sort column will be replaced by a constant, we just remove it.
@@ -177,7 +187,7 @@ func (p *LogicalJoin) getIndexJoinByOuterIdx(outerIdx int) []PhysicalPlan {
 		outerJoinKeys = p.RightJoinKeys
 	}
 	x, ok := innerChild.(*DataSource)
-	if !ok || x.unionScanSchema != nil {
+	if !ok {
 		return nil
 	}
 	indices, includeTableScan := availableIndices(x.indexHints, x.tableInfo)
@@ -567,17 +577,6 @@ func (p *baseLogicalPlan) getBestTask(bestTask task, prop *requiredProp, pp Phys
 	return bestTask, nil
 }
 
-func addUnionScan(cop *copTask, ds *DataSource) task {
-	t := finishCopTask(cop, ds.ctx)
-	us := PhysicalUnionScan{
-		Conditions:    ds.pushedDownConds,
-		NeedColHandle: ds.NeedColHandle,
-	}.init(ds.ctx)
-	us.SetSchema(ds.unionScanSchema)
-	us.profile = t.plan().statsProfile()
-	return us.attach2Task(t)
-}
-
 // tryToGetMemTask will check if this table is a mem table. If it is, it will produce a task and store it.
 func (p *DataSource) tryToGetMemTask(prop *requiredProp) (task task, err error) {
 	client := p.ctx.GetClient()
@@ -741,7 +740,7 @@ func (p *DataSource) convertToIndexScan(prop *requiredProp, idx *model.IndexInfo
 		Columns:             p.Columns,
 		Index:               idx,
 		dataSourceSchema:    p.schema,
-		physicalTableSource: physicalTableSource{NeedColHandle: p.NeedColHandle || p.unionScanSchema != nil},
+		physicalTableSource: physicalTableSource{NeedColHandle: p.NeedColHandle},
 	}.init(p.ctx)
 	statsTbl := p.statisticTable
 	rowCount := float64(statsTbl.Count)
@@ -827,9 +826,6 @@ func (p *DataSource) convertToIndexScan(prop *requiredProp, idx *model.IndexInfo
 		}
 		cop.keepOrder = true
 		is.addPushedDownSelection(cop, p, prop.expectedCnt)
-		if p.unionScanSchema != nil {
-			task = addUnionScan(cop, p)
-		}
 	} else {
 		is.OutOfOrder = true
 		expectedCnt := math.MaxFloat64
@@ -839,9 +835,6 @@ func (p *DataSource) convertToIndexScan(prop *requiredProp, idx *model.IndexInfo
 			return invalidTask, nil
 		}
 		is.addPushedDownSelection(cop, p, expectedCnt)
-		if p.unionScanSchema != nil {
-			task = addUnionScan(cop, p)
-		}
 	}
 	if prop.taskTp == rootTaskType {
 		task = finishCopTask(task, p.ctx)
@@ -994,7 +987,7 @@ func (p *DataSource) convertToTableScan(prop *requiredProp) (task task, err erro
 		Columns:             p.Columns,
 		TableAsName:         p.TableAsName,
 		DBName:              p.DBName,
-		physicalTableSource: physicalTableSource{NeedColHandle: p.NeedColHandle || p.unionScanSchema != nil},
+		physicalTableSource: physicalTableSource{NeedColHandle: p.NeedColHandle},
 	}.init(p.ctx)
 	ts.SetSchema(p.schema)
 	sc := p.ctx.GetSessionVars().StmtCtx
@@ -1056,9 +1049,6 @@ func (p *DataSource) convertToTableScan(prop *requiredProp) (task task, err erro
 		ts.KeepOrder = true
 		copTask.keepOrder = true
 		ts.addPushedDownSelection(copTask, p.profile, prop.expectedCnt)
-		if p.unionScanSchema != nil {
-			task = addUnionScan(copTask, p)
-		}
 	} else {
 		expectedCnt := math.MaxFloat64
 		if prop.isEmpty() {
@@ -1067,9 +1057,6 @@ func (p *DataSource) convertToTableScan(prop *requiredProp) (task task, err erro
 			return invalidTask, nil
 		}
 		ts.addPushedDownSelection(copTask, p.profile, expectedCnt)
-		if p.unionScanSchema != nil {
-			task = addUnionScan(copTask, p)
-		}
 	}
 	if prop.taskTp == rootTaskType {
 		task = finishCopTask(task, p.ctx)

plan/physical_plans.go

@@ -181,9 +181,6 @@ type physicalTableSource struct {
 
 	// NeedColHandle is used in execution phase.
 	NeedColHandle bool
-
-	// TODO: This should be removed after old planner was removed.
-	unionScanSchema *expression.Schema
 }
 
 func needCount(af aggregation.Aggregation) bool {

plan/planbuilder.go

@@ -32,7 +32,7 @@ import (
 
 // Error instances.
 var (
-	ErrUnsupportedType      = terror.ClassOptimizerPlan.New(CodeUnsupportedType, "Unsupported type")
+	ErrUnsupportedType      = terror.ClassOptimizerPlan.New(CodeUnsupportedType, "Unsupported type %T")
 	SystemInternalErrorType = terror.ClassOptimizerPlan.New(SystemInternalError, "System internal error")
 	ErrUnknownColumn        = terror.ClassOptimizerPlan.New(CodeUnknownColumn, mysql.MySQLErrName[mysql.ErrBadField])
 	ErrUnknownTable         = terror.ClassOptimizerPlan.New(CodeUnknownTable, mysql.MySQLErrName[mysql.ErrUnknownTable])