func testLowerCase(engine *xorm.Engine, t *testing.T) { err := engine.Sync(&Lowercase{}) _, err = engine.Where("(id) > 0").Delete(&Lowercase{}) if err != nil { t.Error(err) panic(err) } _, err = engine.Insert(&Lowercase{ended: 1}) if err != nil { t.Error(err) panic(err) } ls := make([]Lowercase, 0) err = engine.Find(&ls) if err != nil { t.Error(err) panic(err) } if len(ls) != 1 { err = errors.New("should be 1") t.Error(err) panic(err) } }
func testCreatedUpdated(engine *xorm.Engine, t *testing.T) { err := engine.Sync(&CreatedUpdated{}) if err != nil { t.Error(err) panic(err) } c := &CreatedUpdated{Name: "test"} _, err = engine.Insert(c) if err != nil { t.Error(err) panic(err) } c2 := new(CreatedUpdated) has, err := engine.Id(c.Id).Get(c2) if err != nil { t.Error(err) panic(err) } if !has { panic(errors.New("no id")) } c2.Value -= 1 _, err = engine.Id(c2.Id).Update(c2) if err != nil { t.Error(err) panic(err) } }
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 }
func NewTestEngine(x *xorm.Engine) (err error) { switch DbCfg.Type { case "mysql": x, err = xorm.NewEngine("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8", DbCfg.User, DbCfg.Pwd, DbCfg.Host, DbCfg.Name)) case "postgres": var host, port = "127.0.0.1", "5432" fields := strings.Split(DbCfg.Host, ":") if len(fields) > 0 && len(strings.TrimSpace(fields[0])) > 0 { host = fields[0] } if len(fields) > 1 && len(strings.TrimSpace(fields[1])) > 0 { port = fields[1] } cnnstr := fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s sslmode=%s", DbCfg.User, DbCfg.Pwd, host, port, DbCfg.Name, DbCfg.SslMode) //fmt.Println(cnnstr) x, err = xorm.NewEngine("postgres", cnnstr) case "sqlite3": if !EnableSQLite3 { return fmt.Errorf("Unknown database type: %s", DbCfg.Type) } os.MkdirAll(path.Dir(DbCfg.Path), os.ModePerm) x, err = xorm.NewEngine("sqlite3", DbCfg.Path) default: return fmt.Errorf("Unknown database type: %s", DbCfg.Type) } if err != nil { return fmt.Errorf("models.init(fail to conntect database): %v", err) } return x.Sync(tables...) }
func OrmRegModels(eng *xorm.Engine) { err := eng.Sync(new(WalletDbT)) if err != nil { logmodels.Logger.Info(logmodels.SPrintError("Database Table", "XORM Engine Sync is err %v", err)) panic(1) } }
func NewTestEngine(x *xorm.Engine) (err error) { x, err = getEngine() if err != nil { return fmt.Errorf("models.init(fail to conntect database): %v", err) } return x.Sync(tables...) }
// 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 }
func NewTestEngine(x *xorm.Engine) (err error) { x, err = getEngine() if err != nil { return fmt.Errorf("Connect to database: %v", err) } x.SetMapper(core.GonicMapper{}) return x.Sync(tables...) }
func get(engine *xorm.Engine, t *testing.T) { user := Userinfo{Uid: 2} has, err := engine.Get(&user) if err != nil { t.Error(err) panic(err) } if has { fmt.Println(user) } else { fmt.Println("no record id is 2") } err = engine.Sync(&NoIdUser{}) if err != nil { t.Error(err) panic(err) } userCol := engine.ColumnMapper.Obj2Table("User") _, err = engine.Where("`"+userCol+"` = ?", "xlw").Delete(&NoIdUser{}) if err != nil { t.Error(err) panic(err) } cnt, err := engine.Insert(&NoIdUser{"xlw", 20, 100}) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("insert not returned 1") t.Error(err) panic(err) } noIdUser := new(NoIdUser) has, err = engine.Where("`"+userCol+"` = ?", "xlw").Get(noIdUser) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New("get not returned 1") t.Error(err) panic(err) } fmt.Println(noIdUser) }
func testTime(engine *xorm.Engine, t *testing.T) { err := engine.Sync(&TTime{}) if err != nil { t.Error(err) panic(err) } tt := &TTime{} println("b4 Insert tt:", tt.String()) _, err = engine.Insert(tt) println("after Insert tt:", tt.String()) if err != nil { t.Error(err) panic(err) } tt2 := &TTime{Id: tt.Id} println("b4 Get tt2:", tt2.String()) has, err := engine.Get(tt2) println("after Get tt2:", tt2.String()) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New("no record error") t.Error(err) panic(err) } tt3 := &TTime{T: time.Now(), Tz: time.Now()} println("b4 Insert tt3:", tt3.String()) _, err = engine.Insert(tt3) println("after Insert tt3:", tt3.String()) if err != nil { t.Error(err) panic(err) } tt4s := make([]TTime, 0) println("b4 Insert tt4s:", tt4s) err = engine.Find(&tt4s) println("after Insert tt4s:", tt4s) if err != nil { t.Error(err) panic(err) } fmt.Println("=======\n", tt4s, "=======\n") }
func renamePullRequestFields(x *xorm.Engine) (err error) { type PullRequest struct { ID int64 `xorm:"pk autoincr"` PullID int64 `xorm:"INDEX"` PullIndex int64 HeadBarcnh string IssueID int64 `xorm:"INDEX"` Index int64 HeadBranch string } if err = x.Sync(new(PullRequest)); err != nil { return fmt.Errorf("sync: %v", err) } results, err := x.Query("SELECT `id`,`pull_id`,`pull_index`,`head_barcnh` FROM `pull_request`") if err != nil { if strings.Contains(err.Error(), "no such column") { return nil } return fmt.Errorf("select pull requests: %v", err) } sess := x.NewSession() defer sessionRelease(sess) if err = sess.Begin(); err != nil { return err } var pull *PullRequest for _, pr := range results { pull = &PullRequest{ ID: com.StrTo(pr["id"]).MustInt64(), IssueID: com.StrTo(pr["pull_id"]).MustInt64(), Index: com.StrTo(pr["pull_index"]).MustInt64(), HeadBranch: string(pr["head_barcnh"]), } if pull.Index == 0 { continue } if _, err = sess.Id(pull.ID).Update(pull); err != nil { return err } } return sess.Commit() }
// 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 accessToCollaboration(x *xorm.Engine) (err error) { type Collaboration struct { ID int64 `xorm:"pk autoincr"` RepoID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"` UserID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"` Created time.Time } if err = x.Sync(new(Collaboration)); err != nil { return fmt.Errorf("sync: %v", err) } results, err := x.Query("SELECT u.id AS `uid`, a.repo_name AS `repo`, a.mode AS `mode`, a.created as `created` FROM `access` a JOIN `user` u ON a.user_name=u.lower_name") if err != nil { if strings.Contains(err.Error(), "no such column") { return nil } return err } sess := x.NewSession() defer sessionRelease(sess) if err = sess.Begin(); err != nil { return err } offset := strings.Split(time.Now().String(), " ")[2] for _, result := range results { mode := com.StrTo(result["mode"]).MustInt64() // Collaborators must have write access. if mode < 2 { continue } userID := com.StrTo(result["uid"]).MustInt64() repoRefName := string(result["repo"]) var created time.Time switch { case setting.UseSQLite3: created, _ = time.Parse(time.RFC3339, string(result["created"])) case setting.UseMySQL: created, _ = time.Parse("2006-01-02 15:04:05-0700", string(result["created"])+offset) case setting.UsePostgreSQL: created, _ = time.Parse("2006-01-02T15:04:05Z-0700", string(result["created"])+offset) } // find owner of repository parts := strings.SplitN(repoRefName, "/", 2) ownerName := parts[0] repoName := parts[1] results, err := sess.Query("SELECT u.id as `uid`, ou.uid as `memberid` FROM `user` u LEFT JOIN org_user ou ON ou.org_id=u.id WHERE u.lower_name=?", ownerName) if err != nil { return err } if len(results) < 1 { continue } ownerID := com.StrTo(results[0]["uid"]).MustInt64() if ownerID == userID { continue } // test if user is member of owning organization isMember := false for _, member := range results { memberID := com.StrTo(member["memberid"]).MustInt64() // We can skip all cases that a user is member of the owning organization if memberID == userID { isMember = true } } if isMember { continue } results, err = sess.Query("SELECT id FROM `repository` WHERE owner_id=? AND lower_name=?", ownerID, repoName) if err != nil { return err } else if len(results) < 1 { continue } collaboration := &Collaboration{ UserID: userID, RepoID: com.StrTo(results[0]["id"]).MustInt64(), } has, err := sess.Get(collaboration) if err != nil { return err } else if has { continue } collaboration.Created = created if _, err = sess.InsertOne(collaboration); err != nil { return err } } return sess.Commit() }
func updateSameMapper(engine *xorm.Engine, t *testing.T) { var ori Userinfo has, err := engine.Get(&ori) if err != nil { t.Error(err) panic(err) } if !has { t.Error(errors.New("not exist")) panic(errors.New("not exist")) } // update by id user := Userinfo{Username: "******", Height: 1.2} cnt, err := engine.Id(ori.Uid).Update(&user) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("update not returned 1") t.Error(err) panic(err) return } condi := Condi{"Username": "******", "Departname": ""} cnt, err = engine.Table(&user).Id(ori.Uid).Update(&condi) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("update not returned 1") t.Error(err) panic(err) return } cnt, err = engine.Update(&Userinfo{Username: "******"}, &user) if err != nil { t.Error(err) panic(err) } total, err := engine.Count(&user) if err != nil { t.Error(err) panic(err) } if cnt != total { err = errors.New("insert not returned 1") t.Error(err) panic(err) return } err = engine.Sync(&Article{}) if err != nil { t.Error(err) panic(err) } defer func() { err = engine.DropTables(&Article{}) if err != nil { t.Error(err) panic(err) } }() a := &Article{0, "1", "2", "3", "4", "5", 2} cnt, err = engine.Insert(a) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) t.Error(err) panic(err) } if a.Id == 0 { err = errors.New("insert returned id is 0") t.Error(err) panic(err) } cnt, err = engine.Id(a.Id).Update(&Article{Name: "6"}) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) t.Error(err) panic(err) return } col1 := &UpdateAllCols{} err = engine.Sync(col1) if err != nil { t.Error(err) panic(err) } _, err = engine.Insert(col1) if err != nil { t.Error(err) panic(err) } col2 := &UpdateAllCols{col1.Id, true, "", nil} _, err = engine.Id(col2.Id).AllCols().Update(col2) if err != nil { t.Error(err) panic(err) } col3 := &UpdateAllCols{} has, err = engine.Id(col2.Id).Get(col3) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) t.Error(err) panic(err) return } if *col2 != *col3 { err = errors.New(fmt.Sprintf("col2 should eq col3")) t.Error(err) panic(err) return } { col1 := &UpdateMustCols{} err = engine.Sync(col1) if err != nil { t.Error(err) panic(err) } _, err = engine.Insert(col1) if err != nil { t.Error(err) panic(err) } col2 := &UpdateMustCols{col1.Id, true, ""} boolStr := engine.ColumnMapper.Obj2Table("Bool") stringStr := engine.ColumnMapper.Obj2Table("String") _, err = engine.Id(col2.Id).MustCols(boolStr, stringStr).Update(col2) if err != nil { t.Error(err) panic(err) } col3 := &UpdateMustCols{} has, err := engine.Id(col2.Id).Get(col3) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) t.Error(err) panic(err) return } if *col2 != *col3 { err = errors.New(fmt.Sprintf("col2 should eq col3")) t.Error(err) panic(err) return } } { col1 := &UpdateIncr{} err = engine.Sync(col1) if err != nil { t.Error(err) panic(err) } _, err = engine.Insert(col1) if err != nil { t.Error(err) panic(err) } cnt, err := engine.Id(col1.Id).Incr("`Cnt`").Update(col1) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("update incr failed") t.Error(err) panic(err) } newCol := new(UpdateIncr) has, err := engine.Id(col1.Id).Get(newCol) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New("has incr failed") t.Error(err) panic(err) } if 1 != newCol.Cnt { err = errors.New("incr failed") t.Error(err) panic(err) } } }
func update(engine *xorm.Engine, t *testing.T) { var ori Userinfo has, err := engine.Get(&ori) if err != nil { t.Error(err) panic(err) } if !has { t.Error(errors.New("not exist")) panic(errors.New("not exist")) } // update by id user := Userinfo{Username: "******", Height: 1.2} cnt, err := engine.Id(ori.Uid).Update(&user) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("update not returned 1") t.Error(err) panic(err) return } condi := Condi{"username": "******", "departname": ""} cnt, err = engine.Table(&user).Id(ori.Uid).Update(&condi) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("update not returned 1") t.Error(err) panic(err) return } cnt, err = engine.Update(&Userinfo{Username: "******"}, &user) if err != nil { t.Error(err) panic(err) } total, err := engine.Count(&user) if err != nil { t.Error(err) panic(err) } if cnt != total { err = errors.New("insert not returned 1") t.Error(err) panic(err) return } // nullable update { user := &Userinfo{Username: "******", Height: 180.5} _, err := engine.Insert(user) if err != nil { t.Error(err) panic(err) } userID := user.Uid has, err := engine.Id(userID). And("username = ?", user.Username). And("height = ?", user.Height). And("departname = ?", ""). And("detail_id = ?", 0). And("is_man = ?", 0). And("created IS NOT NULL"). Get(&Userinfo{}) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New("cannot insert properly") t.Error(err) panic(err) } updatedUser := &Userinfo{Username: "******"} cnt, err = engine.Id(userID). Nullable("height", "departname", "is_man", "created"). Update(updatedUser) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("update not returned 1") t.Error(err) panic(err) } has, err = engine.Id(userID). And("username = ?", updatedUser.Username). And("height IS NULL"). And("departname IS NULL"). And("is_man IS NULL"). And("created IS NULL"). And("detail_id = ?", 0). Get(&Userinfo{}) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New("cannot update with null properly") t.Error(err) panic(err) } cnt, err = engine.Id(userID).Delete(&Userinfo{}) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("delete not returned 1") t.Error(err) panic(err) } } err = engine.StoreEngine("Innodb").Sync2(&Article{}) if err != nil { t.Error(err) panic(err) } defer func() { err = engine.DropTables(&Article{}) if err != nil { t.Error(err) panic(err) } }() a := &Article{0, "1", "2", "3", "4", "5", 2} cnt, err = engine.Insert(a) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) t.Error(err) panic(err) } if a.Id == 0 { err = errors.New("insert returned id is 0") t.Error(err) panic(err) } cnt, err = engine.Id(a.Id).Update(&Article{Name: "6"}) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) t.Error(err) panic(err) return } var s = "test" col1 := &UpdateAllCols{Ptr: &s} err = engine.Sync(col1) if err != nil { t.Error(err) panic(err) } _, err = engine.Insert(col1) if err != nil { t.Error(err) panic(err) } col2 := &UpdateAllCols{col1.Id, true, "", nil} _, err = engine.Id(col2.Id).AllCols().Update(col2) if err != nil { t.Error(err) panic(err) } col3 := &UpdateAllCols{} has, err = engine.Id(col2.Id).Get(col3) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) t.Error(err) panic(err) return } if *col2 != *col3 { err = errors.New(fmt.Sprintf("col2 should eq col3")) t.Error(err) panic(err) return } { col1 := &UpdateMustCols{} err = engine.Sync(col1) if err != nil { t.Error(err) panic(err) } _, err = engine.Insert(col1) if err != nil { t.Error(err) panic(err) } col2 := &UpdateMustCols{col1.Id, true, ""} boolStr := engine.ColumnMapper.Obj2Table("Bool") stringStr := engine.ColumnMapper.Obj2Table("String") _, err = engine.Id(col2.Id).MustCols(boolStr, stringStr).Update(col2) if err != nil { t.Error(err) panic(err) } col3 := &UpdateMustCols{} has, err := engine.Id(col2.Id).Get(col3) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) t.Error(err) panic(err) return } if *col2 != *col3 { err = errors.New(fmt.Sprintf("col2 should eq col3")) t.Error(err) panic(err) return } } { col1 := &UpdateIncr{} err = engine.Sync(col1) if err != nil { t.Error(err) panic(err) } _, err = engine.Insert(col1) if err != nil { t.Error(err) panic(err) } cnt, err := engine.Id(col1.Id).Incr("cnt").Update(col1) if err != nil { t.Error(err) panic(err) } if cnt != 1 { err = errors.New("update incr failed") t.Error(err) panic(err) } newCol := new(UpdateIncr) has, err := engine.Id(col1.Id).Get(newCol) if err != nil { t.Error(err) panic(err) } if !has { err = errors.New("has incr failed") t.Error(err) panic(err) } if 1 != newCol.Cnt { err = fmt.Errorf("incr failed %v %v %v", newCol.Cnt, newCol, col1) t.Error(err) panic(err) } } testUpdateUpdated(engine, t) }
func directCreateTable(engine *xorm.Engine, t *testing.T) { err := engine.DropTables(&Userinfo{}, &Userdetail{}, &Numeric{}) if err != nil { t.Error(err) panic(err) } err = engine.Sync(&Userinfo{}, &Userdetail{}, new(Picture), new(Numeric)) if err != nil { t.Error(err) panic(err) } isEmpty, err := engine.IsTableEmpty(&Userinfo{}) if err != nil { t.Error(err) panic(err) } if !isEmpty { err = errors.New("userinfo should empty") t.Error(err) panic(err) } tbName := engine.TableMapper.Obj2Table("Userinfo") isEmpty, err = engine.IsTableEmpty(tbName) if err != nil { t.Error(err) panic(err) } if !isEmpty { err = errors.New("userinfo should empty") t.Error(err) panic(err) } err = engine.DropTables(&Userinfo{}, &Userdetail{}, new(Numeric)) if err != nil { t.Error(err) panic(err) } err = engine.CreateTables(&Userinfo{}, &Userdetail{}, new(Numeric)) if err != nil { t.Error(err) panic(err) } err = engine.CreateIndexes(&Userinfo{}) if err != nil { t.Error(err) panic(err) } err = engine.CreateIndexes(&Userdetail{}) if err != nil { t.Error(err) panic(err) } err = engine.CreateUniques(&Userinfo{}) if err != nil { t.Error(err) panic(err) } err = engine.CreateUniques(&Userdetail{}) if err != nil { t.Error(err) panic(err) } }
func sync(engine *xorm.Engine) error { return engine.Sync(&SyncLoginInfo2{}, &SyncUser2{}) }
func testConversion(engine *xorm.Engine, t *testing.T) { c := new(ConvStruct) err := engine.DropTables(c) if err != nil { t.Error(err) panic(err) } err = engine.Sync(c) if err != nil { t.Error(err) panic(err) } var s ConvString = "sssss" c.Conv = "tttt" c.Conv2 = &s c.Cfg1 = ConvConfig{"mm", 1} c.Cfg2 = &ConvConfig{"xx", 2} c.Cfg3 = &ConvConfig{"zz", 3} c.Slice = []*ConvConfig{{"yy", 4}, {"ff", 5}} _, err = engine.Insert(c) if err != nil { t.Error(err) panic(err) } c1 := new(ConvStruct) _, err = engine.Get(c1) if err != nil { t.Error(err) panic(err) } if string(c1.Conv) != "prefix---tttt" { err = fmt.Errorf("get conversion error prefix---tttt != %s", c1.Conv) t.Error(err) panic(err) } if c1.Conv2 == nil || *c1.Conv2 != "prefix---"+s { err = fmt.Errorf("get conversion error2, %v", *c1.Conv2) t.Error(err) panic(err) } if c1.Cfg1 != c.Cfg1 { err = fmt.Errorf("get conversion error3, %v", c1.Cfg1) t.Error(err) panic(err) } if c1.Cfg2 == nil || *c1.Cfg2 != *c.Cfg2 { err = fmt.Errorf("get conversion error4, %v", *c1.Cfg2) t.Error(err) panic(err) } if c1.Cfg3 == nil || *c1.Cfg3.(*ConvConfig) != *c.Cfg3.(*ConvConfig) { err = fmt.Errorf("get conversion error5, %v", *c1.Cfg3.(*ConvConfig)) t.Error(err) panic(err) } if len(c1.Slice) != 2 { err = fmt.Errorf("get conversion error6, should be 2") t.Error(err) panic(err) } if *c1.Slice[0] != *c.Slice[0] || *c1.Slice[1] != *c.Slice[1] { err = fmt.Errorf("get conversion error7, should be %v", c1.Slice) t.Error(err) panic(err) } }