Fix enum 0 value validation to respect STRICT_TRANS_TABLES mode

Previously, enum columns would always reject 0 values and other invalid
values with ErrConvertingToEnum, regardless of SQL mode. This change
implements proper MySQL-compatible behavior:

- In STRICT_TRANS_TABLES mode: Invalid enum values (including 0) return
  ErrDataTruncatedForColumn error
- In non-strict mode: Invalid enum values are converted to empty string
  (index 0)
- INSERT IGNORE: Now properly handles ErrDataTruncatedForColumn as an
  ignorable error, converting invalid values to empty string with warnings

Changes made:
- Modified EnumType.Convert() to check SQL mode and handle invalid values
  accordingly
- Added special handling for integer 0 in strict mode
- Ensured uint16(0) is always allowed as internal enum storage value
- Added ErrDataTruncatedForColumn to IgnorableErrors list for INSERT IGNORE
- Updated unit tests to reflect correct MySQL-compatible behavior
- Added integration tests for enum zero validation in both strict and
  non-strict modes

Fixes dolthub/dolt#9425

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

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

Author: elianddb

enginetest/queries/insert_queries.go

@@ -2836,7 +2836,7 @@ var InsertIgnoreScripts = []ScriptTest{
 		Assertions: []ScriptTestAssertion{
 			{
 				Query:       "insert into test_table values (1, 'invalid'), (2, 'comparative politics'), (3, null)",
-				ExpectedErr: types.ErrConvertingToEnum, // TODO: should be ErrDataTruncatedForColumn
+				ExpectedErr: types.ErrDataTruncatedForColumn,
 			},
 			{
 				Query:    "insert ignore into test_table values (1, 'invalid'), (2, 'bye'), (3, null)",
@@ -2849,6 +2849,43 @@ var InsertIgnoreScripts = []ScriptTest{
 			},
 		},
 	},
+	{
+		// https://github.com/dolthub/dolt/issues/9425
+		Name: "issue 9425: 0 value is not allowed for enum in strict mode",
+		SetUpScript: []string{
+			"create table enum_zero_test (id int auto_increment primary key, enum_col enum('apple','banana','cherry'))",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query:    "select @@sql_mode",
+				Expected: []sql.Row{{"NO_ENGINE_SUBSTITUTION,ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES"}},
+			},
+			{
+				Query:       "insert into enum_zero_test (enum_col) values (0)",
+				ExpectedErr: types.ErrDataTruncatedForColumn,
+			},
+			{
+				Query:       "insert into enum_zero_test (enum_col) values ('invalid')",
+				ExpectedErr: types.ErrDataTruncatedForColumn,
+			},
+			{
+				Query:    "set sql_mode = ''",
+				Expected: []sql.Row{{}},
+			},
+			{
+				Query:    "insert into enum_zero_test (enum_col) values (0)",
+				Expected: []sql.Row{{types.OkResult{RowsAffected: 1, InsertID: 1}}},
+			},
+			{
+				Query:    "insert into enum_zero_test (enum_col) values ('invalid')",
+				Expected: []sql.Row{{types.OkResult{RowsAffected: 1, InsertID: 2}}},
+			},
+			{
+				Query:    "select * from enum_zero_test",
+				Expected: []sql.Row{{1, ""}, {2, ""}},
+			},
+		},
+	},
 }
 
 var IgnoreWithDuplicateUniqueKeyKeylessScripts = []ScriptTest{

sql/plan/insert.go

@@ -22,6 +22,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/transform"
+	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
 // ErrInsertIntoNotSupported is thrown when a table doesn't support inserts
@@ -54,6 +55,7 @@ var IgnorableErrors = []*errors.Kind{sql.ErrInsertIntoNonNullableProvidedNull,
 	sql.ErrDuplicateEntry,
 	sql.ErrUniqueKeyViolation,
 	sql.ErrCheckConstraintViolated,
+	types.ErrDataTruncatedForColumn,
 }
 
 // InsertInto is the top level node for INSERT INTO statements. It has a source for rows and a destination to insert

sql/types/enum.go

@@ -165,6 +165,15 @@ func (t EnumType) Convert(ctx context.Context, v interface{}) (interface{}, sql.
 	switch value := v.(type) {
 	case int:
 		if _, ok := t.At(value); ok {
+			// Special handling for index 0 in strict mode
+			if value == 0 {
+				if sqlCtx, ok := ctx.(*sql.Context); ok {
+					sqlMode := sql.LoadSqlMode(sqlCtx)
+					if sqlMode.ModeEnabled(sql.StrictTransTables) {
+						return nil, sql.OutOfRange, ErrDataTruncatedForColumn.New("")
+					}
+				}
+			}
 			return uint16(value), sql.InRange, nil
 		}
 	case uint:
@@ -176,6 +185,10 @@ func (t EnumType) Convert(ctx context.Context, v interface{}) (interface{}, sql.
 	case int16:
 		return t.Convert(ctx, int(value))
 	case uint16:
+		// uint16(0) is always allowed as it represents the enum empty value used by INSERT IGNORE
+		if value == 0 {
+			return uint16(0), sql.InRange, nil
+		}
 		return t.Convert(ctx, int(value))
 	case int32:
 		return t.Convert(ctx, int(value))
@@ -204,6 +217,19 @@ func (t EnumType) Convert(ctx context.Context, v interface{}) (interface{}, sql.
 		return t.Convert(ctx, string(value))
 	}
 
+	// Check if we're in strict mode and handle invalid enum values appropriately
+	// But only for cases where we might want to return the empty value (0)
+	// For other invalid values, always return an error
+	if sqlCtx, ok := ctx.(*sql.Context); ok {
+		sqlMode := sql.LoadSqlMode(sqlCtx)
+		if sqlMode.ModeEnabled(sql.StrictTransTables) {
+			return nil, sql.OutOfRange, ErrDataTruncatedForColumn.New("")
+		}
+		// In non-strict mode, return empty string (index 0) for invalid enum values
+		return uint16(0), sql.InRange, nil
+	}
+	
+	// If we can't determine SQL mode (e.g., test contexts), use the original error
 	return nil, sql.InRange, ErrConvertingToEnum.New(v)
 }
 

sql/types/enum_test.go

@@ -138,9 +138,10 @@ func TestEnumConvert(t *testing.T) {
 		{[]string{"0", "1", "2"}, sql.Collation_Default, "3", "2", false},
 		{[]string{"0", "1", "2"}, sql.Collation_Default, "2", "2", false},
 
-		{[]string{"one", "two"}, sql.Collation_Default, 3, nil, true},
-		{[]string{"one", "two"}, sql.Collation_Default, "three", nil, true},
-		{[]string{"one", "two"}, sql.Collation_Default, time.Date(2019, 12, 12, 12, 12, 12, 0, time.UTC), nil, true},
+		// In non-strict mode (empty context), invalid enum values are converted to empty value (index 0)
+		{[]string{"one", "two"}, sql.Collation_Default, 3, "", false},
+		{[]string{"one", "two"}, sql.Collation_Default, "three", "", false},
+		{[]string{"one", "two"}, sql.Collation_Default, time.Date(2019, 12, 12, 12, 12, 12, 0, time.UTC), "", false},
 	}
 
 	for _, test := range tests {