Bug fixes for two issues: swapped parent / child table names, and incorrect index type in some cases

Author: zachmu

sql/analyzer/apply_foreign_keys.go

@@ -274,7 +274,7 @@ func getForeignKeyReferences(ctx *sql.Context, a *Analyzer, tbl sql.ForeignKeyTa
 			return nil, err
 		}
 
-		typeTransforms, err := plan.GetChildParentTypeTransforms(tblSch, parentTbl.Schema(), fk)
+		typeTransforms, err := plan.GetChildParentTypeTransforms(parentTbl.Schema(), tblSch, fk)
 		if err != nil {
 			return nil, err
 		}

sql/plan/alter_foreign_key.go

@@ -200,7 +200,7 @@ func ResolveForeignKey(ctx *sql.Context, tbl sql.ForeignKeyTable, refTbl sql.For
 			}
 		}
 
-		typeTransforms, err := GetChildParentTypeTransforms(tbl.Schema(), refTbl.Schema(), fkDef)
+		typeTransforms, err := GetChildParentTypeTransforms(refTbl.Schema(), tbl.Schema(), fkDef)
 		if err != nil {
 			return err
 		}

sql/plan/foreign_key_editor.go

@@ -426,6 +426,7 @@ func (reference *ForeignKeyReferenceHandler) CheckReference(ctx *sql.Context, ro
 			return nil
 		}
 	}
+	
 	return sql.ErrForeignKeyChildViolation.New(reference.ForeignKey.Name, reference.ForeignKey.Table,
 		reference.ForeignKey.ParentTable, reference.RowMapper.GetKeyString(row))
 }
@@ -458,7 +459,7 @@ type ForeignKeyRowMapper struct {
 	SourceSch sql.Schema
 	// TargetTypeTransforms are a set of functions to transform the value in the table to the corresponding value in the
 	// other table. This is required when the types of the two tables are compatible but different (e.g. INT and BIGINT). 
-	TargetTypeTransforms []func(ctx *sql.Context, val any) (any, error)
+	TargetTypeTransforms []func(ctx *sql.Context, val any) (sql.Type, any, error)
 	// IndexPositions hold the mapping between an index's column position and the source row's column position. Given
 	// an index (x1, x2) and a source row (y1, y2, y3) and the relation (x1->y3, x2->y1), this slice would contain
 	// [2, 0]. The first index column "x1" maps to the third source column "y3" (so position 2 since it's zero-based),
@@ -486,17 +487,18 @@ func (mapper *ForeignKeyRowMapper) GetIter(ctx *sql.Context, row sql.Row, refChe
 			return sql.RowsToRowIter(), nil
 		}
 
+		targetType := mapper.SourceSch[rowPos].Type
 		// Transform the type of the value in this row to the one in the other table for the index lookup, if necessary
 		if mapper.TargetTypeTransforms != nil && mapper.TargetTypeTransforms[rowPos] != nil {
 			var err error
-			rowVal, err = mapper.TargetTypeTransforms[rowPos](ctx, rowVal)
+			targetType, rowVal, err = mapper.TargetTypeTransforms[rowPos](ctx, rowVal)
 			// TODO: possible for this to fail without error, which means the value cannot be found in the other table
 			if err != nil {
 				return nil, err
 			}
 		}
 
-		rang[rangPosition] = sql.ClosedRangeColumnExpr(rowVal, rowVal, mapper.SourceSch[rowPos].Type)
+		rang[rangPosition] = sql.ClosedRangeColumnExpr(rowVal, rowVal, targetType)
 	}
 	for i, appendType := range mapper.AppendTypes {
 		rang[i+len(mapper.IndexPositions)] = sql.AllRangeColumnExpr(appendType)
@@ -565,7 +567,7 @@ func GetChildParentMapping(parentSch sql.Schema, childSch sql.Schema, fkDef sql.
 
 // GetChildParentTypeTransforms returs a set of functions to transform the value in the child table to the 
 // corresponding type in the parent table, if necessary
-func GetChildParentTypeTransforms(parentSch sql.Schema, childSch sql.Schema, fkDef sql.ForeignKeyConstraint) ([]func(ctx *sql.Context, val any) (any, error), error) {
+func GetChildParentTypeTransforms(parentSch sql.Schema, childSch sql.Schema, fkDef sql.ForeignKeyConstraint) ([]func(ctx *sql.Context, val any) (sql.Type, any, error), error) {
 	parentMap := make(map[string]int)
 	for i, col := range parentSch {
 		parentMap[strings.ToLower(col.Name)] = i
@@ -575,7 +577,7 @@ func GetChildParentTypeTransforms(parentSch sql.Schema, childSch sql.Schema, fkD
 		childMap[strings.ToLower(col.Name)] = i
 	}
 
-	var mapping []func(*sql.Context, any) (any, error)
+	var mapping []func(*sql.Context, any) (sql.Type, any, error)
 
 	for i := range fkDef.Columns {
 		childIndex, ok := childMap[strings.ToLower(fkDef.Columns[i])]
@@ -601,10 +603,11 @@ func GetChildParentTypeTransforms(parentSch sql.Schema, childSch sql.Schema, fkD
 		if !childType.Equals(parentType) {
 			parentExtendedType, _ := parentType.(types.ExtendedType)
 			if mapping == nil {
-				mapping = make([]func(*sql.Context, any) (any, error), len(childSch))
+				mapping = make([]func(*sql.Context, any) (sql.Type, any, error), len(childSch))
 			}
-			mapping[childIndex] = func(ctx *sql.Context, val any) (any, error) {
-				return parentExtendedType.ConvertToType(ctx, childExtendedType, val)
+			mapping[childIndex] = func(ctx *sql.Context, val any) (sql.Type, any, error) {
+				convertedVal, err := parentExtendedType.ConvertToType(ctx, childExtendedType, val)
+				return parentExtendedType, convertedVal, err
 			}
 		}
 	}