From 300b74f15f07972b521a0d9eefdb2d6ccb48bdaf Mon Sep 17 00:00:00 2001 From: Jinzhu Date: Sat, 26 Dec 2015 16:06:53 +0800 Subject: [PATCH] Refactor association Delete --- association.go | 85 ++++++++++++++++++++--------------- polymorphic_test.go | 106 +++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 154 insertions(+), 37 deletions(-) diff --git a/association.go b/association.go index a8a67be7..10be46c6 100644 --- a/association.go +++ b/association.go @@ -169,37 +169,30 @@ func (association *Association) Delete(values ...interface{}) *Association { return association } + var deletingResourcePrimaryFieldNames, deletingResourcePrimaryDBNames []string + for _, field := range scope.New(reflect.New(field.Type()).Interface()).Fields() { + if field.IsPrimaryKey { + deletingResourcePrimaryFieldNames = append(deletingResourcePrimaryFieldNames, field.Name) + deletingResourcePrimaryDBNames = append(deletingResourcePrimaryDBNames, field.DBName) + } + } + + deletingPrimaryKeys := association.getPrimaryKeys(deletingResourcePrimaryFieldNames, values...) + if relationship.Kind == "many_to_many" { - // many to many - // current value's foreign keys + // source value's foreign keys for idx, foreignKey := range relationship.ForeignDBNames { if field, ok := scope.FieldByName(relationship.ForeignFieldNames[idx]); ok { newDB = newDB.Where(fmt.Sprintf("%v = ?", scope.Quote(foreignKey)), field.Field.Interface()) } } - // deleting value's foreign keys - primaryKeys := association.getPrimaryKeys(relationship.AssociationForeignFieldNames, values...) - sql := fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relationship.AssociationForeignDBNames), toQueryMarks(primaryKeys)) - newDB = newDB.Where(sql, toQueryValues(primaryKeys)...) + // association value's foreign keys + deletingPrimaryKeys := association.getPrimaryKeys(relationship.AssociationForeignFieldNames, values...) + sql := fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relationship.AssociationForeignDBNames), toQueryMarks(deletingPrimaryKeys)) + newDB = newDB.Where(sql, toQueryValues(deletingPrimaryKeys)...) - if err := relationship.JoinTableHandler.Delete(relationship.JoinTableHandler, newDB, relationship); err == nil { - leftValues := reflect.Zero(association.Field.Field.Type()) - for i := 0; i < association.Field.Field.Len(); i++ { - reflectValue := association.Field.Field.Index(i) - primaryKey := association.getPrimaryKeys(relationship.ForeignFieldNames, reflectValue.Interface())[0] - var included = false - for _, pk := range primaryKeys { - if equalAsString(primaryKey, pk) { - included = true - } - } - if !included { - leftValues = reflect.Append(leftValues, reflectValue) - } - } - association.Field.Set(leftValues) - } + association.setErr(relationship.JoinTableHandler.Delete(relationship.JoinTableHandler, newDB, relationship)) } else { var foreignKeyMap = map[string]interface{}{} for _, foreignKey := range relationship.ForeignDBNames { @@ -225,23 +218,45 @@ func (association *Association) Delete(values ...interface{}) *Association { ) // only include those deleting relations - var primaryFieldNames, primaryFieldDBNames []string - for _, field := range scope.New(reflect.New(field.Type()).Interface()).Fields() { - if field.IsPrimaryKey { - primaryFieldNames = append(primaryFieldNames, field.Name) - primaryFieldDBNames = append(primaryFieldDBNames, field.DBName) - } - } - - relationsPrimaryKeys := association.getPrimaryKeys(primaryFieldNames, values...) newDB = newDB.Where( - fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, primaryFieldDBNames), toQueryMarks(relationsPrimaryKeys)), - toQueryValues(relationsPrimaryKeys)..., + fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, deletingResourcePrimaryDBNames), toQueryMarks(deletingPrimaryKeys)), + toQueryValues(deletingPrimaryKeys)..., ) // set matched relation's foreign key to be null fieldValue := reflect.New(association.Field.Field.Type()).Interface() - newDB.Model(fieldValue).UpdateColumn(foreignKeyMap) + association.setErr(newDB.Model(fieldValue).UpdateColumn(foreignKeyMap).Error) + } + } + + // Remove deleted records from field + if association.Error == nil { + if association.Field.Field.Kind() == reflect.Slice { + leftValues := reflect.Zero(association.Field.Field.Type()) + + for i := 0; i < association.Field.Field.Len(); i++ { + reflectValue := association.Field.Field.Index(i) + primaryKey := association.getPrimaryKeys(deletingResourcePrimaryFieldNames, reflectValue.Interface())[0] + var included = false + for _, pk := range deletingPrimaryKeys { + if equalAsString(primaryKey, pk) { + included = true + } + } + if !included { + leftValues = reflect.Append(leftValues, reflectValue) + } + } + + association.Field.Set(leftValues) + } else if association.Field.Field.Kind() == reflect.Struct { + for _, pk := range deletingPrimaryKeys { + primaryKey := association.getPrimaryKeys(deletingResourcePrimaryFieldNames, association.Field.Field)[0] + if equalAsString(primaryKey, pk) { + association.Field.Set(reflect.Zero(association.Field.Field.Type())) + break + } + } } } diff --git a/polymorphic_test.go b/polymorphic_test.go index f926fdd4..f3d7584d 100644 --- a/polymorphic_test.go +++ b/polymorphic_test.go @@ -1,7 +1,6 @@ package gorm_test import ( - "fmt" "reflect" "sort" "testing" @@ -103,7 +102,6 @@ func TestPolymorphic(t *testing.T) { var dogToys2 []Toy DB.Model(&dog).Association("Toys").Find(&dogToys2) - fmt.Println(dogToys2) if !compareToys(dogToys2, []string{"dog toy 1", "dog toy 2", "dog toy 3"}) { t.Errorf("Dog's toys should be updated with Append") } @@ -111,7 +109,111 @@ func TestPolymorphic(t *testing.T) { if DB.Model(&dog).Association("Toys").Count() != 3 { t.Errorf("Should return three polymorphic has many associations") } + // Replace + DB.Model(&cat).Association("Toy").Replace(&Toy{ + Name: "cat toy 3", + }) + + var catToy3 Toy + DB.Model(&cat).Association("Toy").Find(&catToy3) + if catToy3.Name != "cat toy 3" { + t.Errorf("Should update has one polymorphic association with Replace") + } + + if DB.Model(&cat).Association("Toy").Count() != 1 { + t.Errorf("Cat's toys count should be 1 after Replace") + } + + if DB.Model(&dog).Association("Toys").Count() != 3 { + t.Errorf("Should return three polymorphic has many associations") + } + + DB.Model(&dog).Association("Toys").Replace(&Toy{ + Name: "dog toy 4", + }, []Toy{ + {Name: "dog toy 5"}, {Name: "dog toy 6"}, {Name: "dog toy 7"}, + }) + + var dogToys3 []Toy + DB.Model(&dog).Association("Toys").Find(&dogToys3) + if !compareToys(dogToys3, []string{"dog toy 4", "dog toy 5", "dog toy 6", "dog toy 7"}) { + t.Errorf("Dog's toys should be updated with Replace") + } + + if DB.Model(&dog).Association("Toys").Count() != 4 { + t.Errorf("Should return three polymorphic has many associations") + } + // Delete + DB.Model(&cat).Association("Toy").Delete(&catToy2) + + var catToy4 Toy + DB.Model(&cat).Association("Toy").Find(&catToy4) + if catToy4.Name != "cat toy 3" { + t.Errorf("Should not update has one polymorphic association when Delete a unrelated Toy") + } + + if DB.Model(&cat).Association("Toy").Count() != 1 { + t.Errorf("Cat's toys count should be 1") + } + + if DB.Model(&dog).Association("Toys").Count() != 4 { + t.Errorf("Dog's toys count should be 4") + } + + DB.Model(&cat).Association("Toy").Delete(&catToy3) + + if !DB.Model(&cat).Related(&Toy{}, "Toy").RecordNotFound() { + t.Errorf("Toy should be deleted with Delete") + } + + if DB.Model(&cat).Association("Toy").Count() != 0 { + t.Errorf("Cat's toys count should be 0 after Delete") + } + + if DB.Model(&dog).Association("Toys").Count() != 4 { + t.Errorf("Dog's toys count should not be changed when delete cat's toy") + } + + DB.Model(&dog).Association("Toys").Delete(&dogToys2) + + if DB.Model(&dog).Association("Toys").Count() != 4 { + t.Errorf("Dog's toys count should not be changed when delete unrelated toys") + } + + DB.Model(&dog).Association("Toys").Delete(&dogToys3) + + if DB.Model(&dog).Association("Toys").Count() != 0 { + t.Errorf("Dog's toys count should be deleted with Delete") + } + // Clear + DB.Model(&cat).Association("Toy").Append(&Toy{ + Name: "cat toy 2", + }) + + if DB.Model(&cat).Association("Toy").Count() != 1 { + t.Errorf("Cat's toys should be added with Append") + } + + DB.Model(&cat).Association("Toy").Clear() + + if DB.Model(&cat).Association("Toy").Count() != 0 { + t.Errorf("Cat's toys should be cleared with Clear") + } + + DB.Model(&dog).Association("Toys").Append(&Toy{ + Name: "dog toy 8", + }) + + if DB.Model(&dog).Association("Toys").Count() != 1 { + t.Errorf("Dog's toys should be added with Append") + } + + DB.Model(&dog).Association("Toys").Clear() + + if DB.Model(&dog).Association("Toys").Count() != 0 { + t.Errorf("Dog's toys should be cleared with Clear") + } }