dolthub/dolt#9426 - Expand enum string context support

Added support for LIKE pattern matching and GROUP_CONCAT aggregation with enum values.
Enhanced enum conversion to strings test with comprehensive coverage.

Changes:
- Fixed LIKE expression to use ConvertToCollatedString for enum types
- Fixed GROUP_CONCAT aggregation to use type-aware string conversion
- Added comprehensive test cases for pattern matching and aggregation

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

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

Author: elianddb

enginetest/queries/script_queries.go

@@ -9094,7 +9094,6 @@ where
 		},
 		Assertions: []ScriptTestAssertion{
 			{
-				// We incorrectly use the numeric values of the enum, resulting in length of 1
 				Query: "select e, length(e) from t order by e;",
 				Expected: []sql.Row{
 					{"abc", 3},
@@ -9103,14 +9102,39 @@ where
 				},
 			},
 			{
-				// We incorrectly use the numeric values of the enum, resulting in length of 1
 				Query: "select e, concat(e, 'test') from t order by e;",
 				Expected: []sql.Row{
 					{"abc", "abctest"},
 					{"defg", "defgtest"},
 					{"hjikl", "hjikltest"},
 				},
 			},
+			{
+				Query: "select e, e like 'a%', e like '%g' from t order by e;",
+				Expected: []sql.Row{
+					{"abc", true, false},
+					{"defg", false, true},
+					{"hjikl", false, false},
+				},
+			},
+			{
+				Query: "select group_concat(e order by e) as grouped from t;",
+				Expected: []sql.Row{
+					{"abc,defg,hjikl"},
+				},
+			},
+			{
+				Query: "select e from t where e = 'abc';",
+				Expected: []sql.Row{
+					{"abc"},
+				},
+			},
+			{
+				Query: "select count(*) from t where e = 'defg';",
+				Expected: []sql.Row{
+					{1},
+				},
+			},
 		},
 	},
 	{

sql/expression/function/aggregation/group_concat.go

@@ -271,16 +271,27 @@ func (g *groupConcatBuffer) Update(ctx *sql.Context, originalRow sql.Row) error
 			return nil
 		}
 	} else {
-		v, _, err = types.LongText.Convert(ctx, evalRow[0])
-		if err != nil {
-			return err
-		}
-		if v == nil {
-			return nil
-		}
-		vs, _, err = sql.Unwrap[string](ctx, v)
-		if err != nil {
-			return err
+		// Use type-aware conversion for enum types
+		if len(g.gc.selectExprs) > 0 {
+			vs, _, err = types.ConvertToCollatedString(ctx, evalRow[0], g.gc.selectExprs[0].Type())
+			if err != nil {
+				return err
+			}
+			if vs == "" {
+				return nil
+			}
+		} else {
+			v, _, err = types.LongText.Convert(ctx, evalRow[0])
+			if err != nil {
+				return err
+			}
+			if v == nil {
+				return nil
+			}
+			vs, _, err = sql.Unwrap[string](ctx, v)
+			if err != nil {
+				return err
+			}
 		}
 	}
 

sql/expression/like.go

@@ -86,10 +86,12 @@ func (l *Like) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		return nil, err
 	}
 	if _, ok := left.(string); !ok {
-		left, _, err = types.LongText.Convert(ctx, left)
+		// Use type-aware conversion for enum types
+		leftStr, _, err := types.ConvertToCollatedString(ctx, left, l.Left().Type())
 		if err != nil {
 			return nil, err
 		}
+		left = leftStr
 	}
 
 	var lm LikeMatcher
@@ -138,10 +140,12 @@ func (l *Like) evalRight(ctx *sql.Context, row sql.Row) (right *string, escape r
 		return nil, 0, err
 	}
 	if _, ok := rightVal.(string); !ok {
-		rightVal, _, err = types.LongText.Convert(ctx, rightVal)
+		// Use type-aware conversion for enum types
+		rightStr, _, err := types.ConvertToCollatedString(ctx, rightVal, l.Right().Type())
 		if err != nil {
 			return nil, 0, err
 		}
+		rightVal = rightStr
 	}
 
 	var escapeVal interface{}