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
}
func test(engine *xorm.Engine) {
err := engine.CreateTables(u)
if err != nil {
fmt.Println(err)
return
}
engine.ShowSQL = true
engine.SetMaxOpenConns(5)
size := 1000
queue := make(chan int, size)
for i := 0; i < size; i++ {
go func(x int) {
//x := i
err := engine.Ping()
if err != nil {
fmt.Println(err)
} else {
/*err = engine.Map(u)
if err != nil {
fmt.Println("Map user failed")
} else {*/
for j := 0; j < 10; j++ {
if x+j < 2 {
_, err = engine.Get(u)
} else if x+j < 4 {
users := make([]User, 0)
err = engine.Find(&users)
} else if x+j < 8 {
_, err = engine.Count(u)
} else if x+j < 16 {
_, err = engine.Insert(&User{Name: "xlw"})
} else if x+j < 32 {
_, err = engine.Id(1).Delete(u)
}
if err != nil {
fmt.Println(err)
queue <- x
return
}
}
fmt.Printf("%v success!\n", x)
//}
}
queue <- x
}(i)
}
for i := 0; i < size; i++ {
<-queue
}
fmt.Println("end")
}
func test(engine *xorm.Engine) {
err := engine.CreateTables(u)
if err != nil {
fmt.Println(err)
return
}
size := 100
queue := make(chan int, size)
for i := 0; i < size; i++ {
go func(x int) {
//x := i
err := engine.Ping()
if err != nil {
fmt.Println(err)
} else {
/*err = engine.(u)
if err != nil {
fmt.Println("Map user failed")
} else {*/
for j := 0; j < 10; j++ {
if x+j < 2 {
_, err = engine.Get(u)
} else if x+j < 4 {
users := make([]User, 0)
err = engine.Find(&users)
} else if x+j < 8 {
_, err = engine.Count(u)
} else if x+j < 16 {
_, err = engine.Insert(&User{Name: "xlw"})
} else if x+j < 32 {
_, err = engine.Id(1).Delete(u)
}
if err != nil {
fmt.Println(err)
queue <- x
return
}
}
fmt.Printf("%v success!\n", x)
//}
}
queue <- x
}(i)
}
for i := 0; i < size; i++ {
<-queue
}
//conns := atomic.LoadInt32(&xorm.ConnectionNum)
//fmt.Println("connection number:", conns)
fmt.Println("end")
}
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 Find(userId int) User {
var h *xorm.Engine
h = hoge.GetDBShardConnection("user", 1)
// データをselect
var user = User{Id: userId}
_, err := h.Get(&user)
//var user User
//_, err := h.Id(userId).Get(&user)
checkErr(err, "not found data!")
return user
}
// 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
}
func cleanUpMigrateRepoInfo(x *xorm.Engine) (err error) {
type (
User struct {
ID int64 `xorm:"pk autoincr"`
LowerName string
}
Repository struct {
ID int64 `xorm:"pk autoincr"`
OwnerID int64
LowerName string
}
)
repos := make([]*Repository, 0, 25)
if err = x.Where("is_mirror=?", false).Find(&repos); err != nil {
return fmt.Errorf("select all non-mirror repositories: %v", err)
}
var user *User
for _, repo := range repos {
user = &User{ID: repo.OwnerID}
has, err := x.Get(user)
if err != nil {
return fmt.Errorf("get owner of repository[%d - %d]: %v", repo.ID, repo.OwnerID, err)
} else if !has {
continue
}
configPath := filepath.Join(setting.RepoRootPath, user.LowerName, repo.LowerName+".git/config")
// In case repository file is somehow missing.
if !com.IsFile(configPath) {
continue
}
cfg, err := ini.Load(configPath)
if err != nil {
return fmt.Errorf("open config file: %v", err)
}
cfg.DeleteSection("remote \"origin\"")
if err = cfg.SaveToIndent(configPath, "\t"); err != nil {
return fmt.Errorf("save config file: %v", 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 testIntId(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&IntId{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&IntId{})
if err != nil {
t.Error(err)
panic(err)
}
cnt, err := engine.Insert(&IntId{Name: "test"})
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert count should be one")
t.Error(err)
panic(err)
}
bean := new(IntId)
has, err := engine.Get(bean)
if err != nil {
t.Error(err)
panic(err)
}
if !has {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
beans := make([]IntId, 0)
err = engine.Find(&beans)
if err != nil {
t.Error(err)
panic(err)
}
if len(beans) != 1 {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
beans2 := make(map[int]IntId)
err = engine.Find(&beans2)
if err != nil {
t.Error(err)
panic(err)
}
if len(beans2) != 1 {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
cnt, err = engine.Id(bean.Id).Delete(&IntId{})
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert count should be one")
t.Error(err)
panic(err)
}
}
func testUint64Id(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&Uint64Id{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&Uint64Id{})
if err != nil {
t.Error(err)
panic(err)
}
idbean := &Uint64Id{Name: "test"}
cnt, err := engine.Insert(idbean)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert count should be one")
t.Error(err)
panic(err)
}
bean := new(Uint64Id)
has, err := engine.Get(bean)
if err != nil {
t.Error(err)
panic(err)
}
if !has {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
if bean.Id != idbean.Id {
panic(errors.New("should be equal"))
}
beans := make([]Uint64Id, 0)
err = engine.Find(&beans)
if err != nil {
t.Error(err)
panic(err)
}
if len(beans) != 1 {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
if *bean != beans[0] {
panic(errors.New("should be equal"))
}
beans2 := make(map[uint64]Uint64Id, 0)
err = engine.Find(&beans2)
if err != nil {
t.Error(err)
panic(err)
}
if len(beans2) != 1 {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
if *bean != beans2[bean.Id] {
panic(errors.New("should be equal"))
}
cnt, err = engine.Id(bean.Id).Delete(&Uint64Id{})
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert count should be one")
t.Error(err)
panic(err)
}
}
func testExtends(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&tempUser2{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&tempUser2{})
if err != nil {
t.Error(err)
panic(err)
}
tu := &tempUser2{tempUser{0, "extends"}, "dev depart"}
_, err = engine.Insert(tu)
if err != nil {
t.Error(err)
panic(err)
}
tu2 := &tempUser2{}
_, err = engine.Get(tu2)
if err != nil {
t.Error(err)
panic(err)
}
tu3 := &tempUser2{tempUser{0, "extends update"}, ""}
_, err = engine.Id(tu2.Id).Update(tu3)
if err != nil {
t.Error(err)
panic(err)
}
err = engine.DropTables(&tempUser3{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&tempUser3{})
if err != nil {
t.Error(err)
panic(err)
}
tu4 := &tempUser3{&tempUser{0, "extends"}, "dev depart"}
_, err = engine.Insert(tu4)
if err != nil {
t.Error(err)
panic(err)
}
tu5 := &tempUser3{}
_, err = engine.Get(tu5)
if err != nil {
t.Error(err)
panic(err)
}
if tu5.Temp == nil {
err = errors.New("error get data extends")
t.Error(err)
panic(err)
}
if tu5.Temp.Id != 1 || tu5.Temp.Username != "extends" ||
tu5.Departname != "dev depart" {
err = errors.New("error get data extends")
t.Error(err)
panic(err)
}
tu6 := &tempUser3{&tempUser{0, "extends update"}, ""}
_, err = engine.Id(tu5.Temp.Id).Update(tu6)
if err != nil {
t.Error(err)
panic(err)
}
users := make([]tempUser3, 0)
err = engine.Find(&users)
if err != nil {
t.Error(err)
panic(err)
}
if len(users) != 1 {
err = errors.New("error get data not 1")
t.Error(err)
panic(err)
}
var info UserAndDetail
qt := engine.Quote
engine.Update(&Userinfo{Detail: Userdetail{Id: 1}})
ui := engine.TableMapper.Obj2Table("Userinfo")
ud := engine.TableMapper.Obj2Table("Userdetail")
uiid := engine.TableMapper.Obj2Table("Id")
udid := "detail_id"
sql := fmt.Sprintf("select * from %s, %s where %s.%s = %s.%s",
qt(ui), qt(ud), qt(ui), qt(udid), qt(ud), qt(uiid))
b, err := engine.Sql(sql).Get(&info)
if err != nil {
t.Error(err)
panic(err)
}
if !b {
err = errors.New("should has lest one record")
t.Error(err)
panic(err)
}
if info.Userinfo.Uid == 0 || info.Userdetail.Id == 0 {
err = errors.New("all of the id should has value")
t.Error(err)
panic(err)
}
fmt.Println(info)
fmt.Println("----join--info2")
var info2 UserAndDetail
b, err = engine.Table(&Userinfo{}).Join("LEFT", qt(ud), qt(ui)+"."+qt("detail_id")+" = "+qt(ud)+"."+qt(uiid)).Get(&info2)
if err != nil {
t.Error(err)
panic(err)
}
if !b {
err = errors.New("should has lest one record")
t.Error(err)
panic(err)
}
if info2.Userinfo.Uid == 0 || info2.Userdetail.Id == 0 {
err = errors.New("all of the id should has value")
t.Error(err)
panic(err)
}
fmt.Println(info2)
fmt.Println("----join--infos2")
var infos2 = make([]UserAndDetail, 0)
err = engine.Table(&Userinfo{}).Join("LEFT", qt(ud), qt(ui)+"."+qt("detail_id")+" = "+qt(ud)+"."+qt(uiid)).Find(&infos2)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(infos2)
}
func testCustomType1(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&MyStruct{})
if err != nil {
t.Error(err)
panic(err)
return
}
err = engine.CreateTables(&MyStruct{})
i := MyStruct{Name: "Test", Type: MyInt(1)}
i.U = 23
i.F = 1.34
i.S = "fafdsafdsaf"
i.UI = 2
i.IA = []MyInt{1, 3, 5}
i.UIA = []uint{1, 3}
i.UIA16 = []uint16{2}
i.UIA32 = []uint32{4, 5}
i.UIA64 = []uint64{6, 7, 9}
i.UIA8 = []uint8{1, 2, 3, 4}
i.NameArray = []string{"ssss", "fsdf", "lllll, ss"}
i.MSS = map[string]string{"s": "sfds,ss", "x": "lfjljsl"}
cnt, err := engine.Insert(&i)
if err != nil {
t.Error(err)
panic(err)
return
}
if cnt != 1 {
err = errors.New("insert not returned 1")
t.Error(err)
panic(err)
return
}
fmt.Println(i)
i.NameArray = []string{}
i.MSS = map[string]string{}
i.F = 0
has, err := engine.Get(&i)
if err != nil {
t.Error(err)
panic(err)
} else if !has {
t.Error(errors.New("should get one record"))
panic(err)
}
ss := []MyStruct{}
err = engine.Find(&ss)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(ss)
sss := MyStruct{}
has, err = engine.Get(&sss)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(sss)
if has {
sss.NameArray = []string{}
sss.MSS = map[string]string{}
cnt, err := engine.Delete(&sss)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
t.Error(errors.New("delete error"))
panic(err)
}
}
}
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 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)
}
}
func testUintId(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&UintId{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&UintId{})
if err != nil {
t.Error(err)
panic(err)
}
cnt, err := engine.Insert(&UintId{Name: "test"})
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert count should be one")
t.Error(err)
panic(err)
}
var inserts = []UintId{
{Name: "test1"},
{Name: "test2"},
}
cnt, err = engine.Insert(&inserts)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 2 {
err = errors.New("insert count should be two")
t.Error(err)
panic(err)
}
bean := new(UintId)
has, err := engine.Get(bean)
if err != nil {
t.Error(err)
panic(err)
}
if !has {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
beans := make([]UintId, 0)
err = engine.Find(&beans)
if err != nil {
t.Error(err)
panic(err)
}
if len(beans) != 3 {
err = errors.New("get count should be three")
t.Error(err)
panic(err)
}
beans2 := make(map[uint]UintId, 0)
err = engine.Find(&beans2)
if err != nil {
t.Error(err)
panic(err)
}
if len(beans2) != 3 {
err = errors.New("get count should be three")
t.Error(err)
panic(err)
}
cnt, err = engine.Id(bean.Id).Delete(&UintId{})
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert count should be one")
t.Error(err)
panic(err)
}
}
func testStringPK(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&StringPK{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&StringPK{})
if err != nil {
t.Error(err)
panic(err)
}
cnt, err := engine.Insert(&StringPK{Id: "1-1-2", Name: "test"})
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert count should be one")
t.Error(err)
panic(err)
}
bean := new(StringPK)
has, err := engine.Get(bean)
if err != nil {
t.Error(err)
panic(err)
}
if !has {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
beans := make([]StringPK, 0)
err = engine.Find(&beans)
if err != nil {
t.Error(err)
panic(err)
}
if len(beans) != 1 {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
beans2 := make(map[string]StringPK)
err = engine.Find(&beans2)
if err != nil {
t.Error(err)
panic(err)
}
if len(beans2) != 1 {
err = errors.New("get count should be one")
t.Error(err)
panic(err)
}
cnt, err = engine.Id(bean.Id).Delete(&StringPK{})
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert count should be one")
t.Error(err)
panic(err)
}
}
func testColTypes(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&allCols{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&allCols{})
if err != nil {
t.Error(err)
panic(err)
}
ac := &allCols{
1,
4,
8,
16,
32,
64,
128,
"123",
"fafdafa",
"fafafafdsafdsafdaf",
"fdsafafdsafdsaf",
"fafdsafdsafdsfadasfsfafd",
"fadfdsafdsafasfdasfds",
[]byte("fdafsafdasfdsafsa"),
[]byte("fdsafsdafs"),
time.Now(),
time.Now(),
time.Now(),
time.Now(),
time.Now(),
1.34,
2.44302346,
1.3344,
2.59693523,
3.2342523543,
[]byte("fafdasf"),
[]byte("fafdfdsafdsafasf"),
[]byte("faffadsfdsdasf"),
[]byte("faffdasfdsadasf"),
[]byte("fafasdfsadffdasf"),
map[string]string{"1": "1", "2": "2"},
[]string{"1", "2", "3"},
true,
0,
//21,
}
cnt, err := engine.Insert(ac)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert return not 1")
t.Error(err)
panic(err)
}
newAc := &allCols{}
has, err := engine.Get(newAc)
if err != nil {
t.Error(err)
panic(err)
}
if !has {
err = errors.New("error no ideas")
t.Error(err)
panic(err)
}
// don't use this type as query condition
newAc.Real = 0
newAc.Float = 0
newAc.Double = 0
newAc.LongText = ""
newAc.TinyText = ""
newAc.MediumText = ""
newAc.Text = ""
newAc.Map = nil
newAc.Slice = nil
cnt, err = engine.Delete(newAc)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New(fmt.Sprintf("delete error, deleted counts is %v", cnt))
t.Error(err)
panic(err)
}
}
func TestNullStructFind(engine *xorm.Engine, t *testing.T) {
if true {
item := new(NullType)
has, err := engine.Id(1).Get(item)
if err != nil {
t.Error(err)
panic(err)
}
if !has {
t.Error(errors.New("no find id 1"))
panic(err)
}
fmt.Println(item)
if item.Id != 1 || item.Name.Valid || item.Age.Valid || item.Height.Valid ||
item.IsMan.Valid {
err = errors.New("insert error")
t.Error(err)
panic(err)
}
}
if true {
item := new(NullType)
item.Id = 2
has, err := engine.Get(item)
if err != nil {
t.Error(err)
panic(err)
}
if !has {
t.Error(errors.New("no find id 2"))
panic(err)
}
fmt.Println(item)
}
if true {
item := make([]NullType, 0)
err := engine.Id(2).Find(&item)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(item)
}
if true {
item := make([]NullType, 0)
err := engine.Asc("age").Find(&item)
if err != nil {
t.Error(err)
panic(err)
}
for k, v := range item {
fmt.Println(k, v)
}
}
}