Planner refactoring

go/vt/sqlparser/ast_funcs.go

@@ -1264,6 +1264,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/sqlparser/ast_rewriting.go

@@ -233,6 +233,7 @@ func (er *expressionRewriter) sysVarRewrite(cursor *Cursor, node *ColName) {
 		sysvars.SQLSelectLimit.Name,
 		sysvars.TransactionMode.Name,
 		sysvars.Workload.Name,
+		sysvars.PlannerVersion.Name,
 		sysvars.DDLStrategy.Name,
 		sysvars.SessionUUID.Name,
 		sysvars.ReadAfterWriteGTID.Name,

go/vt/sqlparser/ast_rewriting_test.go

@@ -32,7 +32,7 @@ type myTestCase struct {
 	ddlStrategy, sessionUUID                                          bool
 	udv                                                               int
 	autocommit, clientFoundRows, skipQueryPlanCache                   bool
-	sqlSelectLimit, transactionMode, workload                         bool
+	sqlSelectLimit, transactionMode, workload, plannerVersion         bool
 }
 
 func TestRewrites(in *testing.T) {
@@ -165,6 +165,10 @@ func TestRewrites(in *testing.T) {
 		// SELECT * behaves different depending the join type used, so if that has been used, we won't rewrite
 		in:       "SELECT * FROM A JOIN B USING (id1,id2,id3)",
 		expected: "SELECT * FROM A JOIN B USING (id1,id2,id3)",
+	}, {
+		in:             "SELECT @@planner_version",
+		expected:       "SELECT :__vtplanner_version as `@@planner_version`",
+		plannerVersion: true,
 	}}
 
 	for _, tc := range tests {
@@ -198,6 +202,7 @@ func TestRewrites(in *testing.T) {
 			assert.Equal(tc.rawGTID, result.NeedsSysVar(sysvars.ReadAfterWriteGTID.Name), "should need rawGTID")
 			assert.Equal(tc.rawTimeout, result.NeedsSysVar(sysvars.ReadAfterWriteTimeOut.Name), "should need rawTimeout")
 			assert.Equal(tc.sessTrackGTID, result.NeedsSysVar(sysvars.SessionTrackGTIDs.Name), "should need sessTrackGTID")
+			assert.Equal(tc.plannerVersion, result.NeedsSysVar(sysvars.PlannerVersion.Name), "should need :__vtplanner_version")
 		})
 	}
 }

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/sysvars/sysvars.go

@@ -51,6 +51,7 @@ var (
 	SQLSelectLimit      = SystemVariable{Name: "sql_select_limit", Default: off}
 	TransactionMode     = SystemVariable{Name: "transaction_mode", IdentifierAsString: true}
 	Workload            = SystemVariable{Name: "workload", IdentifierAsString: true}
+	PlannerVersion      = SystemVariable{Name: "planner_version", IdentifierAsString: true}
 	Charset             = SystemVariable{Name: "charset", Default: utf8, IdentifierAsString: true}
 	Names               = SystemVariable{Name: "names", Default: utf8, IdentifierAsString: true}
 	SessionUUID         = SystemVariable{Name: "session_uuid", IdentifierAsString: true}

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"
 
@@ -316,6 +315,12 @@ func (e *Executor) addNeededBindVars(bindVarNeeds *sqlparser.BindVarNeeds, bindV
 				}
 			})
 			bindVars[key] = sqltypes.StringBindVariable(v)
+		case sysvars.PlannerVersion.Name:
+			v := *plannerVersion
+			ifOptionsExist(session, func(options *querypb.ExecuteOptions) {
+				v = options.GetPlannerVersion().String()
+			})
+			bindVars[key] = sqltypes.StringBindVariable(v)
 		}
 	}
 

go/vt/vtgate/planbuilder/builder.go

@@ -21,6 +21,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"
 
@@ -48,8 +49,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) Wireup2(semTable *semantics.SemTable) error {
+	err := c.lhs.Wireup2(semTable)
+	if err != nil {
+		return err
+	}
+	return c.rhs.Wireup2(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) Solves() semantics.TableSet {
+	return c.lhs.Solves().Merge(c.rhs.Solves())
+}
+
 // 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) Wireup2(semTable *semantics.SemTable) error {
+	err := jb.Right.Wireup2(semTable)
+	if err != nil {
+		return err
+	}
+	return jb.Left.Wireup2(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) Solves() semantics.TableSet {
+	return jb.Left.Solves().Merge(jb.Right.Solves())
+}
+
 // 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,104 @@
+/*
+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 = (*join2)(nil)
+
+// join is used to build a Join primitive.
+// It's used to build a normal join or a left join
+// operation.
+type join2 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 *join2) Order() int {
+	panic("implement me")
+}
+
+// ResultColumns implements the logicalPlan interface
+func (j *join2) ResultColumns() []*resultColumn {
+	panic("implement me")
+}
+
+// Reorder implements the logicalPlan interface
+func (j *join2) Reorder(i int) {
+	panic("implement me")
+}
+
+// Wireup implements the logicalPlan interface
+func (j *join2) Wireup(lp logicalPlan, jt *jointab) error {
+	panic("implement me")
+}
+
+// Wireup2 implements the logicalPlan interface
+func (j *join2) Wireup2(semTable *semantics.SemTable) error {
+	err := j.Left.Wireup2(semTable)
+	if err != nil {
+		return err
+	}
+	return j.Right.Wireup2(semTable)
+}
+
+// SupplyVar implements the logicalPlan interface
+func (j *join2) SupplyVar(from, to int, col *sqlparser.ColName, varname string) {
+	panic("implement me")
+}
+
+// SupplyCol implements the logicalPlan interface
+func (j *join2) SupplyCol(col *sqlparser.ColName) (rc *resultColumn, colNumber int) {
+	panic("implement me")
+}
+
+// SupplyWeightString implements the logicalPlan interface
+func (j *join2) SupplyWeightString(colNumber int) (weightcolNumber int, err error) {
+	panic("implement me")
+}
+
+// Primitive implements the logicalPlan interface
+func (j *join2) 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 *join2) Inputs() []logicalPlan {
+	panic("implement me")
+}
+
+// Rewrite implements the logicalPlan interface
+func (j *join2) Rewrite(inputs ...logicalPlan) error {
+	panic("implement me")
+}
+
+// Solves implements the logicalPlan interface
+func (j *join2) Solves() semantics.TableSet {
+	return j.Left.Solves().Merge(j.Right.Solves())
+}

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
 			}