amend to existing patterns

Author: elianddb

enginetest/queries/script_queries.go

@@ -10538,7 +10538,7 @@ where
 			},
 			{
 				Query:       "insert into child_dec_4_1 values (78.9);",
-				ExpectedErr: sql.ErrForeignKeyChildViolationMySQL845,
+				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},
 
 			{
@@ -10561,7 +10561,7 @@ where
 			},
 			{
 				Query:       "insert into child_dec_65_30 values (1.23);",
-				ExpectedErr: sql.ErrForeignKeyChildViolationMySQL845,
+				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},
 			{
 				Query:       "insert into child_dec_4_2 values (99.99);",

sql/errors.go

@@ -419,8 +419,7 @@ var (
 	ErrInsertIntoNonNullableProvidedNull = errors.NewKind("column name '%v' is non-nullable but attempted to set a value of null")
 
 	// ErrForeignKeyChildViolation is called when a rows is added but there is no parent row, and a foreign key constraint fails. Add the parent row first.
-	ErrForeignKeyChildViolation         = errors.NewKind("cannot add or update a child row - Foreign key violation on fk: `%s`, table: `%s`, referenced table: `%s`, key: `%s`")
-	ErrForeignKeyChildViolationMySQL845 = errors.NewKind("cannot add or update a child row: a foreign key constraint fails (`%s`.`%s`, CONSTRAINT `%s` FOREIGN KEY (`%s`) REFERENCES `%s` (`%s`))")
+	ErrForeignKeyChildViolation = errors.NewKind("cannot add or update a child row - Foreign key violation on fk: `%s`, table: `%s`, referenced table: `%s`, key: `%s`")
 
 	// ErrForeignKeyParentViolation is called when a parent row that is deleted has children, and a foreign key constraint fails. Delete the children first.
 	ErrForeignKeyParentViolation = errors.NewKind("cannot delete or update a parent row - Foreign key violation on fk: `%s`, table: `%s`, referenced table: `%s`, key: `%s`")
@@ -982,7 +981,6 @@ func CastSQLError(err error) *mysql.SQLError {
 		code = mysql.ERDupEntry
 	case ErrPartitionNotFound.Is(err):
 		code = 1526 // TODO: Needs to be added to vitess
-	case ErrForeignKeyChildViolationMySQL845.Is(err):
 	case ErrForeignKeyChildViolation.Is(err):
 		code = mysql.ErNoReferencedRow2 // test with mysql returns 1452 vs 1216
 	case ErrForeignKeyParentViolation.Is(err):

sql/plan/foreign_key_editor.go

@@ -512,11 +512,9 @@ func (reference *ForeignKeyReferenceHandler) CheckReference(ctx *sql.Context, ro
 		return err
 	}
 	if err == nil {
-		// We have a parent row, but for DECIMAL types we need to be strict about precision/scale
-		if shouldReject := reference.validateDecimalMatch(); shouldReject {
-			return sql.ErrForeignKeyChildViolationMySQL845.New(reference.ForeignKey.Database, reference.ForeignKey.Table,
-				reference.ForeignKey.Name, strings.Join(reference.ForeignKey.Columns, ", "),
-				reference.ForeignKey.ParentTable, strings.Join(reference.ForeignKey.ParentColumns, ", "))
+		// We have a parent row, but check for type-specific validation
+		if validationErr := reference.validateDecimalConstraints(row); validationErr != nil {
+			return validationErr
 		}
 		// We have a parent row so throw no error
 		return nil
@@ -545,23 +543,34 @@ func (reference *ForeignKeyReferenceHandler) CheckReference(ctx *sql.Context, ro
 		reference.ForeignKey.ParentTable, reference.RowMapper.GetKeyString(row))
 }
 
-func (reference *ForeignKeyReferenceHandler) validateDecimalMatch() bool {
+// validateDecimalConstraints checks that decimal foreign key columns have compatible scales.
+func (reference *ForeignKeyReferenceHandler) validateDecimalConstraints(row sql.Row) error {
 	if reference.RowMapper.Index == nil {
-		return false
+		return nil
 	}
+
 	indexColumnTypes := reference.RowMapper.Index.ColumnExpressionTypes()
 	for i := range reference.ForeignKey.Columns {
 		if i >= len(indexColumnTypes) {
 			continue
 		}
+
 		childColIdx := reference.RowMapper.IndexPositions[i]
-		childDecimal, childOk := reference.RowMapper.SourceSch[childColIdx].Type.(sql.DecimalType)
-		parentDecimal, parentOk := indexColumnTypes[i].Type.(sql.DecimalType)
-		if childOk && parentOk && childDecimal.Scale() != parentDecimal.Scale() {
-			return true
+		childType := reference.RowMapper.SourceSch[childColIdx].Type
+		parentType := indexColumnTypes[i].Type
+
+		// For decimal types, check scale compatibility (following existing pattern for type-specific validation)
+		if childDecimal, ok := childType.(sql.DecimalType); ok {
+			if parentDecimal, ok := parentType.(sql.DecimalType); ok {
+				if childDecimal.Scale() != parentDecimal.Scale() {
+					return sql.ErrForeignKeyChildViolation.New(reference.ForeignKey.Name, reference.ForeignKey.Table,
+						reference.ForeignKey.ParentTable, reference.RowMapper.GetKeyString(row))
+				}
+			}
 		}
 	}
-	return false
+
+	return nil
 }
 
 // CheckTable checks that every row in the table has an index entry in the referenced table.