Merge pull request #6301 from planetscale/charset_introducer

Allow charset introducers for vindex columns

go/test/endtoend/vtgate/setstatement/main_test.go

@@ -38,22 +38,54 @@ var (
 		val2 int,
 		val3 float,
 		primary key(id)
-	)Engine=InnoDB;`
+	)Engine=InnoDB;
+
+CREATE TABLE test_vdx (
+    val1 varchar(16) NOT NULL,
+    keyspace_id binary(8),
+    UNIQUE KEY (val1)
+) ENGINE=Innodb;
+`
 
 	vSchema = `
 		{	
 			"sharded":true,
 			"vindexes": {
 				"hash_index": {
 					"type": "hash"
-				}
+				},
+				"lookup1": {
+					"type": "consistent_lookup",
+					"params": {
+						"table": "test_vdx",
+						"from": "val1",
+						"to": "keyspace_id",
+						"ignore_nulls": "true"
+					},
+					"owner": "test"
+				},
+				"unicode_vdx":{
+					"type": "unicode_loose_md5"
+                }
 			},	
 			"tables": {
 				"test":{
 					"column_vindexes": [
 						{
 							"column": "id",
 							"name": "hash_index"
+						},
+						{
+							"column": "val1",
+							"name": "lookup1"
+						}
+					]
+				},
+				"test_vdx":{
+					"column_vindexes": [
+						{
+							"column": "val1",
+							"name": "unicode_vdx"
 						}
 					]
 				}

go/test/endtoend/vtgate/setstatement/sysvar_test.go

@@ -28,6 +28,23 @@ import (
 	"vitess.io/vitess/go/test/endtoend/cluster"
 )
 
+func TestCharsetIntro(t *testing.T) {
+	defer cluster.PanicHandler(t)
+	ctx := context.Background()
+	vtParams := mysql.ConnParams{
+		Host: "localhost",
+		Port: clusterInstance.VtgateMySQLPort,
+	}
+	conn, err := mysql.Connect(ctx, &vtParams)
+	require.NoError(t, err)
+	defer conn.Close()
+
+	_, err = exec(t, conn, "delete from test")
+	require.NoError(t, err)
+	_, err = exec(t, conn, "insert into test (id,val1) values (666, _binary'abc')")
+	require.NoError(t, err)
+}
+
 func TestSetSysVar(t *testing.T) {
 	defer cluster.PanicHandler(t)
 	ctx := context.Background()

go/test/endtoend/vtgate/setstatement/udv_test.go

@@ -96,6 +96,8 @@ func TestSetUDV(t *testing.T) {
 	conn, err := mysql.Connect(ctx, &vtParams)
 	require.NoError(t, err)
 	defer conn.Close()
+	_, err = exec(t, conn, "delete from test")
+	require.NoError(t, err)
 
 	for i, q := range queries {
 		t.Run(fmt.Sprintf("%d-%s", i, q.query), func(t *testing.T) {

go/vt/sqlparser/analyzer.go

@@ -377,6 +377,11 @@ func NewPlanValue(node Expr) (sqltypes.PlanValue, error) {
 		return pv, nil
 	case *NullVal:
 		return sqltypes.PlanValue{}, nil
+	case *UnaryExpr:
+		switch node.Operator {
+		case UBinaryStr, Utf8mb4Str, Utf8Str, Latin1Str: // for some charset introducers, we can just ignore them
+			return NewPlanValue(node.Expr)
+		}
 	}
 	return sqltypes.PlanValue{}, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "expression is too complex '%v'", String(node))
 }

go/vt/sqlparser/analyzer_test.go

@@ -17,10 +17,11 @@ limitations under the License.
 package sqlparser
 
 import (
-	"reflect"
-	"strings"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+	"vitess.io/vitess/go/test/utils"
+
 	"github.com/stretchr/testify/assert"
 	"vitess.io/vitess/go/sqltypes"
 )
@@ -413,25 +414,74 @@ func TestNewPlanValue(t *testing.T) {
 			Val:  []byte("2.1"),
 		},
 		out: sqltypes.PlanValue{Value: sqltypes.NewFloat64(2.1)},
+	}, {
+		in: &UnaryExpr{
+			Operator: Latin1Str,
+			Expr: &SQLVal{
+				Type: StrVal,
+				Val:  []byte("strval"),
+			},
+		},
+		out: sqltypes.PlanValue{Value: sqltypes.NewVarBinary("strval")},
+	}, {
+		in: &UnaryExpr{
+			Operator: UBinaryStr,
+			Expr: &SQLVal{
+				Type: StrVal,
+				Val:  []byte("strval"),
+			},
+		},
+		out: sqltypes.PlanValue{Value: sqltypes.NewVarBinary("strval")},
+	}, {
+		in: &UnaryExpr{
+			Operator: Utf8mb4Str,
+			Expr: &SQLVal{
+				Type: StrVal,
+				Val:  []byte("strval"),
+			},
+		},
+		out: sqltypes.PlanValue{Value: sqltypes.NewVarBinary("strval")},
+	}, {
+		in: &UnaryExpr{
+			Operator: Utf8Str,
+			Expr: &SQLVal{
+				Type: StrVal,
+				Val:  []byte("strval"),
+			},
+		},
+		out: sqltypes.PlanValue{Value: sqltypes.NewVarBinary("strval")},
+	}, {
+		in: &UnaryExpr{
+			Operator: MinusStr,
+			Expr: &SQLVal{
+				Type: FloatVal,
+				Val:  []byte("2.1"),
+			},
+		},
+		err: "expression is too complex",
 	}}
 	for _, tc := range tcases {
-		got, err := NewPlanValue(tc.in)
-		if tc.err != "" {
-			if !strings.Contains(err.Error(), tc.err) {
-				t.Errorf("NewPlanValue(%s) error: %v, want '%s'", String(tc.in), err, tc.err)
+		t.Run(String(tc.in), func(t *testing.T) {
+			got, err := NewPlanValue(tc.in)
+			if tc.err != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tc.err)
+				return
 			}
-			continue
-		}
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		if !reflect.DeepEqual(tc.out, got) {
-			t.Errorf("NewPlanValue(%s): %v, want %v", String(tc.in), got, tc.out)
-		}
+
+			require.NoError(t, err)
+			mustMatch(t, tc.out, got, "wut!")
+		})
 	}
 }
 
+var mustMatch = utils.MustMatchFn(
+	[]interface{}{ // types with unexported fields
+		sqltypes.Value{},
+	},
+	[]string{".Conn"}, // ignored fields
+)
+
 func newStrVal(in string) *SQLVal {
 	return NewStrVal([]byte(in))
 }

go/vt/sqlparser/constants.go

@@ -136,6 +136,8 @@ const (
 	BinaryStr  = "binary "
 	UBinaryStr = "_binary "
 	Utf8mb4Str = "_utf8mb4 "
+	Utf8Str    = "_utf8 "
+	Latin1Str  = "_latin1 "
 
 	// this string is "character set" and this comment is required
 	CharacterSetStr = " character set"

go/vt/sqlparser/parse_test.go

@@ -1501,6 +1501,8 @@ var (
 		input: "select binary 'a' = 'A' from t",
 	}, {
 		input: "select 1 from t where foo = _binary 'bar'",
+	}, {
+		input: "select 1 from t where foo = _utf8 'bar' and bar = _latin1 'sjösjuk'",
 	}, {
 		input:  "select 1 from t where foo = _binary'bar'",
 		output: "select 1 from t where foo = _binary 'bar'",