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 DoBenchFindPtr(engine *xorm.Engine, b *testing.B) {
b.StopTimer()
bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
err := engine.CreateTables(bs)
if err != nil {
b.Error(err)
return
}
for i := 0; i < 100; i++ {
bs.Id = 0
_, err = engine.Insert(bs)
if err != nil {
b.Error(err)
return
}
}
b.StartTimer()
for i := 0; i < b.N/50; i++ {
bss := new([]*BigStruct)
err = engine.Limit(50).Find(bss)
if err != nil {
b.Error(err)
return
}
}
b.StopTimer()
err = engine.DropTables(bs)
if err != nil {
b.Error(err)
return
}
}
func limit(engine *xorm.Engine, t *testing.T) {
users := make([]Userinfo, 0)
err := engine.Limit(2, 1).Find(&users)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(users)
err = engine.DropTables(new(Limit))
if err != nil {
t.Error(err)
panic(err)
}
err = engine.Sync2(new(Limit))
if err != nil {
t.Error(err)
panic(err)
}
_, err = engine.Insert(&Limit{Name: "1"})
if err != nil {
t.Error(err)
panic(err)
}
// TODO: support limit for update
/*_, err = engine.Limit(1).Update(&Limit{Name: "2"})
if err != nil {
t.Error(err)
panic(err)
}*/
}
func testCreatedJsonTime(engine *xorm.Engine, t *testing.T) {
di5 := new(MyJsonTime)
err := engine.Sync2(di5)
if err != nil {
t.Fatal(err)
}
ci5 := &MyJsonTime{}
_, err = engine.Insert(ci5)
if err != nil {
t.Fatal(err)
}
has, err := engine.Desc("(id)").Get(di5)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(xorm.ErrNotExist)
}
if time.Time(ci5.Created).Unix() != time.Time(di5.Created).Unix() {
t.Fatal("should equal:", time.Time(ci5.Created).Unix(), time.Time(di5.Created).Unix())
}
fmt.Println("ci5:", ci5, "di5:", di5)
var dis = make([]MyJsonTime, 0)
err = engine.Find(&dis)
if err != nil {
t.Fatal(err)
}
}
func insert(engines *xorm.Engine, File *xlsx.Sheet) {
var num int = 0
if len(File.Rows) < 1 {
fmt.Println("检查更新列表.")
return
}
for _, row := range File.Rows[1:] {
var list []*xlsx.Cell
for _, cell := range row.Cells {
list = append(list, cell)
}
date := parse(list)
if date != nil {
b, err := engines.Where("IssuerId = ? and ServerID = ?", date.IssuerId, date.ServerID).Get(&NxServerState{})
if b {
fmt.Println(*date, " 已存在")
continue
}
n, err := engines.Insert(date)
if n == 0 || err != nil {
fmt.Printf("插入:%s出错.\n", fmt.Sprint(*date))
continue
}
engines.Query(fmt.Sprintf("UPDATE NxServerState SET ServerName=N'%s' where IssuerId = %d and ServerID = %d", date.ServerName, date.IssuerId, date.ServerID))
}
num++
}
fmt.Printf("一共插入%d条数据\n", num)
}
func DoBenchInsert(engine *xorm.Engine, b *testing.B) {
b.StopTimer()
bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
err := engine.CreateTables(bs)
if err != nil {
b.Error(err)
return
}
b.StartTimer()
for i := 0; i < b.N; i++ {
bs.Id = 0
_, err = engine.Insert(bs)
if err != nil {
b.Error(err)
return
}
}
b.StopTimer()
err = engine.DropTables(bs)
if err != nil {
b.Error(err)
return
}
}
func setupForUpdate(engine *xorm.Engine) error {
v := new(ForUpdate)
err := engine.DropTables(v)
if err != nil {
return err
}
err = engine.CreateTables(v)
if err != nil {
return err
}
list := []ForUpdate{
{1, "data1"},
{2, "data2"},
{3, "data3"},
}
for _, f := range list {
_, err = engine.Insert(f)
if err != nil {
return err
}
}
return nil
}
func insertTwoTable(engine *xorm.Engine, t *testing.T) {
userdetail := Userdetail{ /*Id: 1, */ Intro: "I'm a very beautiful women.", Profile: "sfsaf"}
userinfo := Userinfo{Username: "******", Departname: "dev", Alias: "lunny4", Created: time.Now(), Detail: userdetail}
cnt, err := engine.Insert(&userinfo, &userdetail)
if err != nil {
t.Error(err)
panic(err)
}
if userinfo.Uid <= 0 {
err = errors.New("not return id error")
t.Error(err)
panic(err)
}
if userdetail.Id <= 0 {
err = errors.New("not return id error")
t.Error(err)
panic(err)
}
if cnt != 2 {
err = errors.New("insert not returned 2")
t.Error(err)
panic(err)
return
}
}
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 PostGood(ctx *macaron.Context, x *xorm.Engine, g Goods) {
_, err := x.Insert(g)
if err != nil {
glog.V(1).Infof("Insert good %#v fail:%s", g, err.Error())
ctx.JSON(http.StatusBadRequest, map[string]string{"message": err.Error()})
}
ctx.JSON(http.StatusCreated, "SUCCESS")
return
}
func testCompositeKey2(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&User{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&User{})
if err != nil {
t.Error(err)
panic(err)
}
cnt, err := engine.Insert(&User{"11", "nick", 22, 5})
if err != nil {
t.Error(err)
} else if cnt != 1 {
t.Error(errors.New("failed to insert User{11, 22}"))
}
cnt, err = engine.Insert(&User{"11", "nick", 22, 6})
if err == nil || cnt == 1 {
t.Error(errors.New("inserted User{11, 22}"))
}
var user User
has, err := engine.Id(core.PK{"11", 22}).Get(&user)
if err != nil {
t.Error(err)
} else if !has {
t.Error(errors.New("can't get User{11, 22}"))
}
// test passing PK ptr, this test seem failed withCache
has, err = engine.Id(&core.PK{"11", 22}).Get(&user)
if err != nil {
t.Error(err)
} else if !has {
t.Error(errors.New("can't get User{11, 22}"))
}
user = User{NickName: "test1"}
cnt, err = engine.Id(core.PK{"11", 22}).Update(&user)
if err != nil {
t.Error(err)
} else if cnt != 1 {
t.Error(errors.New("can't update User{11, 22}"))
}
cnt, err = engine.Id(core.PK{"11", 22}).Delete(&User{})
if err != nil {
t.Error(err)
} else if cnt != 1 {
t.Error(errors.New("can't delete CompositeKey{11, 22}"))
}
}
func PostCustomer(ctx *macaron.Context, x *xorm.Engine, c Customer) {
_, err := x.Insert(c)
if err != nil {
glog.V(1).Infof("Insert customer %#v fail:%s", c, err.Error())
ctx.JSON(http.StatusBadRequest, map[string]string{"message": err.Error()})
}
ctx.JSON(http.StatusCreated, "SUCCESS")
return
}
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 testCreatedAndUpdated(engine *xorm.Engine, t *testing.T) {
u := new(UserCU)
err := engine.DropTables(u)
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(u)
if err != nil {
t.Error(err)
panic(err)
}
u.Name = "sss"
cnt, err := engine.Insert(u)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert not returned 1")
t.Error(err)
panic(err)
return
}
u.Name = "xxx"
cnt, err = engine.Id(u.Id).Update(u)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("update not returned 1")
t.Error(err)
panic(err)
return
}
u.Id = 0
u.Created = time.Now().Add(-time.Hour * 24 * 365)
u.Updated = u.Created
fmt.Println(u)
cnt, err = engine.NoAutoTime().Insert(u)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert not returned 1")
t.Error(err)
panic(err)
return
}
}
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 testJsonField(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&JsonField{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&JsonField{})
if err != nil {
t.Error(err)
panic(err)
}
js := &JsonField{
Name: map[string]string{
"test": "test",
"test2": "test2",
},
}
_, err = engine.Insert(js)
if err != nil {
t.Error(err)
panic(err)
}
var j JsonField
has, err := engine.Id(js.Id).Get(&j)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println("j:", j)
if !has {
err = errors.New("not exist")
t.Error(err)
panic(err)
}
var jss = make([]JsonField, 0)
err = engine.Find(&jss)
if err != nil {
t.Error(err)
panic(err)
}
if len(jss) == 0 {
err = errors.New("not exist")
t.Error(err)
panic(err)
}
fmt.Println("jss:", jss)
}
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 insertAutoIncr(engine *xorm.Engine, t *testing.T) {
// auto increment insert
user := Userinfo{Username: "******", Departname: "dev", Alias: "lunny", Created: time.Now(),
Detail: Userdetail{Id: 1}, Height: 1.78, Avatar: []byte{1, 2, 3}, IsMan: true}
cnt, err := engine.Insert(&user)
fmt.Println(user.Uid)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert not returned 1")
t.Error(err)
panic(err)
return
}
if user.Uid <= 0 {
t.Error(errors.New("not return id error"))
}
}
func PostOrder(ctx *macaron.Context, x *xorm.Engine, o Order) {
alipaytype := ctx.Params("alipaytype")
_, err := x.Insert(o)
if err != nil {
glog.V(1).Infof("Insert order %#v fail:%s", o, err.Error())
ctx.JSON(http.StatusBadRequest, map[string]string{"message": err.Error()})
}
//after saved to db,we call alipay and submit to alipay
outhtml, outscript := alipay.Form(o, alipaytype)
ob := map[string]string{"html": outhtml, "script": outscript}
ctx.Resp.Header().Set("Content-Type", "application/json")
js, _ := json.Marshal(ob)
ctx.Resp.WriteHeader(http.StatusOK)
ctx.Resp.Write([]byte(js))
return
}
func TestNullStructInsert(engine *xorm.Engine, t *testing.T) {
if true {
item := new(NullType)
_, err := engine.Insert(item)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(item)
if item.Id != 1 {
err = errors.New("insert error")
t.Error(err)
panic(err)
}
}
if true {
item := NullType{
Name: sql.NullString{"haolei", true},
Age: sql.NullInt64{34, true},
Height: sql.NullFloat64{1.72, true},
IsMan: sql.NullBool{true, true},
}
_, err := engine.Insert(&item)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(item)
if item.Id != 2 {
err = errors.New("insert error")
t.Error(err)
panic(err)
}
}
if true {
items := []NullType{}
for i := 0; i < 5; i++ {
item := NullType{
Name: sql.NullString{"haolei_" + fmt.Sprint(i+1), true},
Age: sql.NullInt64{30 + int64(i), true},
Height: sql.NullFloat64{1.5 + 1.1*float64(i), true},
IsMan: sql.NullBool{true, true},
CustomStruct: CustomStruct{i, i + 1, i + 2},
}
items = append(items, item)
}
_, err := engine.Insert(&items)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(items)
}
}
func testStrangeName(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(new(StrangeName))
if err != nil {
t.Error(err)
}
err = engine.CreateTables(new(StrangeName))
if err != nil {
t.Error(err)
}
_, err = engine.Insert(&StrangeName{Name: "sfsfdsfds"})
if err != nil {
t.Error(err)
}
beans := make([]StrangeName, 0)
err = engine.Find(&beans)
if err != nil {
t.Error(err)
}
}
func insertMulti(engine *xorm.Engine, t *testing.T) {
users := []Userinfo{
{Username: "******", Departname: "dev", Alias: "lunny2", Created: time.Now()},
{Username: "******", Departname: "dev", Alias: "lunny3", Created: time.Now()},
{Username: "******", Departname: "dev", Alias: "lunny2", Created: time.Now()},
{Username: "******", Departname: "dev", Alias: "lunny3", Created: time.Now()},
}
cnt, err := engine.Insert(&users)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != int64(len(users)) {
err = errors.New("insert not returned 1")
t.Error(err)
panic(err)
return
}
users2 := []*Userinfo{
&Userinfo{Username: "******", Departname: "dev", Alias: "lunny2", Created: time.Now()},
&Userinfo{Username: "******", Departname: "dev", Alias: "lunny3", Created: time.Now()},
&Userinfo{Username: "******", Departname: "dev", Alias: "lunny2", Created: time.Now()},
&Userinfo{Username: "******", Departname: "dev", Alias: "lunny3", Created: time.Now()},
}
cnt, err = engine.Insert(&users2)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != int64(len(users2)) {
err = errors.New(fmt.Sprintf("insert not returned %v", len(users2)))
t.Error(err)
panic(err)
return
}
}
func insert(engine *xorm.Engine, t *testing.T) {
user := Userinfo{0, "xiaolunwen", "dev", "lunny", time.Now(),
Userdetail{Id: 1}, 1.78, []byte{1, 2, 3}, true}
cnt, err := engine.Insert(&user)
fmt.Println(user.Uid)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("insert not returned 1")
t.Error(err)
panic(err)
return
}
if user.Uid <= 0 {
err = errors.New("not return id error")
t.Error(err)
panic(err)
}
user.Uid = 0
cnt, err = engine.Insert(&user)
if err == nil {
err = errors.New("insert failed but no return error")
t.Error(err)
panic(err)
}
if cnt != 0 {
err = errors.New("insert not returned 1")
t.Error(err)
panic(err)
return
}
testInsertCreated(engine, t)
testCreatedJsonTime(engine, t)
}
func testCustomType2(engine *xorm.Engine, t *testing.T) {
err := engine.CreateTables(&UserCus{})
if err != nil {
t.Fatal(err)
}
engine.Exec("TRUNCATE TABLE " + engine.TableMapper.Obj2Table("UserCus"))
_, err = engine.Insert(&UserCus{1, "xlw", Registed})
if err != nil {
t.Fatal(err)
}
user := UserCus{}
exist, err := engine.Id(1).Get(&user)
if err != nil {
t.Fatal(err)
}
if !exist {
t.Fatal("user not exist")
}
fmt.Println(user)
users := make([]UserCus, 0)
err = engine.Where("`"+engine.ColumnMapper.Obj2Table("Status")+"` = ?", "Registed").Find(&users)
if err != nil {
t.Error(err)
panic(err)
}
if len(users) != 1 {
t.Error("users should has 1 record.")
panic("")
}
fmt.Println(users)
}
// new site init data
func NewSiteInitData(engine *xorm.Engine) {
// default user
user := &model.User{
Name: "admin",
Nick: "admin",
Email: "*****@*****.**",
Url: "#",
AvatarUrl: utils.GravatarLink("*****@*****.**"),
Profile: "this is an administrator",
Role: model.USER_ROLE_ADMIN,
Status: model.USER_STATUS_ACTIVE,
}
user.Salt = utils.Md5String("123456789")[8:24]
user.Password = utils.Sha256String("123456789" + user.Salt)
if _, err := engine.Insert(user); err != nil {
log.Error("NewSite | %s", err.Error())
return
}
// default article
article := &model.Article{
Title: "Welcome to Purine",
Link: "welcome-to-purine",
Preview: blogPreview,
Body: blogContent,
TagString: "blog",
Hits: 1,
Comments: 0,
Status: model.ARTICLE_STATUS_PUBLISH,
CommentStatus: model.ARTICLE_COMMENT_OPEN,
AuthorId: user.Id,
}
if _, err := engine.Insert(article); err != nil {
log.Error("NewSite | %s", err.Error())
return
}
// default settings
settings := make([]interface{}, 0)
settings = append(settings, &model.Setting{"title", "Purine", 0})
settings = append(settings, &model.Setting{"subtitle", "a simple blog engine", 0})
settings = append(settings, &model.Setting{"desc", "a simple blog engine by golang", 0})
settings = append(settings, &model.Setting{"keyword", "purine,blog,golang", 0})
settings = append(settings, &model.Setting{"theme", "default", 0})
settings = append(settings, &model.Setting{"baseurl", "http://localhost:9999/", 0})
settings = append(settings, &model.Setting{"media_imageext", ".jpg,.jpeg,.png,.gif", 0})
settings = append(settings, &model.Setting{"media_fileext", ".txt,.zip,.doc,.xls,.ppt,.pdf", 0})
settings = append(settings, &model.Setting{"media_nameformat", ":hash", 0})
settings = append(settings, &model.Setting{"media_maxsize", strconv.Itoa(2 * 1024 * 1024), 0})
if _, err := engine.Insert(settings...); err != nil {
log.Error("NewSite | %s", err.Error())
return
}
}
func testCompositeKey(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&CompositeKey{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&CompositeKey{})
if err != nil {
t.Error(err)
panic(err)
}
cnt, err := engine.Insert(&CompositeKey{11, 22, ""})
if err != nil {
t.Error(err)
} else if cnt != 1 {
t.Error(errors.New("failed to insert CompositeKey{11, 22}"))
}
cnt, err = engine.Insert(&CompositeKey{11, 22, ""})
if err == nil || cnt == 1 {
t.Error(errors.New("inserted CompositeKey{11, 22}"))
}
var compositeKeyVal CompositeKey
has, err := engine.Id(core.PK{11, 22}).Get(&compositeKeyVal)
if err != nil {
t.Error(err)
} else if !has {
t.Error(errors.New("can't get CompositeKey{11, 22}"))
}
var compositeKeyVal2 CompositeKey
// test passing PK ptr, this test seem failed withCache
has, err = engine.Id(&core.PK{11, 22}).Get(&compositeKeyVal2)
if err != nil {
t.Error(err)
} else if !has {
t.Error(errors.New("can't get CompositeKey{11, 22}"))
}
if compositeKeyVal != compositeKeyVal2 {
t.Error(errors.New("should be equal"))
}
var cps = make([]CompositeKey, 0)
err = engine.Find(&cps)
if err != nil {
t.Error(err)
}
if len(cps) != 1 {
t.Error(errors.New("should has one record"))
}
if cps[0] != compositeKeyVal {
t.Error(errors.New("should be equal"))
}
cnt, err = engine.Insert(&CompositeKey{22, 22, ""})
if err != nil {
t.Error(err)
} else if cnt != 1 {
t.Error(errors.New("failed to insert CompositeKey{22, 22}"))
}
if engine.Cacher != nil {
engine.Cacher.ClearBeans(engine.TableInfo(compositeKeyVal).Name)
}
cps = make([]CompositeKey, 0)
err = engine.Find(&cps)
if err != nil {
t.Error(err)
}
if len(cps) != 2 {
t.Error(errors.New("should has two record"))
}
if cps[0] != compositeKeyVal {
t.Error(errors.New("should be equeal"))
}
compositeKeyVal = CompositeKey{UpdateStr: "test1"}
cnt, err = engine.Id(core.PK{11, 22}).Update(&compositeKeyVal)
if err != nil {
t.Error(err)
} else if cnt != 1 {
t.Error(errors.New("can't update CompositeKey{11, 22}"))
}
cnt, err = engine.Id(core.PK{11, 22}).Delete(&CompositeKey{})
if err != nil {
t.Error(err)
} else if cnt != 1 {
t.Error(errors.New("can't delete CompositeKey{11, 22}"))
}
}
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 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)
}
}