v3: revamp: planBuilder->primitiveBuilder

sougou · sougou · commit e1e849d17ff8 · 2018-05-11T19:54:33.000-07:00
Signed-off-by: Sugu Sougoumarane &lt;ssougou@gmail.com&gt;
diff --git a/go/vt/vtgate/planbuilder/builder.go b/go/vt/vtgate/planbuilder/builder.go
@@ -57,7 +57,7 @@ type builder interface {
 
 	// PushFilter pushes a WHERE or HAVING clause expression
 	// to the specified origin.
-	PushFilter(pb *planBuilder, filter sqlparser.Expr, whereType string, origin builder) error
+	PushFilter(pb *primitiveBuilder, filter sqlparser.Expr, whereType string, origin builder) error
 
 	// PushSelect pushes the select expression to the specified
 	// originator. If successful, the originator must create
diff --git a/go/vt/vtgate/planbuilder/delete.go b/go/vt/vtgate/planbuilder/delete.go
@@ -33,7 +33,7 @@ func buildDeletePlan(del *sqlparser.Delete, vschema ContextVSchema) (*engine.Del
 	edel := &engine.Delete{
 		Query: generateQuery(del),
 	}
-	pb := newPlanBuilder(vschema, newJointab(sqlparser.GetBindvars(del)))
+	pb := newPrimitiveBuilder(vschema, newJointab(sqlparser.GetBindvars(del)))
 	if err := pb.processTableExprs(del.TableExprs); err != nil {
 		return nil, err
 	}
diff --git a/go/vt/vtgate/planbuilder/expr.go b/go/vt/vtgate/planbuilder/expr.go
@@ -79,7 +79,7 @@ func skipParenthesis(node sqlparser.Expr) sqlparser.Expr {
 //
 // If an expression has no references to the current query, then the left-most
 // origin is chosen as the default.
-func (pb *planBuilder) findOrigin(expr sqlparser.Expr) (origin builder, err error) {
+func (pb *primitiveBuilder) findOrigin(expr sqlparser.Expr) (origin builder, err error) {
 	highestOrigin := pb.bldr.First()
 	var subroutes []*route
 	err = sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
@@ -93,7 +93,7 @@ func (pb *planBuilder) findOrigin(expr sqlparser.Expr) (origin builder, err erro
 				highestOrigin = newOrigin
 			}
 		case *sqlparser.Subquery:
-			spb := newPlanBuilder(pb.vschema, pb.jt)
+			spb := newPrimitiveBuilder(pb.vschema, pb.jt)
 			switch stmt := node.Select.(type) {
 			case *sqlparser.Select:
 				if err := spb.processSelect(stmt, pb.st); err != nil {
@@ -158,7 +158,7 @@ func hasSubquery(node sqlparser.SQLNode) bool {
 	return has
 }
 
-func (pb *planBuilder) validateSubquerySamePlan(nodes ...sqlparser.SQLNode) bool {
+func (pb *primitiveBuilder) validateSubquerySamePlan(nodes ...sqlparser.SQLNode) bool {
 	var keyspace string
 	if rb, ok := pb.bldr.(*route); ok {
 		keyspace = rb.ERoute.Keyspace.Name
@@ -176,7 +176,7 @@ func (pb *planBuilder) validateSubquerySamePlan(nodes ...sqlparser.SQLNode) bool
 				if !inSubQuery {
 					return true, nil
 				}
-				spb := newPlanBuilder(pb.vschema, pb.jt)
+				spb := newPrimitiveBuilder(pb.vschema, pb.jt)
 				if err := spb.processSelect(nodeType, pb.st); err != nil {
 					samePlan = false
 					return false, err
@@ -194,7 +194,7 @@ func (pb *planBuilder) validateSubquerySamePlan(nodes ...sqlparser.SQLNode) bool
 				if !inSubQuery {
 					return true, nil
 				}
-				spb := newPlanBuilder(pb.vschema, pb.jt)
+				spb := newPrimitiveBuilder(pb.vschema, pb.jt)
 				if err := spb.processUnion(nodeType, pb.st); err != nil {
 					samePlan = false
 					return false, err
diff --git a/go/vt/vtgate/planbuilder/from.go b/go/vt/vtgate/planbuilder/from.go
@@ -30,23 +30,23 @@ import (
 
 // processTableExprs analyzes the FROM clause. It produces a builder
 // with all the routes identified.
-func (pb *planBuilder) processTableExprs(tableExprs sqlparser.TableExprs) error {
+func (pb *primitiveBuilder) processTableExprs(tableExprs sqlparser.TableExprs) error {
 	if len(tableExprs) == 1 {
 		return pb.processTableExpr(tableExprs[0])
 	}
 
 	if err := pb.processTableExpr(tableExprs[0]); err != nil {
 		return err
 	}
-	rpb := newPlanBuilder(pb.vschema, pb.jt)
+	rpb := newPrimitiveBuilder(pb.vschema, pb.jt)
 	if err := rpb.processTableExprs(tableExprs[1:]); err != nil {
 		return err
 	}
 	return pb.join(rpb, nil)
 }
 
 // processTableExpr produces a builder subtree for the given TableExpr.
-func (pb *planBuilder) processTableExpr(tableExpr sqlparser.TableExpr) error {
+func (pb *primitiveBuilder) processTableExpr(tableExpr sqlparser.TableExpr) error {
 	switch tableExpr := tableExpr.(type) {
 	case *sqlparser.AliasedTableExpr:
 		return pb.processAliasedTable(tableExpr)
@@ -73,12 +73,12 @@ func (pb *planBuilder) processTableExpr(tableExpr sqlparser.TableExpr) error {
 // versatile than a subquery. If a subquery becomes a route, then any result
 // columns that represent underlying vindex columns are also exposed as
 // vindex columns.
-func (pb *planBuilder) processAliasedTable(tableExpr *sqlparser.AliasedTableExpr) error {
+func (pb *primitiveBuilder) processAliasedTable(tableExpr *sqlparser.AliasedTableExpr) error {
 	switch expr := tableExpr.Expr.(type) {
 	case sqlparser.TableName:
 		return pb.buildTablePrimitive(tableExpr, expr)
 	case *sqlparser.Subquery:
-		spb := newPlanBuilder(pb.vschema, pb.jt)
+		spb := newPrimitiveBuilder(pb.vschema, pb.jt)
 		switch stmt := expr.Select.(type) {
 		case *sqlparser.Select:
 			if err := spb.processSelect(stmt, nil); err != nil {
@@ -136,7 +136,7 @@ func (pb *planBuilder) processAliasedTable(tableExpr *sqlparser.AliasedTableExpr
 }
 
 // buildTablePrimitive builds a primitive based on the table name.
-func (pb *planBuilder) buildTablePrimitive(tableExpr *sqlparser.AliasedTableExpr, tableName sqlparser.TableName) error {
+func (pb *primitiveBuilder) buildTablePrimitive(tableExpr *sqlparser.AliasedTableExpr, tableName sqlparser.TableName) error {
 	alias := tableName
 	if !tableExpr.As.IsEmpty() {
 		alias = sqlparser.TableName{Name: tableExpr.As}
@@ -202,7 +202,7 @@ func (pb *planBuilder) buildTablePrimitive(tableExpr *sqlparser.AliasedTableExpr
 // processJoin produces a builder subtree for the given Join.
 // If the left and right nodes can be part of the same route,
 // then it's a route. Otherwise, it's a join.
-func (pb *planBuilder) processJoin(ajoin *sqlparser.JoinTableExpr) error {
+func (pb *primitiveBuilder) processJoin(ajoin *sqlparser.JoinTableExpr) error {
 	switch ajoin.Join {
 	case sqlparser.JoinStr, sqlparser.StraightJoinStr, sqlparser.LeftJoinStr:
 	case sqlparser.RightJoinStr:
@@ -213,7 +213,7 @@ func (pb *planBuilder) processJoin(ajoin *sqlparser.JoinTableExpr) error {
 	if err := pb.processTableExpr(ajoin.LeftExpr); err != nil {
 		return err
 	}
-	rpb := newPlanBuilder(pb.vschema, pb.jt)
+	rpb := newPrimitiveBuilder(pb.vschema, pb.jt)
 	if err := rpb.processTableExpr(ajoin.RightExpr); err != nil {
 		return err
 	}
@@ -234,7 +234,7 @@ func convertToLeftJoin(ajoin *sqlparser.JoinTableExpr) {
 	ajoin.Join = sqlparser.LeftJoinStr
 }
 
-func (pb *planBuilder) join(rpb *planBuilder, ajoin *sqlparser.JoinTableExpr) error {
+func (pb *primitiveBuilder) join(rpb *primitiveBuilder, ajoin *sqlparser.JoinTableExpr) error {
 	if ajoin != nil && ajoin.Condition.Using != nil {
 		return errors.New("unsupported: join with USING(column_list) clause")
 	}
@@ -291,7 +291,7 @@ nomerge:
 // see if the primitive can be improved. The operation can fail if
 // the expression contains a non-pushable subquery. ajoin can be nil
 // if the join is on a ',' operator.
-func (pb *planBuilder) mergeRoutes(rpb *planBuilder, ajoin *sqlparser.JoinTableExpr) error {
+func (pb *primitiveBuilder) mergeRoutes(rpb *primitiveBuilder, ajoin *sqlparser.JoinTableExpr) error {
 	lRoute := pb.bldr.(*route)
 	rRoute := rpb.bldr.(*route)
 	sel := lRoute.Select.(*sqlparser.Select)
@@ -330,7 +330,7 @@ func (pb *planBuilder) mergeRoutes(rpb *planBuilder, ajoin *sqlparser.JoinTableE
 // isSameRoute returns true if the join constraint makes the routes
 // mergeable by unique vindex. The constraint has to be an equality
 // like a.id = b.id where both columns have the same unique vindex.
-func (pb *planBuilder) isSameRoute(rpb *planBuilder, filter sqlparser.Expr) bool {
+func (pb *primitiveBuilder) isSameRoute(rpb *primitiveBuilder, filter sqlparser.Expr) bool {
 	lRoute := pb.bldr.(*route)
 	rRoute := rpb.bldr.(*route)
 
diff --git a/go/vt/vtgate/planbuilder/insert.go b/go/vt/vtgate/planbuilder/insert.go
@@ -29,7 +29,7 @@ import (
 
 // buildInsertPlan builds the route for an INSERT statement.
 func buildInsertPlan(ins *sqlparser.Insert, vschema ContextVSchema) (*engine.Insert, error) {
-	pb := newPlanBuilder(vschema, newJointab(sqlparser.GetBindvars(ins)))
+	pb := newPrimitiveBuilder(vschema, newJointab(sqlparser.GetBindvars(ins)))
 	aliased := &sqlparser.AliasedTableExpr{Expr: ins.Table}
 	if err := pb.processAliasedTable(aliased); err != nil {
 		return nil, err
diff --git a/go/vt/vtgate/planbuilder/join.go b/go/vt/vtgate/planbuilder/join.go
@@ -68,7 +68,7 @@ type join struct {
 // newJoin makes a new join using the two planBuilder. ajoin can be nil
 // if the join is on a ',' operator. lpb will contain the resulting join.
 // rpb will be discarded.
-func newJoin(lpb, rpb *planBuilder, ajoin *sqlparser.JoinTableExpr) error {
+func newJoin(lpb, rpb *primitiveBuilder, ajoin *sqlparser.JoinTableExpr) error {
 	// This function converts ON clauses to WHERE clauses. The WHERE clause
 	// scope can see all tables, whereas the ON clause can only see the
 	// participants of the JOIN. However, since the ON clause doesn't allow
@@ -148,7 +148,7 @@ func (jb *join) ResultColumns() []*resultColumn {
 }
 
 // PushFilter satisfies the builder interface.
-func (jb *join) PushFilter(pb *planBuilder, filter sqlparser.Expr, whereType string, origin builder) error {
+func (jb *join) PushFilter(pb *primitiveBuilder, filter sqlparser.Expr, whereType string, origin builder) error {
 	if jb.isOnLeft(origin.Order()) {
 		return jb.Left.PushFilter(pb, filter, whereType, origin)
 	}
diff --git a/go/vt/vtgate/planbuilder/limit.go b/go/vt/vtgate/planbuilder/limit.go
@@ -73,7 +73,7 @@ func (l *limit) ResultColumns() []*resultColumn {
 }
 
 // PushFilter satisfies the builder interface.
-func (l *limit) PushFilter(_ *planBuilder, _ sqlparser.Expr, whereType string, _ builder) error {
+func (l *limit) PushFilter(_ *primitiveBuilder, _ sqlparser.Expr, whereType string, _ builder) error {
 	panic("BUG: unreachable")
 }
 
diff --git a/go/vt/vtgate/planbuilder/ordered_aggregate.go b/go/vt/vtgate/planbuilder/ordered_aggregate.go
@@ -64,7 +64,7 @@ type orderedAggregate struct {
 // that a primitive is needed to handle the aggregation, it builds an orderedAggregate
 // primitive and returns it. It returns a groupByHandler if there is aggregation it
 // can handle.
-func (pb *planBuilder) checkAggregates(sel *sqlparser.Select) (groupByHandler, error) {
+func (pb *primitiveBuilder) checkAggregates(sel *sqlparser.Select) (groupByHandler, error) {
 	rb, isRoute := pb.bldr.(*route)
 	if isRoute && rb.IsSingle() {
 		return rb, nil
@@ -175,7 +175,7 @@ func nodeHasAggregates(node sqlparser.SQLNode) bool {
 // we don't search the ResultColumns because they're not created yet. Also,
 // error conditions are treated as no match for simplicity; They will be
 // subsequently caught downstream.
-func (pb *planBuilder) groupByHasUniqueVindex(sel *sqlparser.Select, rb *route) bool {
+func (pb *primitiveBuilder) groupByHasUniqueVindex(sel *sqlparser.Select, rb *route) bool {
 	for _, expr := range sel.GroupBy {
 		var matchedExpr sqlparser.Expr
 		switch node := expr.(type) {
@@ -258,7 +258,7 @@ func (oa *orderedAggregate) ResultColumns() []*resultColumn {
 }
 
 // PushFilter satisfies the builder interface.
-func (oa *orderedAggregate) PushFilter(_ *planBuilder, _ sqlparser.Expr, whereType string, _ builder) error {
+func (oa *orderedAggregate) PushFilter(_ *primitiveBuilder, _ sqlparser.Expr, whereType string, _ builder) error {
 	return errors.New("unsupported: filtering on results of aggregates")
 }
 
@@ -364,7 +364,7 @@ func (oa *orderedAggregate) SetGroupBy(groupBy sqlparser.GroupBy) error {
 // 'select a, b, count(*) from t group by a, b order by b'
 // The following construct is not allowed:
 // 'select a, count(*) from t group by a order by count(*)'
-func (oa *orderedAggregate) PushOrderBy(pb *planBuilder, orderBy sqlparser.OrderBy) error {
+func (oa *orderedAggregate) PushOrderBy(pb *primitiveBuilder, orderBy sqlparser.OrderBy) error {
 	// Treat order by null as nil order by.
 	if len(orderBy) == 1 {
 		if _, ok := orderBy[0].Expr.(*sqlparser.NullVal); ok {
diff --git a/go/vt/vtgate/planbuilder/postprocess.go b/go/vt/vtgate/planbuilder/postprocess.go
@@ -39,7 +39,7 @@ type groupByHandler interface {
 
 // pushGroupBy processes the group by clause. It resolves all symbols,
 // and ensures that there are no subqueries.
-func (pb *planBuilder) pushGroupBy(sel *sqlparser.Select, grouper groupByHandler) error {
+func (pb *primitiveBuilder) pushGroupBy(sel *sqlparser.Select, grouper groupByHandler) error {
 	if sel.Distinct != "" {
 		// We can be here only if the builder could handle a group by.
 		if err := grouper.MakeDistinct(); err != nil {
@@ -62,7 +62,7 @@ func (pb *planBuilder) pushGroupBy(sel *sqlparser.Select, grouper groupByHandler
 // In the case of a join, it's only possible to push down if the
 // order by references columns of the left-most route. Otherwise, the
 // function returns an unsupported error.
-func (pb *planBuilder) pushOrderBy(orderBy sqlparser.OrderBy) error {
+func (pb *primitiveBuilder) pushOrderBy(orderBy sqlparser.OrderBy) error {
 	if oa, ok := pb.bldr.(*orderedAggregate); ok {
 		return oa.PushOrderBy(pb, orderBy)
 	}
@@ -130,7 +130,7 @@ func (pb *planBuilder) pushOrderBy(orderBy sqlparser.OrderBy) error {
 	return nil
 }
 
-func (pb *planBuilder) pushLimit(limit *sqlparser.Limit) error {
+func (pb *primitiveBuilder) pushLimit(limit *sqlparser.Limit) error {
 	if limit == nil {
 		return nil
 	}
diff --git a/go/vt/vtgate/planbuilder/primitive_builder.go b/go/vt/vtgate/planbuilder/primitive_builder.go
@@ -16,19 +16,19 @@ limitations under the License.
 
 package planbuilder
 
-// planBuilder is the top level type for building plans.
+// primitiveBuilder is the top level type for building plans.
 // It contains the current builder tree, the symtab and
 // the jointab. It can create transient planBuilders due
 // to the recursive nature of SQL.
-type planBuilder struct {
+type primitiveBuilder struct {
 	vschema ContextVSchema
 	jt      *jointab
 	bldr    builder
 	st      *symtab
 }
 
-func newPlanBuilder(vschema ContextVSchema, jt *jointab) *planBuilder {
-	return &planBuilder{
+func newPrimitiveBuilder(vschema ContextVSchema, jt *jointab) *primitiveBuilder {
+	return &primitiveBuilder{
 		vschema: vschema,
 		jt:      jt,
 	}
diff --git a/go/vt/vtgate/planbuilder/route.go b/go/vt/vtgate/planbuilder/route.go
@@ -111,7 +111,7 @@ func (rb *route) ResultColumns() []*resultColumn {
 
 // PushFilter satisfies the builder interface.
 // The primitive will be updated if the new filter improves the plan.
-func (rb *route) PushFilter(pb *planBuilder, filter sqlparser.Expr, whereType string, _ builder) error {
+func (rb *route) PushFilter(pb *primitiveBuilder, filter sqlparser.Expr, whereType string, _ builder) error {
 	sel := rb.Select.(*sqlparser.Select)
 	switch whereType {
 	case sqlparser.WhereStr:
@@ -129,7 +129,7 @@ func (rb *route) PushFilter(pb *planBuilder, filter sqlparser.Expr, whereType st
 // the route. This function should only be used when merging
 // routes, where the ON clause gets implicitly pushed into
 // the merged route.
-func (rb *route) UpdatePlan(pb *planBuilder, filter sqlparser.Expr) {
+func (rb *route) UpdatePlan(pb *primitiveBuilder, filter sqlparser.Expr) {
 	opcode, vindex, values := rb.computePlan(pb, filter)
 	if opcode == engine.SelectScatter {
 		return
@@ -172,7 +172,7 @@ func (rb *route) updateRoute(opcode engine.RouteOpcode, vindex vindexes.Vindex,
 }
 
 // computePlan computes the plan for the specified filter.
-func (rb *route) computePlan(pb *planBuilder, filter sqlparser.Expr) (opcode engine.RouteOpcode, vindex vindexes.Vindex, condition sqlparser.Expr) {
+func (rb *route) computePlan(pb *primitiveBuilder, filter sqlparser.Expr) (opcode engine.RouteOpcode, vindex vindexes.Vindex, condition sqlparser.Expr) {
 	switch node := filter.(type) {
 	case *sqlparser.ComparisonExpr:
 		switch node.Operator {
@@ -188,7 +188,7 @@ func (rb *route) computePlan(pb *planBuilder, filter sqlparser.Expr) (opcode eng
 }
 
 // computeEqualPlan computes the plan for an equality constraint.
-func (rb *route) computeEqualPlan(pb *planBuilder, comparison *sqlparser.ComparisonExpr) (opcode engine.RouteOpcode, vindex vindexes.Vindex, condition sqlparser.Expr) {
+func (rb *route) computeEqualPlan(pb *primitiveBuilder, comparison *sqlparser.ComparisonExpr) (opcode engine.RouteOpcode, vindex vindexes.Vindex, condition sqlparser.Expr) {
 	left := comparison.Left
 	right := comparison.Right
 	vindex = pb.st.Vindex(left, rb)
@@ -209,7 +209,7 @@ func (rb *route) computeEqualPlan(pb *planBuilder, comparison *sqlparser.Compari
 }
 
 // computeINPlan computes the plan for an IN constraint.
-func (rb *route) computeINPlan(pb *planBuilder, comparison *sqlparser.ComparisonExpr) (opcode engine.RouteOpcode, vindex vindexes.Vindex, condition sqlparser.Expr) {
+func (rb *route) computeINPlan(pb *primitiveBuilder, comparison *sqlparser.ComparisonExpr) (opcode engine.RouteOpcode, vindex vindexes.Vindex, condition sqlparser.Expr) {
 	vindex = pb.st.Vindex(comparison.Left, rb)
 	if vindex == nil {
 		return engine.SelectScatter, nil, nil
@@ -590,7 +590,7 @@ func (rb *route) IsSingle() bool {
 // SubqueryCanMerge returns nil if the supplied route that represents
 // a subquery can be merged with the outer route. If not, it
 // returns an appropriate error.
-func (rb *route) SubqueryCanMerge(pb *planBuilder, inner *route) error {
+func (rb *route) SubqueryCanMerge(pb *primitiveBuilder, inner *route) error {
 	if rb.ERoute.Keyspace.Name != inner.ERoute.Keyspace.Name {
 		return errors.New("unsupported: subquery keyspace different from outer query")
 	}
diff --git a/go/vt/vtgate/planbuilder/select.go b/go/vt/vtgate/planbuilder/select.go
@@ -26,7 +26,7 @@ import (
 
 // buildSelectPlan is the new function to build a Select plan.
 func buildSelectPlan(sel *sqlparser.Select, vschema ContextVSchema) (primitive engine.Primitive, err error) {
-	pb := newPlanBuilder(vschema, newJointab(sqlparser.GetBindvars(sel)))
+	pb := newPrimitiveBuilder(vschema, newJointab(sqlparser.GetBindvars(sel)))
 	if err := pb.processSelect(sel, nil); err != nil {
 		return nil, err
 	}
@@ -76,7 +76,7 @@ func buildSelectPlan(sel *sqlparser.Select, vschema ContextVSchema) (primitive e
 // The LIMIT clause is the last construct of a query. If it cannot be
 // pushed into a route, then a primitve is created on top of any
 // of the above trees to make it discard unwanted rows.
-func (pb *planBuilder) processSelect(sel *sqlparser.Select, outer *symtab) error {
+func (pb *primitiveBuilder) processSelect(sel *sqlparser.Select, outer *symtab) error {
 	if err := pb.processTableExprs(sel.From); err != nil {
 		return err
 	}
@@ -113,7 +113,7 @@ func (pb *planBuilder) processSelect(sel *sqlparser.Select, outer *symtab) error
 // pushFilter identifies the target route for the specified bool expr,
 // pushes it down, and updates the route info if the new constraint improves
 // the primitive. This function can push to a WHERE or HAVING clause.
-func (pb *planBuilder) pushFilter(boolExpr sqlparser.Expr, whereType string) error {
+func (pb *primitiveBuilder) pushFilter(boolExpr sqlparser.Expr, whereType string) error {
 	filters := splitAndExpression(nil, boolExpr)
 	reorderBySubquery(filters)
 	for _, filter := range filters {
@@ -150,7 +150,7 @@ func reorderBySubquery(filters []sqlparser.Expr) {
 
 // pushSelectExprs identifies the target route for the
 // select expressions and pushes them down.
-func (pb *planBuilder) pushSelectExprs(sel *sqlparser.Select, grouper groupByHandler) error {
+func (pb *primitiveBuilder) pushSelectExprs(sel *sqlparser.Select, grouper groupByHandler) error {
 	resultColumns, err := pb.pushSelectRoutes(sel.SelectExprs)
 	if err != nil {
 		return err
@@ -161,7 +161,7 @@ func (pb *planBuilder) pushSelectExprs(sel *sqlparser.Select, grouper groupByHan
 
 // pusheSelectRoutes is a convenience function that pushes all the select
 // expressions and returns the list of resultColumns generated for it.
-func (pb *planBuilder) pushSelectRoutes(selectExprs sqlparser.SelectExprs) ([]*resultColumn, error) {
+func (pb *primitiveBuilder) pushSelectRoutes(selectExprs sqlparser.SelectExprs) ([]*resultColumn, error) {
 	resultColumns := make([]*resultColumn, len(selectExprs))
 	for i, node := range selectExprs {
 		switch node := node.(type) {
diff --git a/go/vt/vtgate/planbuilder/subquery.go b/go/vt/vtgate/planbuilder/subquery.go
@@ -100,7 +100,7 @@ func (sq *subquery) ResultColumns() []*resultColumn {
 }
 
 // PushFilter satisfies the builder interface.
-func (sq *subquery) PushFilter(_ *planBuilder, _ sqlparser.Expr, whereType string, _ builder) error {
+func (sq *subquery) PushFilter(_ *primitiveBuilder, _ sqlparser.Expr, whereType string, _ builder) error {
 	return errors.New("unsupported: filtering on results of cross-shard subquery")
 }
 
diff --git a/go/vt/vtgate/planbuilder/union.go b/go/vt/vtgate/planbuilder/union.go
diff --git a/go/vt/vtgate/planbuilder/update.go b/go/vt/vtgate/planbuilder/update.go
diff --git a/go/vt/vtgate/planbuilder/vindex_func.go b/go/vt/vtgate/planbuilder/vindex_func.go

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ func buildDeletePlan(del sqlparser.Delete, vschema ContextVSchema) (engine.Del`
`33`	`33`	`edel := &engine.Delete{`
`34`	`34`	`Query: generateQuery(del),`
`35`	`35`	`}`
`36`		`- pb := newPlanBuilder(vschema, newJointab(sqlparser.GetBindvars(del)))`
	`36`	`+ pb := newPrimitiveBuilder(vschema, newJointab(sqlparser.GetBindvars(del)))`
`37`	`37`	`if err := pb.processTableExprs(del.TableExprs); err != nil {`
`38`	`38`	`return nil, err`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ func (l limit) ResultColumns() []resultColumn {`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`// PushFilter satisfies the builder interface.`
`76`		`-func (l limit) PushFilter(_ planBuilder, _ sqlparser.Expr, whereType string, _ builder) error {`
	`76`	`+func (l limit) PushFilter(_ primitiveBuilder, _ sqlparser.Expr, whereType string, _ builder) error {`
`77`	`77`	`panic("BUG: unreachable")`
`78`	`78`	`}`
`79`	`79`