t.Fatalf("Failed to auto migrate, but got error %v", err)
	}
}

func TestMigrateWithUniqueIndex(t *testing.T) {
	type UserWithUniqueIndex struct {
		ID    int
		Name  string    `gorm:"size:20;index:idx_name,unique"`
		Date  time.Time `gorm:"index:idx_name,unique"`
		UName string    `gorm:"uniqueIndex;size:255"`
	}

	DB.Migrator().DropTable(&UserWithUniqueIndex{})

	return nil
}

func (s Product3) BeforeUpdate(tx *gorm.DB) (err error) {
	if tx.Statement.Changed() {
		tx.Statement.SetColumn("Price", s.Price+10)
	}

	if tx.Statement.Changed("Code") {
		s.Price += 20
		tx.Statement.SetColumn("Price", s.Price+30)
	}
	return nil
}

func TestSetColumn(t *testing.T) {
	DB.Migrator().DropTable(&Product3{})
	DB.AutoMigrate(&Product3{})

	Address *Address `gorm:"embedded"`
}

func TestScan(t *testing.T) {
	user1 := User{Name: "ScanUser1", Age: 1}
	user2 := User{Name: "ScanUser2", Age: 10}
	user3 := User{Name: "ScanUser3", Age: 20}
	DB.Save(&user1).Save(&user2).Save(&user3)

	type result struct {
		ID   uint
		Name string
		Age  int
	}

	var res result
	DB.Table("users").Select("id, name, age").Where("id = ?", user3.ID).Scan(&res)

	// test setter
	newValues := map[string]interface{}{
		"name":       "valuer_and_setter_2",
		"id":         2,
		"created_at": time.Now(),
		"updated_at": nil,
		"deleted_at": time.Now(),
		"age":        20,
		"birthday":   time.Now(),
		"active":     f,
	}

	for k, v := range newValues {
		if err := userSchema.FieldsByDBName[k].Set(context.Background(), reflectValue, v); err != nil {

	}

	DB.Table(table).Where(map[string]interface{}{"name": user2.Name}).Update("age", 20)

	row = DB.Table(table+" as u").Where("u.name = ?", user2.Name).Select("age").Row()
	if err := row.Scan(&age); err != nil {
		t.Fatalf("Failed to scan age, got %v", err)
	}

	if age != 20 {
		t.Errorf("Scan with Row, age expects: %v, got %v", user2.Age, age)
	}
}

func TestRows(t *testing.T) {

	}
}

func TestLimit(t *testing.T) {
	users := []User{
		{Name: "LimitUser1", Age: 1},
		{Name: "LimitUser2", Age: 10},
		{Name: "LimitUser3", Age: 20},
		{Name: "LimitUser4", Age: 10},
		{Name: "LimitUser5", Age: 20},
		{Name: "LimitUser6", Age: 20},
	}

	DB.Create(&users)

	var users1, users2, users3 []User
	DB.Order("age desc").Limit(3).Find(&users1).Limit(5).Find(&users2).Limit(-1).Find(&users3)

	}
	return fmt.Sprintf("%s.%s", schema.ModelType.PkgPath(), schema.ModelType.Name())
}

func (schema Schema) MakeSlice() reflect.Value {
	slice := reflect.MakeSlice(reflect.SliceOf(reflect.PtrTo(schema.ModelType)), 0, 20)
	results := reflect.New(slice.Type())
	results.Elem().Set(slice)
	return results
}

func (schema Schema) LookUpField(name string) *Field {
	if field, ok := schema.FieldsByDBName[name]; ok {
		return field
	}

		return err
	}
	db.Plugins[name] = plugin
	return nil
}

// ToSQL for generate SQL string.
//
//	db.ToSQL(func(tx *gorm.DB) *gorm.DB {
//			return tx.Model(&User{}).Where(&User{Name: "foo", Age: 20})
//				.Limit(10).Offset(5)
//				.Order("name ASC")
//				.First(&User{})
//	})
func (db *DB) ToSQL(queryFn func(tx *DB) *DB) string {
	tx := queryFn(db.Session(&Session{DryRun: true, SkipDefaultTransaction: true}))