Clean up mixed string foreign key logic

Refactor foreignKeyComparableTypes function to improve readability:
- Inline compatibleStringTypes function for locality of behavior
- Compress logic while preserving legacy structure
- Combine duplicate charset validation logic
- Maintain important comments explaining MySQL behavior

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

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

Author: elianddb

sql/plan/alter_foreign_key.go

@@ -644,71 +644,47 @@ func FindFKIndexWithPrefix(ctx *sql.Context, tbl sql.IndexAddressableTable, pref
 // foreignKeyComparableTypes returns whether the two given types are able to be used as parent/child columns in a
 // foreign key.
 func foreignKeyComparableTypes(ctx *sql.Context, type1 sql.Type, type2 sql.Type) bool {
-	if !type1.Equals(type2) {
-		// There seems to be a special case where CHAR/VARCHAR/BINARY/VARBINARY can have unequal lengths.
-		// Have not tested every type nor combination, but this seems specific to those 4 types.
-		if type1.Type() == type2.Type() {
-			switch type1.Type() {
-			case sqltypes.Char, sqltypes.VarChar, sqltypes.Binary, sqltypes.VarBinary:
-				type1String := type1.(sql.StringType)
-				type2String := type2.(sql.StringType)
-				if type1String.Collation().CharacterSet() != type2String.Collation().CharacterSet() {
-					return false
-				}
-			case sqltypes.Enum:
-				// Enum types can reference each other in foreign keys regardless of their string values.
-				// MySQL allows enum foreign keys to match based on underlying numeric values.
-				return true
-			case sqltypes.Decimal:
-				// MySQL allows decimal foreign keys with different precision/scale
-				// The foreign key constraint validation will handle the actual value comparison
-				return true
-			default:
-				return false
-			}
-		} else {
-			// MySQL allows mixed string types in foreign key constraints:
-			// - CHAR can reference VARCHAR and vice versa
-			// - BINARY can reference VARBINARY and vice versa
-			if compatibleStringTypes(type1, type2) {
-				type1String := type1.(sql.StringType)
-				type2String := type2.(sql.StringType)
-				if type1String.Collation().CharacterSet() != type2String.Collation().CharacterSet() {
-					return false
-				}
-			} else {
-				return false
-			}
-		}
+	if type1.Equals(type2) {
+		return true
 	}
-	return true
-}
 
-// compatibleStringTypes checks if two different string types are compatible for foreign key constraints.
-// MySQL allows mixed string types within the same category:
-// - Character types: CHAR and VARCHAR
-// - Binary types: BINARY and VARBINARY
-func compatibleStringTypes(type1 sql.Type, type2 sql.Type) bool {
-	if type1 == nil || type2 == nil {
-		return false
-	}
-	
 	t1 := type1.Type()
 	t2 := type2.Type()
-	
-	// Check if both are character string types (CHAR/VARCHAR)
-	if (t1 == sqltypes.Char || t1 == sqltypes.VarChar) && (t2 == sqltypes.Char || t2 == sqltypes.VarChar) {
-		return true
+
+	// Same type with different parameters
+	if t1 == t2 {
+		switch t1 {
+		case sqltypes.Char, sqltypes.VarChar, sqltypes.Binary, sqltypes.VarBinary:
+			// There seems to be a special case where CHAR/VARCHAR/BINARY/VARBINARY can have unequal lengths.
+			// Have not tested every type nor combination, but this seems specific to those 4 types.
+			type1String := type1.(sql.StringType)
+			type2String := type2.(sql.StringType)
+			return type1String.Collation().CharacterSet() == type2String.Collation().CharacterSet()
+		case sqltypes.Enum:
+			// Enum types can reference each other in foreign keys regardless of their string values.
+			// MySQL allows enum foreign keys to match based on underlying numeric values.
+			return true
+		case sqltypes.Decimal:
+			// MySQL allows decimal foreign keys with different precision/scale
+			// The foreign key constraint validation will handle the actual value comparison
+			return true
+		default:
+			return false
+		}
 	}
-	
-	// Check if both are binary string types (BINARY/VARBINARY)
-	if (t1 == sqltypes.Binary || t1 == sqltypes.VarBinary) && (t2 == sqltypes.Binary || t2 == sqltypes.VarBinary) {
-		return true
+
+	// Mixed string types: CHAR/VARCHAR or BINARY/VARBINARY
+	if ((t1 == sqltypes.Char || t1 == sqltypes.VarChar) && (t2 == sqltypes.Char || t2 == sqltypes.VarChar)) ||
+		((t1 == sqltypes.Binary || t1 == sqltypes.VarBinary) && (t2 == sqltypes.Binary || t2 == sqltypes.VarBinary)) {
+		type1String := type1.(sql.StringType)
+		type2String := type2.(sql.StringType)
+		return type1String.Collation().CharacterSet() == type2String.Collation().CharacterSet()
 	}
-	
+
 	return false
 }
 
+
 // exprsAreIndexPrefix returns whether the given expressions are a prefix of the given index expressions
 func exprsAreIndexPrefix(exprs, indexExprs []string) bool {
 	if len(exprs) > len(indexExprs) {