Merge pull request #3095 from dolthub/angela/setconversion

Convert SetType to strings

Author: angelamayxie

enginetest/queries/script_queries.go

@@ -9280,7 +9280,6 @@ where
 			},
 			{
 				// https://github.com/dolthub/dolt/issues/8598
-				Skip:  true,
 				Query: "select (case e when 'abc' then e when 'defg' then e when 'hijkl' then 'something' end) as e from t order by e;",
 				Expected: []sql.Row{
 					{"abc"},
@@ -9290,12 +9289,11 @@ where
 			},
 			{
 				// https://github.com/dolthub/dolt/issues/8598
-				Skip:  true,
 				Query: "select (case e when 'abc' then e when 'defg' then e when 'hijkl' then 123 end) as e from t order by e;",
 				Expected: []sql.Row{
 					{"123"},
 					{"abc"},
-					{"def"},
+					{"defg"},
 				},
 			},
 			{
@@ -9778,15 +9776,14 @@ where
 				Skip:  true,
 				Query: "select i, s + 0, s from tt;",
 				Expected: []sql.Row{
-					{0, float64(0), "something,"},
-					{1, float64(1), "something,"},
+					{0, float64(3), "something,"},
+					{1, float64(3), "something,"},
 					{2, float64(2), ""},
 				},
 			},
 		},
 	},
 	{
-		Skip:    true,
 		Name:    "set conversion to strings",
 		Dialect: "mysql",
 		SetUpScript: []string{
@@ -9822,6 +9819,8 @@ where
 				},
 			},
 			{
+				// https://github.com/dolthub/dolt/issues/9510
+				Skip:  true,
 				Query: "select s from t where s like 'a%' order by s;",
 				Expected: []sql.Row{
 					{"abc"},
@@ -9911,6 +9910,8 @@ where
 				},
 			},
 			{
+				// https://github.com/dolthub/dolt/issues/9511
+				Skip:  true,
 				Query: "select s, cast(s as char) from t order by s;",
 				Expected: []sql.Row{
 					{"abc", "abc"},
@@ -9919,6 +9920,8 @@ where
 				},
 			},
 			{
+				// https://github.com/dolthub/dolt/issues/9511
+				Skip:  true,
 				Query: "select s, cast(s as binary) from t order by s;",
 				Expected: []sql.Row{
 					{"abc", []uint8("abc")},

sql/expression/case.go

@@ -136,7 +136,7 @@ func (c *Case) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 			}
 			// When unable to convert to the type of the case, return the original value
 			// A common error here is "Out of bounds value for decimal type"
-			if ret, _, err := t.Convert(ctx, bval); err == nil {
+			if ret, err := types.TypeAwareConversion(ctx, bval, b.Value.Type(), t); err == nil {
 				return ret, nil
 			}
 			return bval, nil
@@ -150,7 +150,7 @@ func (c *Case) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		}
 		// When unable to convert to the type of the case, return the original value
 		// A common error here is "Out of bounds value for decimal type"
-		if ret, _, err := t.Convert(ctx, val); err == nil {
+		if ret, err := types.TypeAwareConversion(ctx, val, c.Else.Type(), t); err == nil {
 			return ret, nil
 		}
 		return val, nil

sql/types/conversion.go

@@ -734,3 +734,23 @@ func GeneralizeTypes(a, b sql.Type) sql.Type {
 	// TODO: decide if we want to make this VarChar to match MySQL, match VarChar length to max of two types
 	return LongText
 }
+
+// TypeAwareConversion converts a value to a specified type, with awareness of the value's original type. This is
+// necessary because some types, such as EnumType and SetType, are stored as ints and require information from the
+// original type to properly convert to strings.
+func TypeAwareConversion(ctx *sql.Context, val interface{}, originalType sql.Type, convertedType sql.Type) (interface{}, error) {
+	if val == nil {
+		return nil, nil
+	}
+	var converted interface{}
+	var err error
+	if IsTextOnly(convertedType) {
+		converted, _, err = ConvertToCollatedString(ctx, val, originalType)
+	} else {
+		converted, _, err = convertedType.Convert(ctx, val)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return converted, nil
+}

sql/types/strings.go

@@ -610,7 +610,7 @@ func convertToLongTextString(ctx context.Context, val interface{}) (string, erro
 }
 
 // convertEnumToString converts an enum value to its string representation
-func convertEnumToString(ctx context.Context, val interface{}, enumType sql.EnumType) (string, error) {
+func convertEnumToString(ctx context.Context, val interface{}, enumType EnumType) (string, error) {
 	if enumVal, ok := val.(uint16); ok {
 		if enumStr, exists := enumType.At(int(enumVal)); exists {
 			return enumStr, nil
@@ -620,6 +620,14 @@ func convertEnumToString(ctx context.Context, val interface{}, enumType sql.Enum
 	return convertToLongTextString(ctx, val)
 }
 
+// convertSetToString converts a set value to its string representation
+func convertSetToString(ctx context.Context, val interface{}, setType SetType) (string, error) {
+	if setVal, ok := val.(uint64); ok {
+		return setType.BitsToString(setVal)
+	}
+	return convertToLongTextString(ctx, val)
+}
+
 // ConvertToCollatedString returns the given interface as a string, along with its collation. If the Type possess a
 // collation, then that collation is returned. If the Type does not possess a collation (such as an integer), then the
 // value is converted to a string and the default collation is used. If the value is already a string then no additional
@@ -640,28 +648,27 @@ func ConvertToCollatedString(ctx context.Context, val interface{}, typ sql.Type)
 			content = strVal
 		} else if byteVal, ok := val.([]byte); ok {
 			content = encodings.BytesToString(byteVal)
-		} else if enumType, ok := typ.(sql.EnumType); ok {
-			// Handle enum types in string context - return the string value, not the index
-			content, err = convertEnumToString(ctx, val, enumType)
-			if err != nil {
-				return "", sql.Collation_Unspecified, err
-			}
 		} else {
-			content, err = convertToLongTextString(ctx, val)
-			if err != nil {
-				return "", sql.Collation_Unspecified, err
+			switch typ := typ.(type) {
+			case EnumType:
+				content, err = convertEnumToString(ctx, val, typ)
+				if err != nil {
+					return "", sql.Collation_Unspecified, err
+				}
+			case SetType:
+				content, err = convertSetToString(ctx, val, typ)
+				if err != nil {
+					return "", sql.Collation_Unspecified, err
+				}
+			default:
+				content, err = convertToLongTextString(ctx, val)
+				if err != nil {
+					return "", sql.Collation_Unspecified, err
+				}
 			}
 		}
 	} else {
 		collation = sql.Collation_Default
-		// Handle enum types in string context even without collation
-		if enumType, ok := typ.(sql.EnumType); ok {
-			content, err = convertEnumToString(ctx, val, enumType)
-			if err != nil {
-				return "", sql.Collation_Unspecified, err
-			}
-			return content, collation, nil
-		}
 		content, err = convertToLongTextString(ctx, val)
 		if err != nil {
 			return "", sql.Collation_Unspecified, err