vitess.io/vitess@v0.16.2/go/vt/vtgate/engine/set_test.go (about)

     1  /*
     2  Copyright 2020 The Vitess Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package engine
    18  
    19  import (
    20  	"context"
    21  	"errors"
    22  	"fmt"
    23  	"testing"
    24  
    25  	"vitess.io/vitess/go/vt/sqlparser"
    26  	"vitess.io/vitess/go/vt/srvtopo"
    27  
    28  	"github.com/stretchr/testify/require"
    29  
    30  	"vitess.io/vitess/go/mysql/collations"
    31  	"vitess.io/vitess/go/vt/vtgate/evalengine"
    32  
    33  	"vitess.io/vitess/go/sqltypes"
    34  	"vitess.io/vitess/go/vt/key"
    35  	"vitess.io/vitess/go/vt/vtgate/vindexes"
    36  
    37  	querypb "vitess.io/vitess/go/vt/proto/query"
    38  )
    39  
    40  func TestSetSystemVariableAsString(t *testing.T) {
    41  	setOp := SysVarReservedConn{
    42  		Name: "x",
    43  		Keyspace: &vindexes.Keyspace{
    44  			Name:    "ks",
    45  			Sharded: true,
    46  		},
    47  		Expr: "dummy_expr",
    48  	}
    49  
    50  	set := &Set{
    51  		Ops:   []SetOp{&setOp},
    52  		Input: &SingleRow{},
    53  	}
    54  	vc := &loggingVCursor{
    55  		shards: []string{"-20", "20-"},
    56  		results: []*sqltypes.Result{sqltypes.MakeTestResult(
    57  			sqltypes.MakeTestFields(
    58  				"id",
    59  				"varchar",
    60  			),
    61  			"foobar",
    62  		)},
    63  		shardSession: []*srvtopo.ResolvedShard{{Target: &querypb.Target{Keyspace: "ks", Shard: "-20"}}},
    64  	}
    65  	_, err := set.TryExecute(context.Background(), vc, map[string]*querypb.BindVariable{}, false)
    66  	require.NoError(t, err)
    67  
    68  	vc.ExpectLog(t, []string{
    69  		"ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)",
    70  		"ExecuteMultiShard ks.-20: select dummy_expr from dual where @@x != dummy_expr {} false false",
    71  		"SysVar set with (x,'foobar')",
    72  		"Needs Reserved Conn",
    73  		"ExecuteMultiShard ks.-20: set x = dummy_expr {} false false",
    74  	})
    75  }
    76  
    77  func TestSetTable(t *testing.T) {
    78  	type testCase struct {
    79  		testName         string
    80  		setOps           []SetOp
    81  		qr               []*sqltypes.Result
    82  		expectedQueryLog []string
    83  		expectedWarning  []*querypb.QueryWarning
    84  		expectedError    string
    85  		input            Primitive
    86  		execErr          error
    87  		mysqlVersion     string
    88  		disableSetVar    bool
    89  	}
    90  
    91  	ks := &vindexes.Keyspace{Name: "ks", Sharded: true}
    92  	tests := []testCase{{
    93  		testName:         "nil set ops",
    94  		expectedQueryLog: []string{},
    95  	}, {
    96  		testName: "udv",
    97  		setOps: []SetOp{
    98  			&UserDefinedVariable{
    99  				Name: "x",
   100  				Expr: evalengine.NewLiteralInt(42),
   101  			},
   102  		},
   103  		expectedQueryLog: []string{
   104  			`UDV set with (x,INT64(42))`,
   105  		},
   106  	}, {
   107  		testName: "udv with input",
   108  		setOps: []SetOp{
   109  			&UserDefinedVariable{
   110  				Name: "x",
   111  				Expr: evalengine.NewColumn(0, collations.TypedCollation{}),
   112  			},
   113  		},
   114  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(
   115  			sqltypes.MakeTestFields(
   116  				"col0",
   117  				"datetime",
   118  			),
   119  			"2020-10-28",
   120  		)},
   121  		expectedQueryLog: []string{
   122  			`ResolveDestinations ks [] Destinations:DestinationAnyShard()`,
   123  			`ExecuteMultiShard ks.-20: select now() from dual {} false false`,
   124  			`UDV set with (x,DATETIME("2020-10-28"))`,
   125  		},
   126  		input: &Send{
   127  			Keyspace:          ks,
   128  			TargetDestination: key.DestinationAnyShard{},
   129  			Query:             "select now() from dual",
   130  			SingleShardOnly:   true,
   131  		},
   132  	}, {
   133  		testName: "sysvar ignore",
   134  		setOps: []SetOp{
   135  			&SysVarIgnore{
   136  				Name: "x",
   137  				Expr: "42",
   138  			},
   139  		},
   140  	}, {
   141  		testName: "sysvar check and ignore",
   142  		setOps: []SetOp{
   143  			&SysVarCheckAndIgnore{
   144  				Name:              "x",
   145  				Keyspace:          ks,
   146  				TargetDestination: key.DestinationAnyShard{},
   147  				Expr:              "dummy_expr",
   148  			},
   149  		},
   150  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(
   151  			sqltypes.MakeTestFields(
   152  				"id",
   153  				"int64",
   154  			),
   155  			"1",
   156  		)},
   157  		expectedQueryLog: []string{
   158  			`ResolveDestinations ks [] Destinations:DestinationAnyShard()`,
   159  			`ExecuteMultiShard ks.-20: select 1 from dual where @@x = dummy_expr {} false false`,
   160  		},
   161  	}, {
   162  		testName: "sysvar check and error",
   163  		setOps: []SetOp{
   164  			&SysVarCheckAndIgnore{
   165  				Name:              "x",
   166  				Keyspace:          ks,
   167  				TargetDestination: key.DestinationAnyShard{},
   168  				Expr:              "dummy_expr",
   169  			},
   170  		},
   171  		expectedQueryLog: []string{
   172  			`ResolveDestinations ks [] Destinations:DestinationAnyShard()`,
   173  			`ExecuteMultiShard ks.-20: select 1 from dual where @@x = dummy_expr {} false false`,
   174  		},
   175  	}, {
   176  		testName: "sysvar checkAndIgnore multi destination error",
   177  		setOps: []SetOp{
   178  			&SysVarCheckAndIgnore{
   179  				Name:              "x",
   180  				Keyspace:          ks,
   181  				TargetDestination: key.DestinationAllShards{},
   182  				Expr:              "dummy_expr",
   183  			},
   184  		},
   185  		expectedQueryLog: []string{
   186  			`ResolveDestinations ks [] Destinations:DestinationAllShards()`,
   187  		},
   188  		expectedError: "Unexpected error, DestinationKeyspaceID mapping to multiple shards: DestinationAllShards()",
   189  	}, {
   190  		testName: "sysvar checkAndIgnore execute error",
   191  		setOps: []SetOp{
   192  			&SysVarCheckAndIgnore{
   193  				Name:              "x",
   194  				Keyspace:          ks,
   195  				TargetDestination: key.DestinationAnyShard{},
   196  				Expr:              "dummy_expr",
   197  			},
   198  		},
   199  		expectedQueryLog: []string{
   200  			`ResolveDestinations ks [] Destinations:DestinationAnyShard()`,
   201  			`ExecuteMultiShard ks.-20: select 1 from dual where @@x = dummy_expr {} false false`,
   202  		},
   203  		execErr: errors.New("some random error"),
   204  	}, {
   205  		testName: "udv ignore checkAndIgnore ",
   206  		setOps: []SetOp{
   207  			&UserDefinedVariable{
   208  				Name: "x",
   209  				Expr: evalengine.NewLiteralInt(1),
   210  			},
   211  			&SysVarIgnore{
   212  				Name: "y",
   213  				Expr: "2",
   214  			},
   215  			&SysVarCheckAndIgnore{
   216  				Name:              "z",
   217  				Keyspace:          ks,
   218  				TargetDestination: key.DestinationAnyShard{},
   219  				Expr:              "dummy_expr",
   220  			},
   221  		},
   222  		expectedQueryLog: []string{
   223  			`UDV set with (x,INT64(1))`,
   224  			`ResolveDestinations ks [] Destinations:DestinationAnyShard()`,
   225  			`ExecuteMultiShard ks.-20: select 1 from dual where @@z = dummy_expr {} false false`,
   226  		},
   227  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(
   228  			sqltypes.MakeTestFields(
   229  				"id",
   230  				"int64",
   231  			),
   232  			"1",
   233  		)},
   234  	}, {
   235  		testName: "sysvar set without destination",
   236  		setOps: []SetOp{
   237  			&SysVarReservedConn{
   238  				Name:              "x",
   239  				Keyspace:          ks,
   240  				TargetDestination: key.DestinationAnyShard{},
   241  				Expr:              "dummy_expr",
   242  			},
   243  		},
   244  		expectedQueryLog: []string{
   245  			`ResolveDestinations ks [] Destinations:DestinationAnyShard()`,
   246  			`Needs Reserved Conn`,
   247  			`ExecuteMultiShard ks.-20: set @@x = dummy_expr {} false false`,
   248  		},
   249  	}, {
   250  		testName: "sysvar set not modifying setting",
   251  		setOps: []SetOp{
   252  			&SysVarReservedConn{
   253  				Name:     "x",
   254  				Keyspace: ks,
   255  				Expr:     "dummy_expr",
   256  			},
   257  		},
   258  		expectedQueryLog: []string{
   259  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   260  			`ExecuteMultiShard ks.-20: select dummy_expr from dual where @@x != dummy_expr {} false false`,
   261  		},
   262  	}, {
   263  		testName: "sysvar set modifying setting",
   264  		setOps: []SetOp{
   265  			&SysVarReservedConn{
   266  				Name:     "x",
   267  				Keyspace: ks,
   268  				Expr:     "dummy_expr",
   269  			},
   270  		},
   271  		expectedQueryLog: []string{
   272  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   273  			`ExecuteMultiShard ks.-20: select dummy_expr from dual where @@x != dummy_expr {} false false`,
   274  			`SysVar set with (x,123456)`,
   275  			`Needs Reserved Conn`,
   276  		},
   277  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(
   278  			sqltypes.MakeTestFields(
   279  				"id",
   280  				"int64",
   281  			),
   282  			"123456",
   283  		)},
   284  	}, {
   285  		testName: "sql_mode no change - same",
   286  		setOps: []SetOp{
   287  			&SysVarReservedConn{
   288  				Name:     "sql_mode",
   289  				Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true},
   290  				Expr:     "'a,b'",
   291  			},
   292  		},
   293  		expectedQueryLog: []string{
   294  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   295  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'a,b' new {} false false`,
   296  		},
   297  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   298  			"a,b|a,b",
   299  		)},
   300  	}, {
   301  		testName: "sql_mode no change - jumbled orig",
   302  		setOps: []SetOp{
   303  			&SysVarReservedConn{
   304  				Name:     "sql_mode",
   305  				Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true},
   306  				Expr:     "'a,b'",
   307  			},
   308  		},
   309  		expectedQueryLog: []string{
   310  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   311  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'a,b' new {} false false`,
   312  		},
   313  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   314  			"b,a|a,b",
   315  		)},
   316  	}, {
   317  		testName: "sql_mode no change - jumbled new",
   318  		setOps: []SetOp{
   319  			&SysVarReservedConn{
   320  				Name:     "sql_mode",
   321  				Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true},
   322  				Expr:     "'b,a'",
   323  			},
   324  		},
   325  		expectedQueryLog: []string{
   326  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   327  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'b,a' new {} false false`,
   328  		},
   329  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   330  			"a,b|b,a",
   331  		)},
   332  	}, {
   333  		testName: "sql_mode no change - same mixed case",
   334  		setOps: []SetOp{
   335  			&SysVarReservedConn{
   336  				Name:     "sql_mode",
   337  				Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true},
   338  				Expr:     "'B,a'",
   339  			},
   340  		},
   341  		expectedQueryLog: []string{
   342  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   343  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'B,a' new {} false false`,
   344  		},
   345  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   346  			"a,b|B,a",
   347  		)},
   348  	}, {
   349  		testName: "sql_mode no change - same multiple",
   350  		setOps: []SetOp{
   351  			&SysVarReservedConn{
   352  				Name:          "sql_mode",
   353  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   354  				Expr:          "'B,a,A,B,b,a'",
   355  				SupportSetVar: true,
   356  			},
   357  		},
   358  		expectedQueryLog: []string{
   359  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   360  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'B,a,A,B,b,a' new {} false false`,
   361  		},
   362  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   363  			"a,b|B,a,A,B,b,a",
   364  		)},
   365  	}, {
   366  		testName:     "sql_mode change - changed additional - MySQL57",
   367  		mysqlVersion: "50709",
   368  		setOps: []SetOp{
   369  			&SysVarReservedConn{
   370  				Name:          "sql_mode",
   371  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   372  				Expr:          "'B,a,A,B,b,a,c'",
   373  				SupportSetVar: true,
   374  			},
   375  		},
   376  		expectedQueryLog: []string{
   377  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   378  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'B,a,A,B,b,a,c' new {} false false`,
   379  			"SysVar set with (sql_mode,'B,a,A,B,b,a,c')",
   380  			"Needs Reserved Conn",
   381  		},
   382  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   383  			"a,b|B,a,A,B,b,a,c",
   384  		)},
   385  	}, {
   386  		testName:     "sql_mode change - changed less - MySQL57",
   387  		mysqlVersion: "50709",
   388  		setOps: []SetOp{
   389  			&SysVarReservedConn{
   390  				Name:          "sql_mode",
   391  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   392  				Expr:          "'B,b,B,b'",
   393  				SupportSetVar: true,
   394  			},
   395  		},
   396  		expectedQueryLog: []string{
   397  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   398  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'B,b,B,b' new {} false false`,
   399  			"SysVar set with (sql_mode,'B,b,B,b')",
   400  			"Needs Reserved Conn",
   401  		},
   402  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   403  			"a,b|B,b,B,b",
   404  		)},
   405  	}, {
   406  		testName: "sql_mode no change - empty list",
   407  		setOps: []SetOp{
   408  			&SysVarReservedConn{
   409  				Name:          "sql_mode",
   410  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   411  				Expr:          "''",
   412  				SupportSetVar: true,
   413  			},
   414  		},
   415  		expectedQueryLog: []string{
   416  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   417  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, '' new {} false false`,
   418  		},
   419  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   420  			"|",
   421  		)},
   422  	}, {
   423  		testName:     "sql_mode change - empty orig - MySQL57",
   424  		mysqlVersion: "50709",
   425  		setOps: []SetOp{
   426  			&SysVarReservedConn{
   427  				Name:          "sql_mode",
   428  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   429  				Expr:          "'a'",
   430  				SupportSetVar: true,
   431  			},
   432  		},
   433  		expectedQueryLog: []string{
   434  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   435  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'a' new {} false false`,
   436  			"SysVar set with (sql_mode,'a')",
   437  			"Needs Reserved Conn",
   438  		},
   439  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   440  			"|a",
   441  		)},
   442  	}, {
   443  		testName: "sql_mode change - empty new",
   444  		setOps: []SetOp{
   445  			&SysVarReservedConn{
   446  				Name:          "sql_mode",
   447  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   448  				Expr:          "''",
   449  				SupportSetVar: true,
   450  			},
   451  		},
   452  		expectedQueryLog: []string{
   453  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   454  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, '' new {} false false`,
   455  			"SysVar set with (sql_mode,'')",
   456  			"Needs Reserved Conn",
   457  		},
   458  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   459  			"a|",
   460  		)},
   461  	}, {
   462  		testName:     "sql_mode change - empty orig - MySQL80",
   463  		mysqlVersion: "80000",
   464  		setOps: []SetOp{
   465  			&SysVarReservedConn{
   466  				Name:          "sql_mode",
   467  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   468  				Expr:          "'a'",
   469  				SupportSetVar: true,
   470  			},
   471  		},
   472  		expectedQueryLog: []string{
   473  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   474  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'a' new {} false false`,
   475  			"SysVar set with (sql_mode,'a')",
   476  			"SET_VAR can be used",
   477  		},
   478  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   479  			"|a",
   480  		)},
   481  	}, {
   482  		testName:     "sql_mode change to empty - non empty orig - MySQL80 - should use reserved conn",
   483  		mysqlVersion: "80000",
   484  		setOps: []SetOp{
   485  			&SysVarReservedConn{
   486  				Name:          "sql_mode",
   487  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   488  				Expr:          "''",
   489  				SupportSetVar: true,
   490  			},
   491  		},
   492  		expectedQueryLog: []string{
   493  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   494  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, '' new {} false false`,
   495  			"SysVar set with (sql_mode,'')",
   496  			"Needs Reserved Conn",
   497  		},
   498  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   499  			"a|",
   500  		)},
   501  	}, {
   502  		testName:     "sql_mode change - empty orig - MySQL80 - SET_VAR disabled",
   503  		mysqlVersion: "80000",
   504  		setOps: []SetOp{
   505  			&SysVarReservedConn{
   506  				Name:          "sql_mode",
   507  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   508  				Expr:          "'a'",
   509  				SupportSetVar: true,
   510  			},
   511  		},
   512  		expectedQueryLog: []string{
   513  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   514  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'a' new {} false false`,
   515  			"SysVar set with (sql_mode,'a')",
   516  			"Needs Reserved Conn",
   517  		},
   518  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   519  			"|a",
   520  		)},
   521  		disableSetVar: true,
   522  	}, {
   523  		testName:     "sql_mode set an unsupported mode",
   524  		mysqlVersion: "80000",
   525  		setOps: []SetOp{
   526  			&SysVarReservedConn{
   527  				Name:          "sql_mode",
   528  				Keyspace:      &vindexes.Keyspace{Name: "ks", Sharded: true},
   529  				Expr:          "'REAL_AS_FLOAT'",
   530  				SupportSetVar: true,
   531  			},
   532  		},
   533  		expectedQueryLog: []string{
   534  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   535  			`ExecuteMultiShard ks.-20: select @@sql_mode orig, 'REAL_AS_FLOAT' new {} false false`,
   536  		},
   537  		expectedError: "setting the REAL_AS_FLOAT sql_mode is unsupported",
   538  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("orig|new", "varchar|varchar"),
   539  			"|REAL_AS_FLOAT",
   540  		)},
   541  		disableSetVar: true,
   542  	}, {
   543  		testName:     "default_week_format change - empty orig - MySQL80",
   544  		mysqlVersion: "80000",
   545  		setOps: []SetOp{
   546  			&SysVarReservedConn{
   547  				Name:     "default_week_format",
   548  				Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true},
   549  				Expr:     "'a'",
   550  			},
   551  		},
   552  		expectedQueryLog: []string{
   553  			`ResolveDestinations ks [] Destinations:DestinationKeyspaceID(00)`,
   554  			`ExecuteMultiShard ks.-20: select 'a' from dual where @@default_week_format != 'a' {} false false`,
   555  			"SysVar set with (default_week_format,'a')",
   556  			"Needs Reserved Conn",
   557  		},
   558  		qr: []*sqltypes.Result{sqltypes.MakeTestResult(sqltypes.MakeTestFields("new", "varchar"),
   559  			"a",
   560  		)},
   561  	}}
   562  
   563  	for _, tc := range tests {
   564  		t.Run(tc.testName, func(t *testing.T) {
   565  			if tc.input == nil {
   566  				tc.input = &SingleRow{}
   567  			}
   568  
   569  			oldMySQLVersion := sqlparser.GetParserVersion()
   570  			defer func() { sqlparser.SetParserVersion(oldMySQLVersion) }()
   571  			if tc.mysqlVersion != "" {
   572  				sqlparser.SetParserVersion(tc.mysqlVersion)
   573  			}
   574  
   575  			set := &Set{
   576  				Ops:   tc.setOps,
   577  				Input: tc.input,
   578  			}
   579  			vc := &loggingVCursor{
   580  				shards:         []string{"-20", "20-"},
   581  				results:        tc.qr,
   582  				multiShardErrs: []error{tc.execErr},
   583  				disableSetVar:  tc.disableSetVar,
   584  			}
   585  			_, err := set.TryExecute(context.Background(), vc, map[string]*querypb.BindVariable{}, false)
   586  			if tc.expectedError == "" {
   587  				require.NoError(t, err)
   588  			} else {
   589  				require.EqualError(t, err, tc.expectedError)
   590  			}
   591  
   592  			vc.ExpectLog(t, tc.expectedQueryLog)
   593  			vc.ExpectWarnings(t, tc.expectedWarning)
   594  		})
   595  	}
   596  }
   597  
   598  func TestSysVarSetErr(t *testing.T) {
   599  	setOps := []SetOp{
   600  		&SysVarReservedConn{
   601  			Name: "x",
   602  			Keyspace: &vindexes.Keyspace{
   603  				Name:    "ks",
   604  				Sharded: true,
   605  			},
   606  			TargetDestination: key.DestinationAnyShard{},
   607  			Expr:              "dummy_expr",
   608  		},
   609  	}
   610  
   611  	expectedQueryLog := []string{
   612  		`ResolveDestinations ks [] Destinations:DestinationAnyShard()`,
   613  		"Needs Reserved Conn",
   614  		`ExecuteMultiShard ks.-20: set @@x = dummy_expr {} false false`,
   615  	}
   616  
   617  	set := &Set{
   618  		Ops:   setOps,
   619  		Input: &SingleRow{},
   620  	}
   621  	vc := &loggingVCursor{
   622  		shards:         []string{"-20", "20-"},
   623  		multiShardErrs: []error{fmt.Errorf("error")},
   624  	}
   625  	_, err := set.TryExecute(context.Background(), vc, map[string]*querypb.BindVariable{}, false)
   626  	require.EqualError(t, err, "error")
   627  	vc.ExpectLog(t, expectedQueryLog)
   628  }