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) } }