Fix SET type casting to CHAR and BINARY

This commit fixes an issue where SET types were not properly converted
to their string representation when casting to CHAR or BINARY types.

The problem was that SET types use internal uint64 values to represent
bit fields, but when casting to CHAR or BINARY, the string representation
of the SET should be used instead.

Changes:
- Added special handling in convertValue() for SET types in both CHAR and BINARY conversion cases
- Convert SET uint64 bit field to string representation before passing to LongText/LongBlob converters
- Removed Skip flags from previously failing tests in script_queries.go
- Updated test expectations to include all SET values (including "defg")

Fixes dolthub/dolt#9511

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: elianddb

enginetest/queries/script_queries.go

@@ -9911,21 +9911,19 @@ 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"},
+					{"defg", "defg"},
 					{"abc,defg", "abc,defg"},
 					{"abc,defg,hijkl", "abc,defg,hijkl"},
 				},
 			},
 			{
-				// 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")},
+					{"defg", []uint8("defg")},
 					{"abc,defg", []uint8("abc,defg")},
 					{"abc,defg,hijkl", []uint8("abc,defg,hijkl")},
 				},

sql/expression/convert.go

@@ -278,17 +278,27 @@ func (c *Convert) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	return casted, nil
 }
 
-// convertValue only returns an error if converting to JSON, Date, and Datetime;
-// the zero value is returned for float types. Nil is returned in all other cases.
-// If |typeLength| and |typeScale| are 0, they are ignored, otherwise they are used as constraints on the
-// converted type where applicable (e.g. Char conversion supports only |typeLength|, Decimal conversion supports
-// |typeLength| and |typeScale|).
+// convertValue converts a value from its current type to the specified target type for CAST/CONVERT operations.
+// It handles type-specific conversion logic and applies length/scale constraints where applicable.
+//
+// Parameters:
+//   - val: the value to convert
+//   - castTo: target type name (e.g., "char", "binary", "decimal", "json")
+//   - originType: the original SQL type of the value (used for type-specific conversion logic)
+//   - typeLength: optional length constraint for the target type (0 if not specified)
+//   - typeScale: optional scale constraint for decimal types (0 if not specified)
+//
+// Special handling:
+//   - SET types: converts uint64 bit field values to their string representation for CHAR/BINARY targets
+//   - BLOB types: converts hex values to decimals for numeric targets
+//   - Only returns errors for JSON, Date, and Datetime conversions; returns zero/nil for other failed conversions
 func convertValue(ctx *sql.Context, val interface{}, castTo string, originType sql.Type, typeLength, typeScale int) (interface{}, error) {
 	if val == nil {
 		return nil, nil
 	}
 	switch strings.ToLower(castTo) {
 	case ConvertToBinary:
+		val = convertSetToStringForStringContext(val, originType)
 		b, _, err := types.LongBlob.Convert(ctx, val)
 		if err != nil {
 			return nil, nil
@@ -307,6 +317,7 @@ func convertValue(ctx *sql.Context, val interface{}, castTo string, originType s
 		}
 		return truncateConvertedValue(b, typeLength)
 	case ConvertToChar, ConvertToNChar:
+		val = convertSetToStringForStringContext(val, originType)
 		s, _, err := types.LongText.Convert(ctx, val)
 		if err != nil {
 			return nil, nil
@@ -468,6 +479,20 @@ func createConvertedDecimalType(length, scale int, logErrors bool) sql.DecimalTy
 	return types.InternalDecimalType
 }
 
+// convertSetToStringForStringContext converts SET type bit field values to their string representation
+// when converting to string-based types (CHAR, BINARY, etc.). This ensures that SET types are properly
+// represented as their comma-separated string values rather than their internal uint64 bit field values.
+func convertSetToStringForStringContext(val interface{}, originType sql.Type) interface{} {
+	if setType, ok := originType.(sql.SetType); ok {
+		if bitField, ok := val.(uint64); ok {
+			if stringVal, err := setType.BitsToString(bitField); err == nil {
+				return stringVal
+			}
+		}
+	}
+	return val
+}
+
 // convertHexBlobToDecimalForNumericContext converts byte array value to unsigned int value if originType is BLOB type.
 // This function is called when convertTo type is number type only. The hex literal values are parsed into blobs as
 // binary string as default, but for numeric context, the value should be a number.