func TestSaveWithPrimaryValue(t *testing.T) {
	lang := Language{Code: "save", Name: "save"}
	if result := DB.Save(&lang); result.RowsAffected != 1 {
		t.Errorf("should create language, rows affected: %v", result.RowsAffected)
	}

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

	lang.Name = "save name2"
	if result := DB.Save(&lang); result.RowsAffected != 1 {

func SaveBeforeAssociations(create bool) func(db *gorm.DB) {
	return func(db *gorm.DB) {
		if db.Error == nil && db.Statement.Schema != nil {
			selectColumns, restricted := db.Statement.SelectAndOmitColumns(create, !create)

			// Save Belongs To associations
			for _, rel := range db.Statement.Schema.Relationships.BelongsTo {
				if v, ok := selectColumns[rel.Name]; (ok && !v) || (!ok && restricted) {
					continue
				}

	DB.AutoMigrate(&Product{})

	p := Product{Code: "Invalid", Price: 100}
	if DB.Save(&p).Error == nil {
		t.Fatalf("An error from before create callbacks happened when create with invalid value")
	}

	if DB.Where("code = ?", "Invalid").First(&Product{}).Error == nil {
		t.Fatalf("Should not save record that have errors")
	}

	if DB.Save(&Product{Code: "dont_save", Price: 100}).Error == nil {

	}
}

func TestScanToEmbedded(t *testing.T) {
	person1 := Person{Name: "person 1"}
	person2 := Person{Name: "person 2"}
	DB.Save(&person1).Save(&person2)

	address1 := Address{Name: "address 1"}
	address2 := Address{Name: "address 2"}
	DB.Save(&address1).Save(&address2)

	DB.Create(&PersonAddress{PersonID: person1.ID, AddressID: int(address1.ID)})

	tx := DB.Begin()

	user := *GetUser("transaction-save-point", Config{})
	tx.Create(&user)

	if err := tx.First(&User{}, "name = ?", user.Name).Error; err != nil {
		t.Fatalf("Should find saved record")
	}

	if err := tx.SavePoint("save_point1").Error; err != nil {
		t.Fatalf("Failed to save point, got error %v", err)
	}

	user1 := *GetUser("transaction-save-point-1", Config{})
	tx.Create(&user1)

		}
	}
}

func TestUpsertWithSave(t *testing.T) {
	langs := []Language{
		{Code: "upsert-save-1", Name: "Upsert-save-1"},
		{Code: "upsert-save-2", Name: "Upsert-save-2"},
	}

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

	for _, lang := range langs {
		var result Language

	child := Child{ParentID: &parent.ID, Parent: &parent}
	DB.Create(&child)

	parent.FavChildID = child.ID
	parent.FavChild = &child
	DB.Save(&parent)

	var parent1 Parent
	DB.First(&parent1, parent.ID)
	AssertObjEqual(t, parent, parent1, "ID", "FavChildID")

	// Save and Updates is the same
	DB.Updates(&parent)
	DB.First(&parent1, parent.ID)
	AssertObjEqual(t, parent, parent1, "ID", "FavChildID")
}

	. "gorm.io/gorm/utils/tests"
)

func TestRow(t *testing.T) {
	user1 := User{Name: "RowUser1", Age: 1}
	user2 := User{Name: "RowUser2", Age: 10}
	user3 := User{Name: "RowUser3", Age: 20}
	DB.Save(&user1).Save(&user2).Save(&user3)

	row := DB.Table("users").Where("name = ?", user2.Name).Select("age").Row()

	var age int64
	if err := row.Scan(&age); err != nil {
		t.Fatalf("Failed to scan age, got %v", err)
	}

        loadLayout(reader, false);
    }

    public void save() throws IOException {
        save(this.location);
    }

    public void save(Path location) throws IOException {
        try (OutputStream os = Files.newOutputStream(location)) {
            save(os);
        }
    }

    public void save(OutputStream os) throws IOException {
        save(new OutputStreamWriter(os, DEFAULT_ENCODING));
    }

        loadLayout(reader, false);
    }

    public void save() throws IOException {
        save(this.location);
    }

    public void save(Path location) throws IOException {
        try (OutputStream os = Files.newOutputStream(location)) {
            save(os);
        }
    }

    public void save(OutputStream os) throws IOException {
        save(new OutputStreamWriter(os, DEFAULT_ENCODING));
    }