func Migrate(x *xorm.Engine) error {
if err := x.Sync(new(Version)); err != nil {
return fmt.Errorf("sync: %v", err)
}
currentVersion := &Version{Id: 1}
has, err := x.Get(currentVersion)
if err != nil {
return fmt.Errorf("get: %v", err)
} else if !has {
// If the version record does not exist we think
// it is a fresh installation and we can skip all migrations.
currentVersion.Version = int64(_MIN_DB_VER + len(migrations))
if _, err = x.InsertOne(currentVersion); err != nil {
return fmt.Errorf("insert: %v", err)
}
}
v := currentVersion.Version
for i, m := range migrations[v-_MIN_DB_VER:] {
log.Info("Migration: %s", m.Description())
if err = m.Migrate(x); err != nil {
return fmt.Errorf("do migrate: %v", err)
}
currentVersion.Version = v + int64(i) + 1
if _, err = x.Id(1).Update(currentVersion); err != nil {
return err
}
}
return nil
}
// Migrate database to current version
func Migrate(x *xorm.Engine) error {
if err := x.Sync(new(Version)); err != nil {
return fmt.Errorf("sync: %v", err)
}
currentVersion := &Version{Id: 1}
has, err := x.Get(currentVersion)
if err != nil {
return fmt.Errorf("get: %v", err)
} else if !has {
// If the user table does not exist it is a fresh installation and we
// can skip all migrations.
needsMigration, err := x.IsTableExist("user")
if err != nil {
return err
}
if needsMigration {
isEmpty, err := x.IsTableEmpty("user")
if err != nil {
return err
}
// If the user table is empty it is a fresh installation and we can
// skip all migrations.
needsMigration = !isEmpty
}
if !needsMigration {
currentVersion.Version = int64(_MIN_DB_VER + len(migrations))
}
if _, err = x.InsertOne(currentVersion); err != nil {
return fmt.Errorf("insert: %v", err)
}
}
v := currentVersion.Version
if _MIN_DB_VER > v {
log.Fatal(4, "Gogs no longer supports auto-migration from your previously installed version. Please try to upgrade to a lower version first, then upgrade to current version.")
return nil
}
if int(v-_MIN_DB_VER) > len(migrations) {
// User downgraded Gogs.
currentVersion.Version = int64(len(migrations) + _MIN_DB_VER)
_, err = x.Id(1).Update(currentVersion)
return err
}
for i, m := range migrations[v-_MIN_DB_VER:] {
log.Info("Migration: %s", m.Description())
if err = m.Migrate(x); err != nil {
return fmt.Errorf("do migrate: %v", err)
}
currentVersion.Version = v + int64(i) + 1
if _, err = x.Id(1).Update(currentVersion); err != nil {
return err
}
}
return nil
}
// Migrate database to current version
func Migrate(x *xorm.Engine) error {
if err := x.Sync(new(Version)); err != nil {
return fmt.Errorf("sync: %v", err)
}
currentVersion := &Version{Id: 1}
has, err := x.Get(currentVersion)
if err != nil {
return fmt.Errorf("get: %v", err)
} else if !has {
// If the user table does not exist it is a fresh installation and we
// can skip all migrations.
needsMigration, err := x.IsTableExist("user")
if err != nil {
return err
}
if needsMigration {
isEmpty, err := x.IsTableEmpty("user")
if err != nil {
return err
}
// If the user table is empty it is a fresh installation and we can
// skip all migrations.
needsMigration = !isEmpty
}
if !needsMigration {
currentVersion.Version = int64(_MIN_DB_VER + len(migrations))
}
if _, err = x.InsertOne(currentVersion); err != nil {
return fmt.Errorf("insert: %v", err)
}
}
v := currentVersion.Version
for i, m := range migrations[v-_MIN_DB_VER:] {
log.Info("Migration: %s", m.Description())
if err = m.Migrate(x); err != nil {
return fmt.Errorf("do migrate: %v", err)
}
currentVersion.Version = v + int64(i) + 1
if _, err = x.Id(1).Update(currentVersion); err != nil {
return err
}
}
return nil
}
// Migrate database to current version
func Migrate(x *xorm.Engine) error {
if err := x.Sync(new(Version)); err != nil {
return fmt.Errorf("sync: %v", err)
}
currentVersion := &Version{ID: 1}
has, err := x.Get(currentVersion)
if err != nil {
return fmt.Errorf("get: %v", err)
} else if !has {
// If the version record does not exist we think
// it is a fresh installation and we can skip all migrations.
currentVersion.Version = int64(_MIN_DB_VER + len(migrations))
if _, err = x.InsertOne(currentVersion); err != nil {
return fmt.Errorf("insert: %v", err)
}
}
v := currentVersion.Version
if _MIN_DB_VER > v {
log.Fatal(4, `Gogs no longer supports auto-migration from your previously installed version.
Please try to upgrade to a lower version (>= v0.6.0) first, then upgrade to current version.`)
return nil
}
if int(v-_MIN_DB_VER) > len(migrations) {
// User downgraded Gogs.
currentVersion.Version = int64(len(migrations) + _MIN_DB_VER)
_, err = x.Id(1).Update(currentVersion)
return err
}
for i, m := range migrations[v-_MIN_DB_VER:] {
log.Info("Migration: %s", m.Description())
if err = m.Migrate(x); err != nil {
return fmt.Errorf("do migrate: %v", err)
}
currentVersion.Version = v + int64(i) + 1
if _, err = x.Id(1).Update(currentVersion); err != nil {
return err
}
}
return nil
}
func testDeleted(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&Deleted{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&Deleted{})
if err != nil {
t.Error(err)
panic(err)
}
_, err = engine.InsertOne(&Deleted{Id: 1, Name: "11111"})
if err != nil {
t.Error(err)
panic(err)
}
_, err = engine.InsertOne(&Deleted{Id: 2, Name: "22222"})
if err != nil {
t.Error(err)
panic(err)
}
_, err = engine.InsertOne(&Deleted{Id: 3, Name: "33333"})
if err != nil {
t.Error(err)
panic(err)
}
// Test normal Find()
var records1 []Deleted
err = engine.Where("`"+engine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&records1, &Deleted{})
if len(records1) != 3 {
t.Fatalf("Find failed: expected=%d, actual=%d, err=%v", 3, len(records1), err)
}
// Test normal Get()
record1 := &Deleted{}
has, err := engine.Id(1).Get(record1)
if !has {
t.Fatalf("Get failed: expected=%v, actual=%v, err=%v", true, has, err)
}
//fmt.Println("----- get:", record1)
// Test Delete() with deleted
affected, err := engine.Id(1).Delete(&Deleted{})
if affected != 1 {
t.Fatalf("Delete failed: expected=%v, actual=%v, err=%v", 1, affected, err)
}
has, err = engine.Id(1).Get(&Deleted{})
if has {
t.Fatalf("Delete failed. Must not get any records.")
}
var records2 []Deleted
err = engine.Where("`" + engine.ColumnMapper.Obj2Table("Id") + "` > 0").Find(&records2)
if len(records2) != 2 {
t.Fatalf("Find() failed.")
}
// Test no rows affected after Delete() again.
affected, err = engine.Id(1).Delete(&Deleted{})
if affected != 0 {
t.Fatalf("Delete failed. No rows must be affected: expected=%v, actual=%v, err=%v", 0, affected, err)
}
// Deleted.DeletedAt must not be updated.
affected, err = engine.Id(2).Update(&Deleted{Name: "2", DeletedAt: time.Now()})
if affected != 1 {
t.Fatalf("Update failed: expected=%v, actual=%v, err=%v", 1, affected, err)
}
record2 := &Deleted{}
has, err = engine.Id(2).Get(record2)
if !record2.DeletedAt.IsZero() {
t.Fatalf("Update failed: DeletedAt must be zero value. actual=%v", record2.DeletedAt)
}
// Test find all records whatever `deleted`.
var unscopedRecords1 []Deleted
err = engine.Unscoped().Where("`"+engine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&unscopedRecords1, &Deleted{})
if len(unscopedRecords1) != 3 {
fmt.Printf("unscopedRecords1 = %v\n", unscopedRecords1)
t.Fatalf("Find failed: all records must be selected when engine.Unscoped()")
}
// Delete() must really delete a record with Unscoped()
affected, err = engine.Unscoped().Id(1).Delete(&Deleted{})
if affected != 1 {
t.Fatalf("Delete failed")
}
var unscopedRecords2 []Deleted
err = engine.Unscoped().Where("`"+engine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&unscopedRecords2, &Deleted{})
if len(unscopedRecords2) != 2 {
t.Fatalf("Find failed: Only 2 records must be selected when engine.Unscoped()")
}
var records3 []Deleted
err = engine.Where("`"+engine.ColumnMapper.Obj2Table("Id")+"` > 0").And("`"+engine.ColumnMapper.Obj2Table("Id")+"`> 1").
Or("`"+engine.ColumnMapper.Obj2Table("Id")+"` = ?", 3).Find(&records3)
if len(records3) != 2 {
t.Fatalf("Find failed: expected=%d, actual=%d, err=%v", 2, len(records3), err)
}
}
