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 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 TestDropNullStructTable(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(new(NullType))
if err != nil {
t.Error(err)
panic(err)
}
}
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 testIndexAndUnique(engine *xorm.Engine, t *testing.T) {
err := engine.CreateTables(&IndexOrUnique{})
if err != nil {
t.Error(err)
//panic(err)
}
err = engine.DropTables(&IndexOrUnique{})
if err != nil {
t.Error(err)
//panic(err)
}
err = engine.CreateTables(&IndexOrUnique{})
if err != nil {
t.Error(err)
//panic(err)
}
err = engine.CreateIndexes(&IndexOrUnique{})
if err != nil {
t.Error(err)
//panic(err)
}
err = engine.CreateUniques(&IndexOrUnique{})
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 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 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 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 testCustomTableName(engine *xorm.Engine, t *testing.T) {
c := new(CustomTableName)
err := engine.DropTables(c)
if err != nil {
t.Error(err)
}
err = engine.CreateTables(c)
if err != nil {
t.Error(err)
}
}
func testStoreEngine(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables("user_store_engine")
if err != nil {
t.Error(err)
panic(err)
}
err = engine.StoreEngine("InnoDB").Table("user_store_engine").CreateTable(&Userinfo{})
if err != nil {
t.Error(err)
panic(err)
}
}
func table(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables("user_user")
if err != nil {
t.Error(err)
panic(err)
}
err = engine.Table("user_user").CreateTable(&Userinfo{})
if err != nil {
t.Error(err)
panic(err)
}
}
func testCharst(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables("user_charset")
if err != nil {
t.Error(err)
panic(err)
}
err = engine.Charset("utf8").Table("user_charset").CreateTable(&Userinfo{})
if err != nil {
t.Error(err)
panic(err)
}
}
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 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 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)
}
}
func testProcessorsTx(engine *xorm.Engine, t *testing.T) {
// tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName)
// if err != nil {
// t.Error(err)
// panic(err)
// }
// tempEngine.ShowSQL = true
err := engine.DropTables(&ProcessorsStruct{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&ProcessorsStruct{})
if err != nil {
t.Error(err)
panic(err)
}
// test insert processors with tx rollback
session := engine.NewSession()
err = session.Begin()
if err != nil {
t.Error(err)
panic(err)
}
p := &ProcessorsStruct{}
b4InsertFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4InsertViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
afterInsertFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterInsertedViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
_, err = session.Before(b4InsertFunc).After(afterInsertFunc).Insert(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p.AfterInsertedFlag != 0 {
t.Error(errors.New("B4InsertFlag is set"))
}
if p.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertViaExt not set"))
}
if p.AfterInsertedViaExt != 0 {
t.Error(errors.New("AfterInsertedViaExt is set"))
}
}
err = session.Rollback()
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p.AfterInsertedFlag != 0 {
t.Error(errors.New("B4InsertFlag is set"))
}
if p.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertViaExt not set"))
}
if p.AfterInsertedViaExt != 0 {
t.Error(errors.New("AfterInsertedViaExt is set"))
}
}
session.Close()
p2 := &ProcessorsStruct{}
_, err = engine.Id(p.Id).Get(p2)
if err != nil {
t.Error(err)
panic(err)
} else {
if p2.Id > 0 {
err = errors.New("tx got committed upon insert!?")
t.Error(err)
panic(err)
}
}
// --
// test insert processors with tx commit
session = engine.NewSession()
err = session.Begin()
if err != nil {
t.Error(err)
panic(err)
}
p = &ProcessorsStruct{}
_, err = session.Before(b4InsertFunc).After(afterInsertFunc).Insert(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p.AfterInsertedFlag != 0 {
t.Error(errors.New("AfterInsertedFlag is set"))
}
if p.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertViaExt not set"))
}
if p.AfterInsertedViaExt != 0 {
t.Error(errors.New("AfterInsertedViaExt is set"))
}
}
err = session.Commit()
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p.AfterInsertedFlag == 0 {
t.Error(errors.New("AfterInsertedFlag not set"))
}
if p.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertViaExt not set"))
}
if p.AfterInsertedViaExt == 0 {
t.Error(errors.New("AfterInsertedViaExt not set"))
}
}
session.Close()
p2 = &ProcessorsStruct{}
_, err = engine.Id(p.Id).Get(p2)
if err != nil {
t.Error(err)
panic(err)
} else {
if p2.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p2.AfterInsertedFlag != 0 {
t.Error(errors.New("AfterInsertedFlag is set"))
}
if p2.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertViaExt not set"))
}
if p2.AfterInsertedViaExt != 0 {
t.Error(errors.New("AfterInsertedViaExt is set"))
}
}
insertedId := p2.Id
// --
// test update processors with tx rollback
session = engine.NewSession()
err = session.Begin()
if err != nil {
t.Error(err)
panic(err)
}
b4UpdateFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4UpdateViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
afterUpdateFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterUpdatedViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
p = p2 // reset
_, err = session.Id(insertedId).Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4UpdateFlag == 0 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p.AfterUpdatedFlag != 0 {
t.Error(errors.New("AfterUpdatedFlag is set"))
}
if p.B4UpdateViaExt == 0 {
t.Error(errors.New("B4UpdateViaExt not set"))
}
if p.AfterUpdatedViaExt != 0 {
t.Error(errors.New("AfterUpdatedViaExt is set"))
}
}
err = session.Rollback()
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4UpdateFlag == 0 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p.AfterUpdatedFlag != 0 {
t.Error(errors.New("AfterUpdatedFlag is set"))
}
if p.B4UpdateViaExt == 0 {
t.Error(errors.New("B4UpdateViaExt not set"))
}
if p.AfterUpdatedViaExt != 0 {
t.Error(errors.New("AfterUpdatedViaExt is set"))
}
}
session.Close()
p2 = &ProcessorsStruct{}
_, err = engine.Id(insertedId).Get(p2)
if err != nil {
t.Error(err)
panic(err)
} else {
if p2.B4UpdateFlag != 0 {
t.Error(errors.New("B4UpdateFlag is set"))
}
if p2.AfterUpdatedFlag != 0 {
t.Error(errors.New("AfterUpdatedFlag is set"))
}
if p2.B4UpdateViaExt != 0 {
t.Error(errors.New("B4UpdateViaExt not set"))
}
if p2.AfterUpdatedViaExt != 0 {
t.Error(errors.New("AfterUpdatedViaExt is set"))
}
}
// --
// test update processors with tx commit
session = engine.NewSession()
err = session.Begin()
if err != nil {
t.Error(err)
panic(err)
}
p = &ProcessorsStruct{}
_, err = session.Id(insertedId).Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4UpdateFlag == 0 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p.AfterUpdatedFlag != 0 {
t.Error(errors.New("AfterUpdatedFlag is set"))
}
if p.B4UpdateViaExt == 0 {
t.Error(errors.New("B4UpdateViaExt not set"))
}
if p.AfterUpdatedViaExt != 0 {
t.Error(errors.New("AfterUpdatedViaExt is set"))
}
}
err = session.Commit()
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4UpdateFlag == 0 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p.AfterUpdatedFlag == 0 {
t.Error(errors.New("AfterUpdatedFlag not set"))
}
if p.B4UpdateViaExt == 0 {
t.Error(errors.New("B4UpdateViaExt not set"))
}
if p.AfterUpdatedViaExt == 0 {
t.Error(errors.New("AfterUpdatedViaExt not set"))
}
}
session.Close()
p2 = &ProcessorsStruct{}
_, err = engine.Id(insertedId).Get(p2)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4UpdateFlag == 0 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p.AfterUpdatedFlag == 0 {
t.Error(errors.New("AfterUpdatedFlag not set"))
}
if p.B4UpdateViaExt == 0 {
t.Error(errors.New("B4UpdateViaExt not set"))
}
if p.AfterUpdatedViaExt == 0 {
t.Error(errors.New("AfterUpdatedViaExt not set"))
}
}
// --
// test delete processors with tx rollback
session = engine.NewSession()
err = session.Begin()
if err != nil {
t.Error(err)
panic(err)
}
b4DeleteFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4DeleteViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
afterDeleteFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterDeletedViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
p = &ProcessorsStruct{} // reset
_, err = session.Id(insertedId).Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4DeleteFlag == 0 {
t.Error(errors.New("B4DeleteFlag not set"))
}
if p.AfterDeletedFlag != 0 {
t.Error(errors.New("AfterDeletedFlag is set"))
}
if p.B4DeleteViaExt == 0 {
t.Error(errors.New("B4DeleteViaExt not set"))
}
if p.AfterDeletedViaExt != 0 {
t.Error(errors.New("AfterDeletedViaExt is set"))
}
}
err = session.Rollback()
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4DeleteFlag == 0 {
t.Error(errors.New("B4DeleteFlag not set"))
}
if p.AfterDeletedFlag != 0 {
t.Error(errors.New("AfterDeletedFlag is set"))
}
if p.B4DeleteViaExt == 0 {
t.Error(errors.New("B4DeleteViaExt not set"))
}
if p.AfterDeletedViaExt != 0 {
t.Error(errors.New("AfterDeletedViaExt is set"))
}
}
session.Close()
p2 = &ProcessorsStruct{}
_, err = engine.Id(insertedId).Get(p2)
if err != nil {
t.Error(err)
panic(err)
} else {
if p2.B4DeleteFlag != 0 {
t.Error(errors.New("B4DeleteFlag is set"))
}
if p2.AfterDeletedFlag != 0 {
t.Error(errors.New("AfterDeletedFlag is set"))
}
if p2.B4DeleteViaExt != 0 {
t.Error(errors.New("B4DeleteViaExt is set"))
}
if p2.AfterDeletedViaExt != 0 {
t.Error(errors.New("AfterDeletedViaExt is set"))
}
}
// --
// test delete processors with tx commit
session = engine.NewSession()
err = session.Begin()
if err != nil {
t.Error(err)
panic(err)
}
p = &ProcessorsStruct{}
_, err = session.Id(insertedId).Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4DeleteFlag == 0 {
t.Error(errors.New("B4DeleteFlag not set"))
}
if p.AfterDeletedFlag != 0 {
t.Error(errors.New("AfterDeletedFlag is set"))
}
if p.B4DeleteViaExt == 0 {
t.Error(errors.New("B4DeleteViaExt not set"))
}
if p.AfterDeletedViaExt != 0 {
t.Error(errors.New("AfterDeletedViaExt is set"))
}
}
err = session.Commit()
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4DeleteFlag == 0 {
t.Error(errors.New("B4DeleteFlag not set"))
}
if p.AfterDeletedFlag == 0 {
t.Error(errors.New("AfterDeletedFlag not set"))
}
if p.B4DeleteViaExt == 0 {
t.Error(errors.New("B4DeleteViaExt not set"))
}
if p.AfterDeletedViaExt == 0 {
t.Error(errors.New("AfterDeletedViaExt not set"))
}
}
session.Close()
// --
}
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 testNullValue(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&NullData{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&NullData{})
if err != nil {
t.Error(err)
panic(err)
}
nullData := NullData{}
cnt, err := engine.Insert(&nullData)
fmt.Println(nullData.Id)
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 nullData.Id <= 0 {
err = errors.New("not return id error")
t.Error(err)
panic(err)
}
nullDataGet := NullData{}
has, err := engine.Id(nullData.Id).Get(&nullDataGet)
if err != nil {
t.Error(err)
panic(err)
} else if !has {
t.Error(errors.New("ID not found"))
}
if nullDataGet.StringPtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.StringPtr)))
}
if nullDataGet.StringPtr2 != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.StringPtr2)))
}
if nullDataGet.BoolPtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%t]", *nullDataGet.BoolPtr)))
}
if nullDataGet.UintPtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.UintPtr)))
}
if nullDataGet.Uint8Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Uint8Ptr)))
}
if nullDataGet.Uint16Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Uint16Ptr)))
}
if nullDataGet.Uint32Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Uint32Ptr)))
}
if nullDataGet.Uint64Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Uint64Ptr)))
}
if nullDataGet.IntPtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.IntPtr)))
}
if nullDataGet.Int8Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Int8Ptr)))
}
if nullDataGet.Int16Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Int16Ptr)))
}
if nullDataGet.Int32Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Int32Ptr)))
}
if nullDataGet.Int64Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Int64Ptr)))
}
if nullDataGet.RunePtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.RunePtr)))
}
if nullDataGet.Float32Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Float32Ptr)))
}
if nullDataGet.Float64Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Float64Ptr)))
}
// if nullDataGet.Complex64Ptr != nil {
// t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Complex64Ptr)))
// }
// if nullDataGet.Complex128Ptr != nil {
// t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Complex128Ptr)))
// }
if nullDataGet.TimePtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.TimePtr)))
}
nullDataUpdate := NullData{
StringPtr: new(string),
StringPtr2: new(string),
BoolPtr: new(bool),
BytePtr: new(byte),
UintPtr: new(uint),
Uint8Ptr: new(uint8),
Uint16Ptr: new(uint16),
Uint32Ptr: new(uint32),
Uint64Ptr: new(uint64),
IntPtr: new(int),
Int8Ptr: new(int8),
Int16Ptr: new(int16),
Int32Ptr: new(int32),
Int64Ptr: new(int64),
RunePtr: new(rune),
Float32Ptr: new(float32),
Float64Ptr: new(float64),
// Complex64Ptr: new(complex64),
// Complex128Ptr: new(complex128),
TimePtr: new(time.Time),
}
*nullDataUpdate.StringPtr = "abc"
*nullDataUpdate.StringPtr2 = "123"
*nullDataUpdate.BoolPtr = true
*nullDataUpdate.BytePtr = 1
*nullDataUpdate.UintPtr = 1
*nullDataUpdate.Uint8Ptr = 1
*nullDataUpdate.Uint16Ptr = 1
*nullDataUpdate.Uint32Ptr = 1
*nullDataUpdate.Uint64Ptr = 1
*nullDataUpdate.IntPtr = -1
*nullDataUpdate.Int8Ptr = -1
*nullDataUpdate.Int16Ptr = -1
*nullDataUpdate.Int32Ptr = -1
*nullDataUpdate.Int64Ptr = -1
*nullDataUpdate.RunePtr = 1
*nullDataUpdate.Float32Ptr = -1.2
*nullDataUpdate.Float64Ptr = -1.1
// *nullDataUpdate.Complex64Ptr = 123456789012345678901234567890
// *nullDataUpdate.Complex128Ptr = 123456789012345678901234567890123456789012345678901234567890
*nullDataUpdate.TimePtr = time.Now()
cnt, err = engine.Id(nullData.Id).Update(&nullDataUpdate)
if err != nil {
t.Error(err)
panic(err)
} else if cnt != 1 {
t.Error(errors.New("update count == 0, how can this happen!?"))
return
}
// verify get values
nullDataGet = NullData{}
has, err = engine.Id(nullData.Id).Get(&nullDataGet)
if err != nil {
t.Error(err)
return
} else if !has {
t.Error(errors.New("ID not found"))
return
}
if *nullDataGet.StringPtr != *nullDataUpdate.StringPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.StringPtr)))
}
if *nullDataGet.StringPtr2 != *nullDataUpdate.StringPtr2 {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.StringPtr2)))
}
if *nullDataGet.BoolPtr != *nullDataUpdate.BoolPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%t]", *nullDataGet.BoolPtr)))
}
if *nullDataGet.UintPtr != *nullDataUpdate.UintPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.UintPtr)))
}
if *nullDataGet.Uint8Ptr != *nullDataUpdate.Uint8Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Uint8Ptr)))
}
if *nullDataGet.Uint16Ptr != *nullDataUpdate.Uint16Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Uint16Ptr)))
}
if *nullDataGet.Uint32Ptr != *nullDataUpdate.Uint32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Uint32Ptr)))
}
if *nullDataGet.Uint64Ptr != *nullDataUpdate.Uint64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Uint64Ptr)))
}
if *nullDataGet.IntPtr != *nullDataUpdate.IntPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.IntPtr)))
}
if *nullDataGet.Int8Ptr != *nullDataUpdate.Int8Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Int8Ptr)))
}
if *nullDataGet.Int16Ptr != *nullDataUpdate.Int16Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Int16Ptr)))
}
if *nullDataGet.Int32Ptr != *nullDataUpdate.Int32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Int32Ptr)))
}
if *nullDataGet.Int64Ptr != *nullDataUpdate.Int64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Int64Ptr)))
}
if *nullDataGet.RunePtr != *nullDataUpdate.RunePtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.RunePtr)))
}
if *nullDataGet.Float32Ptr != *nullDataUpdate.Float32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Float32Ptr)))
}
if *nullDataGet.Float64Ptr != *nullDataUpdate.Float64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Float64Ptr)))
}
// if *nullDataGet.Complex64Ptr != *nullDataUpdate.Complex64Ptr {
// t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Complex64Ptr)))
// }
// if *nullDataGet.Complex128Ptr != *nullDataUpdate.Complex128Ptr {
// t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Complex128Ptr)))
// }
// !nashtsai! skipped mymysql test due to driver will round up time caused inaccuracy comparison
// skipped postgres test due to postgres driver doesn't read time.Time's timzezone info when stored in the db
// mysql and sqlite3 seem have done this correctly by storing datatime in UTC timezone, I think postgres driver
// prefer using timestamp with timezone to sovle the issue
if engine.DriverName() != core.POSTGRES && engine.DriverName() != "mymysql" &&
engine.DriverName() != core.MYSQL {
if (*nullDataGet.TimePtr).Unix() != (*nullDataUpdate.TimePtr).Unix() {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]:[%v]", *nullDataGet.TimePtr, *nullDataUpdate.TimePtr)))
} else {
// !nashtsai! mymysql driver will failed this test case, due the time is roundup to nearest second, I would considered this is a bug in mymysql driver
// inserted value unmatch: [2013-12-25 12:12:45 +0800 CST]:[2013-12-25 12:12:44.878903653 +0800 CST]
fmt.Printf("time value: [%v]:[%v]", *nullDataGet.TimePtr, *nullDataUpdate.TimePtr)
fmt.Println()
}
}
// update to null values
nullDataUpdate = NullData{}
string_ptr := engine.ColumnMapper.Obj2Table("StringPtr")
cnt, err = engine.Id(nullData.Id).Cols(string_ptr).Update(&nullDataUpdate)
if err != nil {
t.Error(err)
panic(err)
} else if cnt != 1 {
t.Error(errors.New("update count == 0, how can this happen!?"))
return
}
// verify get values
nullDataGet = NullData{}
has, err = engine.Id(nullData.Id).Get(&nullDataGet)
if err != nil {
t.Error(err)
return
} else if !has {
t.Error(errors.New("ID not found"))
return
}
fmt.Printf("%+v", nullDataGet)
fmt.Println()
if nullDataGet.StringPtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.StringPtr)))
}
/*
if nullDataGet.StringPtr2 != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.StringPtr2)))
}
if nullDataGet.BoolPtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%t]", *nullDataGet.BoolPtr)))
}
if nullDataGet.UintPtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.UintPtr)))
}
if nullDataGet.Uint8Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Uint8Ptr)))
}
if nullDataGet.Uint16Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Uint16Ptr)))
}
if nullDataGet.Uint32Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Uint32Ptr)))
}
if nullDataGet.Uint64Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Uint64Ptr)))
}
if nullDataGet.IntPtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.IntPtr)))
}
if nullDataGet.Int8Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Int8Ptr)))
}
if nullDataGet.Int16Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Int16Ptr)))
}
if nullDataGet.Int32Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Int32Ptr)))
}
if nullDataGet.Int64Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Int64Ptr)))
}
if nullDataGet.RunePtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.RunePtr)))
}
if nullDataGet.Float32Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Float32Ptr)))
}
if nullDataGet.Float64Ptr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Float64Ptr)))
}
// if nullDataGet.Complex64Ptr != nil {
// t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Float64Ptr)))
// }
// if nullDataGet.Complex128Ptr != nil {
// t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.Float64Ptr)))
// }
if nullDataGet.TimePtr != nil {
t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.TimePtr)))
}*/
// --
}
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 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 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 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 testProcessors(engine *xorm.Engine, t *testing.T) {
// tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName)
// if err != nil {
// t.Error(err)
// panic(err)
// }
engine.ShowSQL = true
err := engine.DropTables(&ProcessorsStruct{})
if err != nil {
t.Error(err)
panic(err)
}
p := &ProcessorsStruct{}
err = engine.CreateTables(&ProcessorsStruct{})
if err != nil {
t.Error(err)
panic(err)
}
b4InsertFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4InsertViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
afterInsertFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterInsertedViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
_, err = engine.Before(b4InsertFunc).After(afterInsertFunc).Insert(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p.AfterInsertedFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p.AfterInsertedViaExt == 0 {
t.Error(errors.New("AfterInsertedViaExt not set"))
}
}
p2 := &ProcessorsStruct{}
_, err = engine.Id(p.Id).Get(p2)
if err != nil {
t.Error(err)
panic(err)
} else {
if p2.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p2.AfterInsertedFlag != 0 {
t.Error(errors.New("AfterInsertedFlag is set"))
}
if p2.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertViaExt not set"))
}
if p2.AfterInsertedViaExt != 0 {
t.Error(errors.New("AfterInsertedViaExt is set"))
}
}
// --
// test update processors
b4UpdateFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4UpdateViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
afterUpdateFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterUpdatedViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
p = p2 // reset
_, err = engine.Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4UpdateFlag == 0 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p.AfterUpdatedFlag == 0 {
t.Error(errors.New("AfterUpdatedFlag not set"))
}
if p.B4UpdateViaExt == 0 {
t.Error(errors.New("B4UpdateViaExt not set"))
}
if p.AfterUpdatedViaExt == 0 {
t.Error(errors.New("AfterUpdatedViaExt not set"))
}
}
p2 = &ProcessorsStruct{}
_, err = engine.Id(p.Id).Get(p2)
if err != nil {
t.Error(err)
panic(err)
} else {
if p2.B4UpdateFlag == 0 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p2.AfterUpdatedFlag != 0 {
t.Error(errors.New("AfterUpdatedFlag is set: " + string(p.AfterUpdatedFlag)))
}
if p2.B4UpdateViaExt == 0 {
t.Error(errors.New("B4UpdateViaExt not set"))
}
if p2.AfterUpdatedViaExt != 0 {
t.Error(errors.New("AfterUpdatedViaExt is set: " + string(p.AfterUpdatedViaExt)))
}
}
// --
// test delete processors
b4DeleteFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4DeleteViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
afterDeleteFunc := func(bean interface{}) {
if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterDeletedViaExt = 1
} else {
t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
}
}
p = p2 // reset
_, err = engine.Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p.B4DeleteFlag == 0 {
t.Error(errors.New("B4DeleteFlag not set"))
}
if p.AfterDeletedFlag == 0 {
t.Error(errors.New("AfterDeletedFlag not set"))
}
if p.B4DeleteViaExt == 0 {
t.Error(errors.New("B4DeleteViaExt not set"))
}
if p.AfterDeletedViaExt == 0 {
t.Error(errors.New("AfterDeletedViaExt not set"))
}
}
// --
// test insert multi
pslice := make([]*ProcessorsStruct, 0)
pslice = append(pslice, &ProcessorsStruct{})
pslice = append(pslice, &ProcessorsStruct{})
cnt, err := engine.Before(b4InsertFunc).After(afterInsertFunc).Insert(&pslice)
if err != nil {
t.Error(err)
panic(err)
} else {
if cnt != 2 {
t.Error(errors.New("incorrect insert count"))
}
for _, elem := range pslice {
if elem.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if elem.AfterInsertedFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if elem.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if elem.AfterInsertedViaExt == 0 {
t.Error(errors.New("AfterInsertedViaExt not set"))
}
}
}
for _, elem := range pslice {
p = &ProcessorsStruct{}
_, err = engine.Id(elem.Id).Get(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p2.B4InsertFlag == 0 {
t.Error(errors.New("B4InsertFlag not set"))
}
if p2.AfterInsertedFlag != 0 {
t.Error(errors.New("AfterInsertedFlag is set"))
}
if p2.B4InsertViaExt == 0 {
t.Error(errors.New("B4InsertViaExt not set"))
}
if p2.AfterInsertedViaExt != 0 {
t.Error(errors.New("AfterInsertedViaExt is set"))
}
}
}
// --
}
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 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 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 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 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 testPointerData(engine *xorm.Engine, t *testing.T) {
err := engine.DropTables(&NullData{})
if err != nil {
t.Error(err)
panic(err)
}
err = engine.CreateTables(&NullData{})
if err != nil {
t.Error(err)
panic(err)
}
nullData := NullData{
StringPtr: new(string),
StringPtr2: new(string),
BoolPtr: new(bool),
BytePtr: new(byte),
UintPtr: new(uint),
Uint8Ptr: new(uint8),
Uint16Ptr: new(uint16),
Uint32Ptr: new(uint32),
Uint64Ptr: new(uint64),
IntPtr: new(int),
Int8Ptr: new(int8),
Int16Ptr: new(int16),
Int32Ptr: new(int32),
Int64Ptr: new(int64),
RunePtr: new(rune),
Float32Ptr: new(float32),
Float64Ptr: new(float64),
// Complex64Ptr: new(complex64),
// Complex128Ptr: new(complex128),
TimePtr: new(time.Time),
}
*nullData.StringPtr = "abc"
*nullData.StringPtr2 = "123"
*nullData.BoolPtr = true
*nullData.BytePtr = 1
*nullData.UintPtr = 1
*nullData.Uint8Ptr = 1
*nullData.Uint16Ptr = 1
*nullData.Uint32Ptr = 1
*nullData.Uint64Ptr = 1
*nullData.IntPtr = -1
*nullData.Int8Ptr = -1
*nullData.Int16Ptr = -1
*nullData.Int32Ptr = -1
*nullData.Int64Ptr = -1
*nullData.RunePtr = 1
*nullData.Float32Ptr = -1.2
*nullData.Float64Ptr = -1.1
// *nullData.Complex64Ptr = 123456789012345678901234567890
// *nullData.Complex128Ptr = 123456789012345678901234567890123456789012345678901234567890
*nullData.TimePtr = time.Now()
cnt, err := engine.Insert(&nullData)
fmt.Println(nullData.Id)
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 nullData.Id <= 0 {
err = errors.New("not return id error")
t.Error(err)
panic(err)
}
// verify get values
nullDataGet := NullData{}
has, err := engine.Id(nullData.Id).Get(&nullDataGet)
if err != nil {
t.Error(err)
panic(err)
} else if !has {
t.Error(errors.New("ID not found"))
}
if *nullDataGet.StringPtr != *nullData.StringPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.StringPtr)))
}
if *nullDataGet.StringPtr2 != *nullData.StringPtr2 {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.StringPtr2)))
}
if *nullDataGet.BoolPtr != *nullData.BoolPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%t]", *nullDataGet.BoolPtr)))
}
if *nullDataGet.UintPtr != *nullData.UintPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.UintPtr)))
}
if *nullDataGet.Uint8Ptr != *nullData.Uint8Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Uint8Ptr)))
}
if *nullDataGet.Uint16Ptr != *nullData.Uint16Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Uint16Ptr)))
}
if *nullDataGet.Uint32Ptr != *nullData.Uint32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Uint32Ptr)))
}
if *nullDataGet.Uint64Ptr != *nullData.Uint64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Uint64Ptr)))
}
if *nullDataGet.IntPtr != *nullData.IntPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.IntPtr)))
}
if *nullDataGet.Int8Ptr != *nullData.Int8Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Int8Ptr)))
}
if *nullDataGet.Int16Ptr != *nullData.Int16Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Int16Ptr)))
}
if *nullDataGet.Int32Ptr != *nullData.Int32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Int32Ptr)))
}
if *nullDataGet.Int64Ptr != *nullData.Int64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Int64Ptr)))
}
if *nullDataGet.RunePtr != *nullData.RunePtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.RunePtr)))
}
if *nullDataGet.Float32Ptr != *nullData.Float32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Float32Ptr)))
}
if *nullDataGet.Float64Ptr != *nullData.Float64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Float64Ptr)))
}
// if *nullDataGet.Complex64Ptr != *nullData.Complex64Ptr {
// t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Complex64Ptr)))
// }
// if *nullDataGet.Complex128Ptr != *nullData.Complex128Ptr {
// t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Complex128Ptr)))
// }
/*if (*nullDataGet.TimePtr).Unix() != (*nullData.TimePtr).Unix() {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]:[%v]", *nullDataGet.TimePtr, *nullData.TimePtr)))
} else {
// !nashtsai! mymysql driver will failed this test case, due the time is roundup to nearest second, I would considered this is a bug in mymysql driver
fmt.Printf("time value: [%v]:[%v]", *nullDataGet.TimePtr, *nullData.TimePtr)
fmt.Println()
}*/
// --
// using instance type should just work too
nullData2Get := NullData2{}
tableName := engine.TableMapper.Obj2Table("NullData")
has, err = engine.Table(tableName).Id(nullData.Id).Get(&nullData2Get)
if err != nil {
t.Error(err)
panic(err)
} else if !has {
t.Error(errors.New("ID not found"))
}
if nullData2Get.StringPtr != *nullData.StringPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.StringPtr)))
}
if nullData2Get.StringPtr2 != *nullData.StringPtr2 {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.StringPtr2)))
}
if nullData2Get.BoolPtr != *nullData.BoolPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%t]", nullData2Get.BoolPtr)))
}
if nullData2Get.UintPtr != *nullData.UintPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.UintPtr)))
}
if nullData2Get.Uint8Ptr != *nullData.Uint8Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Uint8Ptr)))
}
if nullData2Get.Uint16Ptr != *nullData.Uint16Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Uint16Ptr)))
}
if nullData2Get.Uint32Ptr != *nullData.Uint32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Uint32Ptr)))
}
if nullData2Get.Uint64Ptr != *nullData.Uint64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Uint64Ptr)))
}
if nullData2Get.IntPtr != *nullData.IntPtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.IntPtr)))
}
if nullData2Get.Int8Ptr != *nullData.Int8Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Int8Ptr)))
}
if nullData2Get.Int16Ptr != *nullData.Int16Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Int16Ptr)))
}
if nullData2Get.Int32Ptr != *nullData.Int32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Int32Ptr)))
}
if nullData2Get.Int64Ptr != *nullData.Int64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Int64Ptr)))
}
if nullData2Get.RunePtr != *nullData.RunePtr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.RunePtr)))
}
if nullData2Get.Float32Ptr != *nullData.Float32Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Float32Ptr)))
}
if nullData2Get.Float64Ptr != *nullData.Float64Ptr {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Float64Ptr)))
}
// if nullData2Get.Complex64Ptr != *nullData.Complex64Ptr {
// t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Complex64Ptr)))
// }
// if nullData2Get.Complex128Ptr != *nullData.Complex128Ptr {
// t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", nullData2Get.Complex128Ptr)))
// }
/*if nullData2Get.TimePtr.Unix() != (*nullData.TimePtr).Unix() {
t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]:[%v]", nullData2Get.TimePtr, *nullData.TimePtr)))
} else {
// !nashtsai! mymysql driver will failed this test case, due the time is roundup to nearest second, I would considered this is a bug in mymysql driver
fmt.Printf("time value: [%v]:[%v]", nullData2Get.TimePtr, *nullData.TimePtr)
fmt.Println()
}*/
// --
}