Planner refactoring

go/vt/sqlparser/ast_funcs.go

@@ -1278,6 +1278,14 @@ func (lock LockOptionType) ToString() string {
 	}
 }
 
+// CompliantName is used to get the name of the bind variable to use for this column name
+func (node *ColName) CompliantName(suffix string) string {
+	if !node.Qualifier.IsEmpty() {
+		return node.Qualifier.Name.CompliantName() + "_" + node.Name.CompliantName() + suffix
+	}
+	return node.Name.CompliantName() + suffix
+}
+
 // AtCount represents the '@' count in ColIdent
 type AtCount int
 

go/vt/srvtopo/resilient_server_test.go

@@ -310,7 +310,8 @@ func TestGetSrvKeyspace(t *testing.T) {
 
 	time.Sleep(*srvTopoCacheTTL)
 
-	timeoutCtx, _ := context.WithTimeout(context.Background(), *srvTopoCacheRefresh*2) //nolint
+	timeoutCtx, cancel := context.WithTimeout(context.Background(), *srvTopoCacheRefresh*2) //nolint
+	defer cancel()
 	_, err = rs.GetSrvKeyspace(timeoutCtx, "test_cell", "test_ks")
 	wantErr := "timed out waiting for keyspace"
 	if err == nil || err.Error() != wantErr {
@@ -614,7 +615,8 @@ func TestGetSrvKeyspaceNames(t *testing.T) {
 
 	time.Sleep(*srvTopoCacheTTL)
 
-	timeoutCtx, _ := context.WithTimeout(context.Background(), *srvTopoCacheRefresh*2) //nolint
+	timeoutCtx, cancel := context.WithTimeout(context.Background(), *srvTopoCacheRefresh*2) //nolint
+	defer cancel()
 	_, err = rs.GetSrvKeyspaceNames(timeoutCtx, "test_cell", false)
 	wantErr := "timed out waiting for keyspace names"
 	if err == nil || err.Error() != wantErr {

go/vt/vtgate/engine/fake_vcursor_test.go

@@ -152,6 +152,10 @@ func (t noopVCursor) SetWorkload(querypb.ExecuteOptions_Workload) {
 	panic("implement me")
 }
 
+func (t noopVCursor) SetPlannerVersion(querypb.ExecuteOptions_PlannerVersion) {
+	panic("implement me")
+}
+
 func (t noopVCursor) SetTarget(string) error {
 	panic("implement me")
 }
@@ -483,6 +487,10 @@ func (f *loggingVCursor) SetWorkload(querypb.ExecuteOptions_Workload) {
 	panic("implement me")
 }
 
+func (f *loggingVCursor) SetPlannerVersion(querypb.ExecuteOptions_PlannerVersion) {
+	panic("implement me")
+}
+
 func (f *loggingVCursor) FindRoutedTable(tbl sqlparser.TableName) (*vindexes.Table, error) {
 	f.log = append(f.log, fmt.Sprintf("FindTable(%s)", sqlparser.String(tbl)))
 	return f.tableRoutes.tbl, nil

go/vt/vtgate/engine/primitive.go

@@ -126,6 +126,7 @@ type (
 		SetSQLSelectLimit(int64) error
 		SetTransactionMode(vtgatepb.TransactionMode)
 		SetWorkload(querypb.ExecuteOptions_Workload)
+		SetPlannerVersion(querypb.ExecuteOptions_PlannerVersion)
 		SetFoundRows(uint64)
 
 		SetDDLStrategy(string)

go/vt/vtgate/executor.go

@@ -108,7 +108,6 @@ type Executor struct {
 var executorOnce sync.Once
 
 const pathQueryPlans = "/debug/query_plans"
-
 const pathScatterStats = "/debug/scatter_stats"
 const pathVSchema = "/debug/vschema"
 

go/vt/vtgate/planbuilder/builder.go

@@ -22,6 +22,7 @@ import (
 
 	"vitess.io/vitess/go/sqltypes"
 	querypb "vitess.io/vitess/go/vt/proto/query"
+	"vitess.io/vitess/go/vt/vtgate/semantics"
 
 	"vitess.io/vitess/go/vt/vterrors"
 
@@ -49,8 +50,24 @@ type ContextVSchema interface {
 	SysVarSetEnabled() bool
 	KeyspaceExists(keyspace string) bool
 	AllKeyspace() ([]*vindexes.Keyspace, error)
+	GetSemTable() *semantics.SemTable
+	Planner() PlannerVersion
 }
 
+// PlannerVersion is an alias here to make the code more readable
+type PlannerVersion = querypb.ExecuteOptions_PlannerVersion
+
+const (
+	// V3 is also the default planner
+	V3 = querypb.ExecuteOptions_V3
+	// V4 uses the default V4 planner, which is the greedy planner
+	V4 = querypb.ExecuteOptions_V4
+	// V4GreedyOnly uses only the faster greedy planner
+	V4GreedyOnly = querypb.ExecuteOptions_V4Greedy
+	// V4Left2Right tries to emulate the V3 planner by only joining plans in the order they are listed in the FROM-clause
+	V4Left2Right = querypb.ExecuteOptions_V4Left2Right
+)
+
 type truncater interface {
 	SetTruncateColumnCount(int)
 }

go/vt/vtgate/planbuilder/concatenate.go

@@ -21,6 +21,7 @@ import (
 	"vitess.io/vitess/go/vt/sqlparser"
 	"vitess.io/vitess/go/vt/vterrors"
 	"vitess.io/vitess/go/vt/vtgate/engine"
+	"vitess.io/vitess/go/vt/vtgate/semantics"
 )
 
 type concatenate struct {
@@ -53,6 +54,14 @@ func (c *concatenate) Wireup(plan logicalPlan, jt *jointab) error {
 	return c.rhs.Wireup(plan, jt)
 }
 
+func (c *concatenate) WireupV4(semTable *semantics.SemTable) error {
+	err := c.lhs.WireupV4(semTable)
+	if err != nil {
+		return err
+	}
+	return c.rhs.WireupV4(semTable)
+}
+
 func (c *concatenate) SupplyVar(from, to int, col *sqlparser.ColName, varname string) {
 	panic("implement me")
 }
@@ -84,6 +93,10 @@ func (c *concatenate) Rewrite(inputs ...logicalPlan) error {
 	return nil
 }
 
+func (c *concatenate) ContainsTables() semantics.TableSet {
+	return c.lhs.ContainsTables().Merge(c.rhs.ContainsTables())
+}
+
 // Inputs implements the logicalPlan interface
 func (c *concatenate) Inputs() []logicalPlan {
 	return []logicalPlan{c.lhs, c.rhs}

go/vt/vtgate/planbuilder/join.go

@@ -19,6 +19,8 @@ package planbuilder
 import (
 	"errors"
 
+	"vitess.io/vitess/go/vt/vtgate/semantics"
+
 	vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc"
 	"vitess.io/vitess/go/vt/vterrors"
 
@@ -151,6 +153,15 @@ func (jb *join) Wireup(plan logicalPlan, jt *jointab) error {
 	return jb.Left.Wireup(plan, jt)
 }
 
+// Wireup2 implements the logicalPlan interface
+func (jb *join) WireupV4(semTable *semantics.SemTable) error {
+	err := jb.Right.WireupV4(semTable)
+	if err != nil {
+		return err
+	}
+	return jb.Left.WireupV4(semTable)
+}
+
 // SupplyVar implements the logicalPlan interface
 func (jb *join) SupplyVar(from, to int, col *sqlparser.ColName, varname string) {
 	if !jb.isOnLeft(from) {
@@ -235,6 +246,11 @@ func (jb *join) Rewrite(inputs ...logicalPlan) error {
 	return nil
 }
 
+// Solves implements the logicalPlan interface
+func (jb *join) ContainsTables() semantics.TableSet {
+	return jb.Left.ContainsTables().Merge(jb.Right.ContainsTables())
+}
+
 // Inputs implements the logicalPlan interface
 func (jb *join) Inputs() []logicalPlan {
 	return []logicalPlan{jb.Left, jb.Right}

go/vt/vtgate/planbuilder/join2.go

@@ -0,0 +1,103 @@
+/*
+Copyright 2019 The Vitess Authors.
+
+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,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package planbuilder
+
+import (
+	"vitess.io/vitess/go/vt/sqlparser"
+	"vitess.io/vitess/go/vt/vtgate/engine"
+	"vitess.io/vitess/go/vt/vtgate/semantics"
+)
+
+var _ logicalPlan = (*joinV4)(nil)
+
+// joinV4 is used to build a Join primitive.
+// It's used to build an inner join and only used by the V4 planner
+type joinV4 struct {
+	// Left and Right are the nodes for the join.
+	Left, Right logicalPlan
+	Cols        []int
+	Vars        map[string]int
+}
+
+// Order implements the logicalPlan interface
+func (j *joinV4) Order() int {
+	panic("implement me")
+}
+
+// ResultColumns implements the logicalPlan interface
+func (j *joinV4) ResultColumns() []*resultColumn {
+	panic("implement me")
+}
+
+// Reorder implements the logicalPlan interface
+func (j *joinV4) Reorder(i int) {
+	panic("implement me")
+}
+
+// Wireup implements the logicalPlan interface
+func (j *joinV4) Wireup(lp logicalPlan, jt *jointab) error {
+	panic("implement me")
+}
+
+// Wireup2 implements the logicalPlan interface
+func (j *joinV4) WireupV4(semTable *semantics.SemTable) error {
+	err := j.Left.WireupV4(semTable)
+	if err != nil {
+		return err
+	}
+	return j.Right.WireupV4(semTable)
+}
+
+// SupplyVar implements the logicalPlan interface
+func (j *joinV4) SupplyVar(from, to int, col *sqlparser.ColName, varname string) {
+	panic("implement me")
+}
+
+// SupplyCol implements the logicalPlan interface
+func (j *joinV4) SupplyCol(col *sqlparser.ColName) (rc *resultColumn, colNumber int) {
+	panic("implement me")
+}
+
+// SupplyWeightString implements the logicalPlan interface
+func (j *joinV4) SupplyWeightString(colNumber int) (weightcolNumber int, err error) {
+	panic("implement me")
+}
+
+// Primitive implements the logicalPlan interface
+func (j *joinV4) Primitive() engine.Primitive {
+	return &engine.Join{
+		Left:  j.Left.Primitive(),
+		Right: j.Right.Primitive(),
+		Cols:  j.Cols,
+		Vars:  j.Vars,
+	}
+}
+
+// Inputs implements the logicalPlan interface
+func (j *joinV4) Inputs() []logicalPlan {
+	panic("implement me")
+}
+
+// Rewrite implements the logicalPlan interface
+func (j *joinV4) Rewrite(inputs ...logicalPlan) error {
+	panic("implement me")
+}
+
+// Solves implements the logicalPlan interface
+func (j *joinV4) ContainsTables() semantics.TableSet {
+	return j.Left.ContainsTables().Merge(j.Right.ContainsTables())
+}

go/vt/vtgate/planbuilder/jointab.go

@@ -50,11 +50,7 @@ func (jt *jointab) Procure(plan logicalPlan, col *sqlparser.ColName, to int) str
 		suffix := ""
 		i := 0
 		for {
-			if !col.Qualifier.IsEmpty() {
-				joinVar = col.Qualifier.Name.CompliantName() + "_" + col.Name.CompliantName() + suffix
-			} else {
-				joinVar = col.Name.CompliantName() + suffix
-			}
+			joinVar = col.CompliantName(suffix)
 			if _, ok := jt.vars[joinVar]; !ok {
 				break
 			}

go/vt/vtgate/planbuilder/logical_plan.go

@@ -21,6 +21,7 @@ import (
 	"vitess.io/vitess/go/vt/sqlparser"
 	"vitess.io/vitess/go/vt/vterrors"
 	"vitess.io/vitess/go/vt/vtgate/engine"
+	"vitess.io/vitess/go/vt/vtgate/semantics"
 )
 
 // logicalPlan defines the interface that a primitive must
@@ -48,6 +49,9 @@ type logicalPlan interface {
 	// the lhs nodes.
 	Wireup(lp logicalPlan, jt *jointab) error
 
+	// WireupV4 does the wire up work for the V4 planner
+	WireupV4(semTable *semantics.SemTable) error
+
 	// SupplyVar finds the common root between from and to. If it's
 	// the common root, it supplies the requested var to the rhs tree.
 	// If the primitive already has the column in its list, it should
@@ -72,8 +76,15 @@ type logicalPlan interface {
 	// This function should only be called after Wireup is finished.
 	Primitive() engine.Primitive
 
+	// Inputs are the children of this plan
 	Inputs() []logicalPlan
+
+	// Rewrite replaces the inputs of this plan with the ones provided
 	Rewrite(inputs ...logicalPlan) error
+
+	// ContainsTables keeps track which query tables are being solved by this logical plan
+	// This is only applicable for plans that have been built with the V4 planner
+	ContainsTables() semantics.TableSet
 }
 
 //-------------------------------------------------------------------------
@@ -147,6 +158,10 @@ func (bc *logicalPlanCommon) Wireup(plan logicalPlan, jt *jointab) error {
 	return bc.input.Wireup(plan, jt)
 }
 
+func (bc *logicalPlanCommon) WireupV4(semTable *semantics.SemTable) error {
+	return bc.input.WireupV4(semTable)
+}
+
 func (bc *logicalPlanCommon) SupplyVar(from, to int, col *sqlparser.ColName, varname string) {
 	bc.input.SupplyVar(from, to, col, varname)
 }
@@ -173,6 +188,11 @@ func (bc *logicalPlanCommon) Inputs() []logicalPlan {
 	return []logicalPlan{bc.input}
 }
 
+// Solves implements the logicalPlan interface
+func (bc *logicalPlanCommon) ContainsTables() semantics.TableSet {
+	return bc.input.ContainsTables()
+}
+
 //-------------------------------------------------------------------------
 
 // resultsBuilder is a superset of logicalPlanCommon. It also handles

go/vt/vtgate/planbuilder/memory_sort.go

@@ -20,6 +20,8 @@ import (
 	"errors"
 	"fmt"
 
+	"vitess.io/vitess/go/vt/vtgate/semantics"
+
 	"vitess.io/vitess/go/sqltypes"
 	"vitess.io/vitess/go/vt/sqlparser"
 	"vitess.io/vitess/go/vt/vtgate/engine"
@@ -125,3 +127,7 @@ func (ms *memorySort) Wireup(plan logicalPlan, jt *jointab) error {
 	}
 	return ms.input.Wireup(plan, jt)
 }
+
+func (ms *memorySort) WireupV4(semTable *semantics.SemTable) error {
+	return ms.input.WireupV4(semTable)
+}

go/vt/vtgate/planbuilder/merge_sort.go

@@ -19,6 +19,7 @@ package planbuilder
 import (
 	"vitess.io/vitess/go/sqltypes"
 	"vitess.io/vitess/go/vt/vtgate/engine"
+	"vitess.io/vitess/go/vt/vtgate/semantics"
 )
 
 var _ logicalPlan = (*mergeSort)(nil)
@@ -82,3 +83,7 @@ func (ms *mergeSort) Wireup(plan logicalPlan, jt *jointab) error {
 	rb.eroute.TruncateColumnCount = ms.truncateColumnCount
 	return ms.input.Wireup(plan, jt)
 }
+
+func (ms *mergeSort) WireupV4(semTable *semantics.SemTable) error {
+	return ms.input.WireupV4(semTable)
+}