}

	AssertEqual(t, user1.NamedPet.Name, "joins-on_pet_1")

	onQuery2 := DB.Where(&Pet{Name: "joins-on_pet_2"})
	var user2 User
	if err := DB.Joins("NamedPet", onQuery2).Where("users.name = ?", user.Name).First(&user2).Error; err != nil {
		t.Fatalf("Failed to load with joins on, got error: %v", err)
	}
	AssertEqual(t, user2.NamedPet.Name, "joins-on_pet_2")
}

	AssertEqual(t, nil, err)

	var findUser1 User
	err = DB.Preload("Languages").Where("id = ?", user1.ID).First(&findUser1).Error
	AssertEqual(t, nil, err)
	AssertEqual(t, user1, findUser1)

	var findUser2 User
	err = DB.Preload("Languages").Where("id = ?", user2.ID).First(&findUser2).Error
	AssertEqual(t, nil, err)
	AssertEqual(t, user2, findUser2)
}

	u.Mobile = ""
	err = DB.Clauses(clause.OnConflict{UpdateAll: true}).Create(&u).Error
	AssertEqual(t, err, nil)

	var u2 OnConflictUser
	err = DB.Where("id = ?", u.ID).First(&u2).Error
	AssertEqual(t, err, nil)
	AssertEqual(t, u2.Name, "on-conflict-user-name-2")
	AssertEqual(t, u2.Email, "on-conflict-user-email-2")
	AssertEqual(t, u2.Mobile, "133xxxx")
}

func TestCreateFromMapWithoutPK(t *testing.T) {

	if err != nil {
		t.Errorf("failed to find value, got err: %v", err)
	}
	AssertEqual(t, len(finds), 2)
	AssertEqual(t, finds[0], value1)
	AssertEqual(t, finds[1], value2)
}

func TestMergeNestedPreloadWithNestedJoin(t *testing.T) {
	users := []User{
		{
			Name: "TestMergeNestedPreloadWithNestedJoin-1",
			Manager: &User{
				Name: "Alexis Manager",
				Tools: []Tools{

	err = DB.Model(&emptyUser).Association("Company").Delete(&user1.Company)
	AssertEqual(t, err, gorm.ErrPrimaryKeyRequired)
	// has many
	err = DB.Model(&emptyUser).Association("Pets").Delete(&user1.Pets)
	AssertEqual(t, err, gorm.ErrPrimaryKeyRequired)
	// has one
	err = DB.Model(&emptyUser).Association("Account").Delete(&user1.Account)
	AssertEqual(t, err, gorm.ErrPrimaryKeyRequired)
	// many to many

	} else {
		AssertEqual(t, result, lang)
	}

	lang.Name += "_new"
	if err := DB.Save(&lang).Error; err != nil {
		t.Errorf("Failed to create, got error %v", err)
	}

	var result2 Language
	if err := DB.First(&result2, "code = ?", lang.Code).Error; err != nil {
		t.Errorf("Failed to query lang, got error %v", err)
	} else {
		AssertEqual(t, result2, lang)
	}
}

	}

	var result Language
	DB.First(&result, "code = ?", "save")
	AssertEqual(t, result, lang)

	lang.Name = "save name2"
	if result := DB.Save(&lang); result.RowsAffected != 1 {
		t.Errorf("should update language")
	}

	var result2 Language
	DB.First(&result2, "code = ?", "save")
	AssertEqual(t, result2, lang)

	DB.Table("langs").Migrator().DropTable(&Language{})

		t.Errorf("Table with escape character, got %v", r.Statement.SQL.String())
	}

	AssertEqual(t, r.Statement.Vars, []interface{}{2, 4, 1, 3})
}

func TestTableWithAllFields(t *testing.T) {
	dryDB := DB.Session(&gorm.Session{DryRun: true, QueryFields: true})

	}

	personDupField := Person{ID: person1.ID}
	if err := DB.Select("people.id, people.*").
		First(&personDupField).Error; err != nil {
		t.Errorf("Failed to run join query, got error: %v", err)
	}
	AssertEqual(t, person1, personDupField)

	user := User{
		Name: "TestScanToEmbedded_1",
		Manager: &User{
			Name:    "TestScanToEmbedded_1_m1",
			Manager: &User{Name: "TestScanToEmbedded_1_m1_m1"},
		},
	}

	if product.Name != "Product New3" || product.Price != 220 || product.Code != "L1213" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	var result Product3
	DB.First(&result, product.ID)

	AssertEqual(t, result, product)

	// Select to change Code, but nothing updated, price should not change
	DB.Model(&product).Select("code").Updates(Product3{Name: "L1214", Code: "L1213"})