SET planning

go/vt/sqlparser/expression_converter.go

@@ -22,22 +22,28 @@ import (
  "vitess.io/vitess/go/vt/vtgate/evalengine"
 )
 
-var ExprNotSupported = fmt.Errorf("Expr Not Supported")
+// ErrExprNotSupported signals that the expression cannot be handled by expression evaluation engine.
+var ErrExprNotSupported = fmt.Errorf("Expr Not Supported")
 
 //Convert converts between AST expressions and executable expressions
 func Convert(e Expr) (evalengine.Expr, error) {
  switch node := e.(type) {
  case *SQLVal:
  switch node.Type {
  case IntVal:
- return evalengine.NewLiteralInt(node.Val)
+ return evalengine.NewLiteralIntFromBytes(node.Val)
  case FloatVal:
  return evalengine.NewLiteralFloat(node.Val)
  case ValArg:
- return &evalengine.BindVariable{Key: string(node.Val[1:])}, nil
+ return evalengine.NewBindVar(string(node.Val[1:])), nil
  case StrVal:
- return evalengine.NewLiteralString(node.Val)
+ return evalengine.NewLiteralString(node.Val), nil
  }
+ case BoolVal:
+ if node {
+ return evalengine.NewLiteralIntFromBytes([]byte("1"))
+ }
+ return evalengine.NewLiteralIntFromBytes([]byte("0"))
  case *BinaryExpr:
  var op evalengine.BinaryExpr
  switch node.Operator {
@@ -50,7 +56,7 @@ func Convert(e Expr) (evalengine.Expr, error) {
  case DivStr:
  op = &evalengine.Division{}
  default:
- return nil, ExprNotSupported
+ return nil, ErrExprNotSupported
  }
  left, err := Convert(node.Left)
  if err != nil {
@@ -67,5 +73,5 @@ func Convert(e Expr) (evalengine.Expr, error) {
  }, nil
 
  }
- return nil, ExprNotSupported
+ return nil, ErrExprNotSupported
 }

go/vt/sqlparser/set_normalizer.go

@@ -50,13 +50,13 @@ func (n *setNormalizer) normalizeSetExpr(in *SetExpr) (*SetExpr, error) {
  }
  switch {
  case strings.HasPrefix(in.Name.Lowered(), "session."):
- in.Name = NewColIdent(in.Name.Lowered()[8:])
+ in.Name = createColumn(in.Name.Lowered()[8:])
  in.Scope = SessionStr
  case strings.HasPrefix(in.Name.Lowered(), "global."):
- in.Name = NewColIdent(in.Name.Lowered()[7:])
+ in.Name = createColumn(in.Name.Lowered()[7:])
  in.Scope = GlobalStr
  case strings.HasPrefix(in.Name.Lowered(), "vitess_metadata."):
- in.Name = NewColIdent(in.Name.Lowered()[16:])
+ in.Name = createColumn(in.Name.Lowered()[16:])
  in.Scope = VitessMetadataStr
  default:
  in.Name.at = NoAt
@@ -79,3 +79,11 @@ func (n *setNormalizer) normalizeSetExpr(in *SetExpr) (*SetExpr, error) {
  }
  panic("this should never happen")
 }
+
+func createColumn(str string) ColIdent {
+ size := len(str)
+ if str[0] == '`' && str[size-1] == '`' {
+ str = str[1 : size-1]
+ }
+ return NewColIdent(str)
+}

go/vt/sqlparser/set_normalizer_test.go

@@ -26,8 +26,8 @@ func TestNormalizeSetExpr(t *testing.T) {
  tests := []struct {
  in, expected, err string
  }{{
- in: "@@foo = 42",
- expected: "session foo = 42",
+ in: "@@session.x.foo = 42",
+ expected: "session `x.foo` = 42",
  }, {
  in: "@@session.foo = 42",
  expected: "session foo = 42",
@@ -57,8 +57,14 @@ func TestNormalizeSetExpr(t *testing.T) {
  in: "@@x.foo = 42",
  expected: "session `x.foo` = 42",
  }, {
- in: "@@session.x.foo = 42",
- expected: "session `x.foo` = 42",
+ in: "@@session.`foo` = 1",
+ expected: "session foo = 1",
+ }, {
+ in: "@@global.`foo` = 1",
+ expected: "global foo = 1",
+ }, {
+ in: "@@vitess_metadata.`foo` = 1",
+ expected: "vitess_metadata foo = 1",
  //}, { TODO: we should support local scope as well
  // in: "local foo = 42",
  // expected: "session foo = 42",

go/vt/vtgate/engine/fake_vcursor_test.go

@@ -85,7 +85,31 @@ func (t noopVCursor) Session() SessionActions {
  return t
 }
 
-func (t noopVCursor) SetTarget(target string) error {
+func (t noopVCursor) SetAutocommit(bool) error {
+ panic("implement me")
+}
+
+func (t noopVCursor) SetClientFoundRows(bool) {
+ panic("implement me")
+}
+
+func (t noopVCursor) SetSkipQueryPlanCache(bool) {
+ panic("implement me")
+}
+
+func (t noopVCursor) SetSQLSelectLimit(int64) {
+ panic("implement me")
+}
+
+func (t noopVCursor) SetTransactionMode(vtgatepb.TransactionMode) {
+ panic("implement me")
+}
+
+func (t noopVCursor) SetWorkload(querypb.ExecuteOptions_Workload) {
+ panic("implement me")
+}
+
+func (t noopVCursor) SetTarget(string) error {
  panic("implement me")
 }
 
@@ -192,7 +216,7 @@ func (f *loggingVCursor) ShardSession() []*srvtopo.ResolvedShard {
  return nil
 }
 
-func (f *loggingVCursor) ExecuteVSchema(keyspace string, vschemaDDL *sqlparser.DDL) error {
+func (f *loggingVCursor) ExecuteVSchema(string, *sqlparser.DDL) error {
  panic("implement me")
 }
 
@@ -209,7 +233,7 @@ func (f *loggingVCursor) Context() context.Context {
  return context.Background()
 }
 
-func (f *loggingVCursor) SetContextTimeout(timeout time.Duration) context.CancelFunc {
+func (f *loggingVCursor) SetContextTimeout(time.Duration) context.CancelFunc {
  return func() {}
 }
 
@@ -221,7 +245,7 @@ func (f *loggingVCursor) RecordWarning(warning *querypb.QueryWarning) {
  f.warnings = append(f.warnings, warning)
 }
 
-func (f *loggingVCursor) Execute(method string, query string, bindvars map[string]*querypb.BindVariable, rollbackOnError bool, co vtgatepb.CommitOrder) (*sqltypes.Result, error) {
+func (f *loggingVCursor) Execute(_ string, query string, bindvars map[string]*querypb.BindVariable, rollbackOnError bool, co vtgatepb.CommitOrder) (*sqltypes.Result, error) {
  name := "Unknown"
  switch co {
  case vtgatepb.CommitOrder_NORMAL:
@@ -351,6 +375,30 @@ func (f *loggingVCursor) Rewind() {
  f.warnings = nil
 }
 
+func (f *loggingVCursor) SetAutocommit(bool) error {
+ panic("implement me")
+}
+
+func (f *loggingVCursor) SetClientFoundRows(bool) {
+ panic("implement me")
+}
+
+func (f *loggingVCursor) SetSkipQueryPlanCache(bool) {
+ panic("implement me")
+}
+
+func (f *loggingVCursor) SetSQLSelectLimit(int64) {
+ panic("implement me")
+}
+
+func (f *loggingVCursor) SetTransactionMode(vtgatepb.TransactionMode) {
+ panic("implement me")
+}
+
+func (f *loggingVCursor) SetWorkload(querypb.ExecuteOptions_Workload) {
+ panic("implement me")
+}
+
 func (f *loggingVCursor) nextResult() (*sqltypes.Result, error) {
  if f.results == nil || f.curResult >= len(f.results) {
  return &sqltypes.Result{}, f.resultErr

go/vt/vtgate/engine/primitive.go

@@ -107,6 +107,13 @@ type (
 
  // ShardSession returns shard info about open connections
  ShardSession() []*srvtopo.ResolvedShard
+
+ SetAutocommit(bool) error
+ SetClientFoundRows(bool)
+ SetSkipQueryPlanCache(bool)
+ SetSQLSelectLimit(int64)
+ SetTransactionMode(vtgatepb.TransactionMode)
+ SetWorkload(querypb.ExecuteOptions_Workload)
  }
 
  // Plan represents the execution strategy for a given query.

go/vt/vtgate/engine/set.go

@@ -20,6 +20,9 @@ import (
  "bytes"
  "encoding/json"
  "fmt"
+ "strings"
+
+ vtgatepb "vitess.io/vitess/go/vt/proto/vtgate"
 
  "vitess.io/vitess/go/vt/log"
 
@@ -78,13 +81,11 @@ type (
  Expr string
  }
 
- // SysVarSetSpecial implements the SetOp interface and will write the changes variable into the session
+ // SysVarSetAware implements the SetOp interface and will write the changes variable into the session
  // The special part is that these settings change the sessions behaviour in different ways
- SysVarSetSpecial struct {
- Name string
- Keyspace *vindexes.Keyspace
- TargetDestination key.Destination `json:",omitempty"`
- Expr string
+ SysVarSetAware struct {
+ Name string
+ Expr evalengine.Expr
  }
 )
 
@@ -338,3 +339,119 @@ func (svs *SysVarSet) checkAndUpdateSysVar(vcursor VCursor, res evalengine.Expre
  vcursor.Session().NeedsReservedConn()
  return true, nil
 }
+
+var _ SetOp = (*SysVarSetAware)(nil)
+
+// System variables that needs special handling
+const (
+ Autocommit = "autocommit"
+ ClientFoundRows = "client_found_rows"
+ SkipQueryPlanCache = "skip_query_plan_cache"
+ TxReadOnly = "tx_read_only"
+ TransactionReadOnly = "transaction_read_only"
+ SQLSelectLimit = "sql_select_limit"
+ TransactionMode = "transaction_mode"
+ Workload = "workload"
+ Charset = "charset"
+ Names = "names"
+)
+
+//MarshalJSON provides the type to SetOp for plan json
+func (svss *SysVarSetAware) MarshalJSON() ([]byte, error) {
+ return json.Marshal(struct {
+ Type string
+ Name string
+ Expr string
+ }{
+ Type: "SysVarAware",
+ Name: svss.Name,
+ Expr: svss.Expr.String(),
+ })
+}
+
+//Execute implements the SetOp interface method
+func (svss *SysVarSetAware) Execute(vcursor VCursor, env evalengine.ExpressionEnv) error {
+ switch svss.Name {
+ // These are all the boolean values we need to handle
+ case Autocommit, ClientFoundRows, SkipQueryPlanCache, TxReadOnly, TransactionReadOnly:
+ value, err := svss.Expr.Evaluate(env)
+ if err != nil {
+ return err
+ }
+ boolValue, err := value.ToBooleanStrict()
+ if err != nil {
+ return vterrors.Wrapf(err, "System setting '%s' can't be set to this value", svss.Name)
+ }
+ switch svss.Name {
+ case Autocommit:
+ vcursor.Session().SetAutocommit(boolValue)
+ case ClientFoundRows:
+ vcursor.Session().SetClientFoundRows(boolValue)
+ case SkipQueryPlanCache:
+ vcursor.Session().SetSkipQueryPlanCache(boolValue)
+ case TxReadOnly, TransactionReadOnly:
+ // TODO (4127): This is a dangerous NOP.
+ }
+
+ case SQLSelectLimit:
+ value, err := svss.Expr.Evaluate(env)
+ if err != nil {
+ return err
+ }
+
+ v := value.Value()
+ if !v.IsIntegral() {
+ return vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "unexpected value type for sql_select_limit: %T", value.Value().Type().String())
+ }
+ intValue, err := v.ToInt64()
+ if err != nil {
+ return err
+ }
+ vcursor.Session().SetSQLSelectLimit(intValue)
+
+ // String settings
+ case TransactionMode, Workload, Charset, Names:
+ value, err := svss.Expr.Evaluate(env)
+ if err != nil {
+ return err
+ }
+ v := value.Value()
+ if !v.IsText() && !v.IsBinary() {
+ return vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "unexpected value type for %s: %s", svss.Name, value.Value().Type().String())
+ }
+
+ str := v.ToString()
+ switch svss.Name {
+ case TransactionMode:
+ out, ok := vtgatepb.TransactionMode_value[strings.ToUpper(str)]
+ if !ok {
+ return vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "invalid transaction_mode: %s", str)
+ }
+ vcursor.Session().SetTransactionMode(vtgatepb.TransactionMode(out))
+ case Workload:
+ out, ok := querypb.ExecuteOptions_Workload_value[strings.ToUpper(str)]
+ if !ok {
+ return vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "invalid workload: %s", str)
+ }
+ vcursor.Session().SetWorkload(querypb.ExecuteOptions_Workload(out))
+ case Charset, Names:
+ switch strings.ToLower(str) {
+ case "", "utf8", "utf8mb4", "latin1", "default":
+ // do nothing
+ break
+ default:
+ return vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "unexpected value for charset/names: %v", str)
+ }
+ }
+
+ default:
+ return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "unsupported construct")
+ }
+
+ return nil
+}
+
+//VariableName implements the SetOp interface method
+func (svss *SysVarSetAware) VariableName() string {
+ return svss.Name
+}

go/vt/vtgate/engine/set_test.go

@@ -18,7 +18,6 @@ package engine
 
 import (
  "fmt"
- "strconv"
  "testing"
 
  "github.com/stretchr/testify/require"
@@ -75,12 +74,6 @@ func TestSetTable(t *testing.T) {
  expectedError string
  }
 
- intExpr := func(i int) evalengine.Expr {
- s := strconv.FormatInt(int64(i), 10)
- e, _ := evalengine.NewLiteralInt([]byte(s))
- return e
- }
-
  tests := []testCase{
  {
  testName: "nil set ops",
@@ -91,7 +84,7 @@ func TestSetTable(t *testing.T) {
  setOps: []SetOp{
  &UserDefinedVariable{
  Name: "x",
- Expr: intExpr(42),
+ Expr: evalengine.NewLiteralInt(42),
  },
  },
  expectedQueryLog: []string{
@@ -173,7 +166,7 @@ func TestSetTable(t *testing.T) {
  setOps: []SetOp{
  &UserDefinedVariable{
  Name: "x",
- Expr: intExpr(1),
+ Expr: evalengine.NewLiteralInt(1),
  },
  &SysVarIgnore{
  Name: "y",