aaaaa

Author: James Cor

enginetest/memory_engine_test.go

@@ -200,18 +200,19 @@ func TestSingleQueryPrepared(t *testing.T) {
 
 // Convenience test for debugging a single query. Unskip and set to the desired query.
 func TestSingleScript(t *testing.T) {
-	//t.Skip()
+	t.Skip()
 	var scripts = []queries.ScriptTest{
 		{
-			Name: "asdfasdfasdf",
+			Name: "sets",
 			SetUpScript: []string{
-				"create table parent (e enum('a', 'b', 'c') primary key);",
-				"insert into parent values (1), (2);",
-				"create table child1 (e enum('x', 'y', 'z'), foreign key (e) references parent (e));",
+				`CREATE TABLE test (pk SET("a","b","c") PRIMARY KEY, v1 SET("w","x","y","z"));`,
+				`INSERT INTO test VALUES (0, 1), ("b", "y"), ("b,c", "z,z"), ("a,c,b", 10);`,
+				`UPDATE test SET v1 = "y,x,w" WHERE pk >= 4`,
+				`DELETE FROM test WHERE pk > "b,c";`,
 			},
 			Assertions: []queries.ScriptTestAssertion{
 				{
-					Query: "insert into child1 values (1), (2);",
+					Query: `SELECT * FROM test ORDER BY pk;`,
 					Expected: []sql.Row{
 						{types.NewOkResult(2)},
 					},
@@ -242,7 +243,7 @@ func TestSingleScript(t *testing.T) {
 
 	for _, test := range scripts {
 		harness := enginetest.NewMemoryHarness("", 1, testNumPartitions, true, nil)
-		//harness.UseServer()
+		harness.UseServer()
 		engine, err := harness.NewEngine(t)
 		if err != nil {
 			panic(err)

sql/expression/comparison.go

@@ -303,6 +303,32 @@ func (c *comparison) CastLeftAndRight(ctx *sql.Context, left, right interface{})
 
 	lType := c.Left().Type()
 	rType := c.Right().Type()
+
+	//lIsEnumOrSet := types.IsEnum(lType) || types.IsSet(lType)
+	//rIsEnumOrSet := types.IsEnum(rType) || types.IsSet(rType)
+	//// If right side is convertible to enum/set, convert. Otherwise, convert left side
+	//if lIsEnumOrSet && (types.IsText(rType) || types.IsNumber(rType)) {
+	//	if r, inRange, err := lType.Convert(ctx, right); inRange && err == nil {
+	//		return left, r, lType, nil
+	//	}
+	//	l, _, err := types.TypeAwareConversion(ctx, left, lType, rType, false)
+	//	if err != nil {
+	//		return nil, nil, nil, err
+	//	}
+	//	return l, right, rType, nil
+	//}
+	//// If left side is convertible to enum/set, convert. Otherwise, convert right side
+	//if rIsEnumOrSet && (types.IsText(lType) || types.IsNumber(lType)) {
+	//	if l, inRange, err := rType.Convert(ctx, left); inRange && err == nil {
+	//		return l, right, rType, nil
+	//	}
+	//	r, _, err := types.TypeAwareConversion(ctx, right, rType, lType, false)
+	//	if err != nil {
+	//		return nil, nil, nil, err
+	//	}
+	//	return left, r, lType, nil
+	//}
+
 	compType := types.GetCompareType(lType, rType)
 
 	// Special case for JSON types

sql/types/utils.go

@@ -16,6 +16,7 @@ package types
 
 import (
 	"github.com/dolthub/go-mysql-server/sql"
+
 )
 
 // GetCompareType returns the type to use when comparing values of types left and right.
@@ -24,6 +25,15 @@ func GetCompareType(left, right sql.Type) sql.Type {
 		return left
 	}
 
+	// Left and right are both Enum types, but not the same, so use uint16 representation for comparison
+	if IsEnum(left) && IsEnum(right) {
+		return Uint16
+	}
+	// Left and right are both Set types, but not the same, so use uint16 representation for comparison
+	if IsSet(left) && IsSet(right) {
+		return Uint16
+	}
+
 	if IsTimespan(left) || IsTimespan(right) {
 		return left
 	}