HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: fix go lint warning.

This commit is contained in:
Bo-Yi Wu 2018-10-11 13:51:25 +08:00
parent 3e8290cc94
commit 4fc3f139e9
29 changed files with 512 additions and 513 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
cache_lru_test.go
View File

@ -13,7 +13,7 @@ import (
func TestLRUCache(t *testing.T) { func TestLRUCache(t *testing.T) {
type CacheObject1 struct { type CacheObject1 struct {
Id int64 ID int64
} }
store := NewMemoryStore() store := NewMemoryStore()
@ -29,12 +29,12 @@ func TestLRUCache(t *testing.T) {
sid, err := pk.ToString() sid, err := pk.ToString()
assert.NoError(t, err) assert.NoError(t, err)
cacher.PutIds(tableName, "select * from cache_object1", sid) cacher.PutIDs(tableName, "select * from cache_object1", sid)
ids := cacher.GetIds(tableName, "select * from cache_object1") ids := cacher.GetIDs(tableName, "select * from cache_object1")
assert.EqualValues(t, sid, ids) assert.EqualValues(t, sid, ids)
cacher.ClearIds(tableName) cacher.ClearIDs(tableName)
ids2 := cacher.GetIds(tableName, "select * from cache_object1") ids2 := cacher.GetIDs(tableName, "select * from cache_object1")
assert.Nil(t, ids2) assert.Nil(t, ids2)
obj2 := cacher.GetBean(tableName, sid) obj2 := cacher.GetBean(tableName, sid)

4
cache_memory_store_test.go
View File

@ -25,12 +25,12 @@ func TestMemoryStore(t *testing.T) {
assert.EqualValues(t, v, val) assert.EqualValues(t, v, val)
} }
for k, _ := range kvs { for k := range kvs {
err := store.Del(k) err := store.Del(k)
assert.NoError(t, err) assert.NoError(t, err)
} }
for k, _ := range kvs { for k := range kvs {
_, err := store.Get(k) _, err := store.Get(k)
assert.EqualValues(t, ErrNotExist, err) assert.EqualValues(t, ErrNotExist, err)
} }

32
cache_test.go
View File

@ -15,7 +15,7 @@ func TestCacheFind(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type MailBox struct { type MailBox struct {
Id int64 `xorm:"pk"` ID int64 `xorm:"pk"`
Username string Username string
Password string Password string
} }
@ -28,12 +28,12 @@ func TestCacheFind(t *testing.T) {
var inserts = []*MailBox{ var inserts = []*MailBox{
{ {
Id: 0, ID: 0,
Username: "user1", Username: "user1",
Password: "pass1", Password: "pass1",
}, },
{ {
Id: 1, ID: 1,
Username: "user2", Username: "user2",
Password: "pass2", Password: "pass2",
}, },
@ -45,7 +45,7 @@ func TestCacheFind(t *testing.T) {
assert.NoError(t, testEngine.Find(&boxes)) assert.NoError(t, testEngine.Find(&boxes))
assert.EqualValues(t, 2, len(boxes)) assert.EqualValues(t, 2, len(boxes))
for i, box := range boxes { for i, box := range boxes {
assert.Equal(t, inserts[i].Id, box.Id) assert.Equal(t, inserts[i].ID, box.ID)
assert.Equal(t, inserts[i].Username, box.Username) assert.Equal(t, inserts[i].Username, box.Username)
assert.Equal(t, inserts[i].Password, box.Password) assert.Equal(t, inserts[i].Password, box.Password)
} }
@ -54,7 +54,7 @@ func TestCacheFind(t *testing.T) {
assert.NoError(t, testEngine.Find(&boxes)) assert.NoError(t, testEngine.Find(&boxes))
assert.EqualValues(t, 2, len(boxes)) assert.EqualValues(t, 2, len(boxes))
for i, box := range boxes { for i, box := range boxes {
assert.Equal(t, inserts[i].Id, box.Id) assert.Equal(t, inserts[i].ID, box.ID)
assert.Equal(t, inserts[i].Username, box.Username) assert.Equal(t, inserts[i].Username, box.Username)
assert.Equal(t, inserts[i].Password, box.Password) assert.Equal(t, inserts[i].Password, box.Password)
} }
@ -63,13 +63,13 @@ func TestCacheFind(t *testing.T) {
assert.NoError(t, testEngine.Alias("a").Where("a.id > -1").Asc("a.id").Find(&boxes)) assert.NoError(t, testEngine.Alias("a").Where("a.id > -1").Asc("a.id").Find(&boxes))
assert.EqualValues(t, 2, len(boxes)) assert.EqualValues(t, 2, len(boxes))
for i, box := range boxes { for i, box := range boxes {
assert.Equal(t, inserts[i].Id, box.Id) assert.Equal(t, inserts[i].ID, box.ID)
assert.Equal(t, inserts[i].Username, box.Username) assert.Equal(t, inserts[i].Username, box.Username)
assert.Equal(t, inserts[i].Password, box.Password) assert.Equal(t, inserts[i].Password, box.Password)
} }
type MailBox4 struct { type MailBox4 struct {
Id int64 ID int64
Username string Username string
Password string Password string
} }
@ -78,7 +78,7 @@ func TestCacheFind(t *testing.T) {
assert.NoError(t, testEngine.Table("mail_box").Where("mail_box.id > -1").Asc("mail_box.id").Find(&boxes2)) assert.NoError(t, testEngine.Table("mail_box").Where("mail_box.id > -1").Asc("mail_box.id").Find(&boxes2))
assert.EqualValues(t, 2, len(boxes2)) assert.EqualValues(t, 2, len(boxes2))
for i, box := range boxes2 { for i, box := range boxes2 {
assert.Equal(t, inserts[i].Id, box.Id) assert.Equal(t, inserts[i].ID, box.ID)
assert.Equal(t, inserts[i].Username, box.Username) assert.Equal(t, inserts[i].Username, box.Username)
assert.Equal(t, inserts[i].Password, box.Password) assert.Equal(t, inserts[i].Password, box.Password)
} }
@ -90,7 +90,7 @@ func TestCacheFind2(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type MailBox2 struct { type MailBox2 struct {
Id uint64 `xorm:"pk"` ID uint64 `xorm:"pk"`
Username string Username string
Password string Password string
} }
@ -103,12 +103,12 @@ func TestCacheFind2(t *testing.T) {
var inserts = []*MailBox2{ var inserts = []*MailBox2{
{ {
Id: 0, ID: 0,
Username: "user1", Username: "user1",
Password: "pass1", Password: "pass1",
}, },
{ {
Id: 1, ID: 1,
Username: "user2", Username: "user2",
Password: "pass2", Password: "pass2",
}, },
@ -120,7 +120,7 @@ func TestCacheFind2(t *testing.T) {
assert.NoError(t, testEngine.Find(&boxes)) assert.NoError(t, testEngine.Find(&boxes))
assert.EqualValues(t, 2, len(boxes)) assert.EqualValues(t, 2, len(boxes))
for i, box := range boxes { for i, box := range boxes {
assert.Equal(t, inserts[i].Id, box.Id) assert.Equal(t, inserts[i].ID, box.ID)
assert.Equal(t, inserts[i].Username, box.Username) assert.Equal(t, inserts[i].Username, box.Username)
assert.Equal(t, inserts[i].Password, box.Password) assert.Equal(t, inserts[i].Password, box.Password)
} }
@ -129,7 +129,7 @@ func TestCacheFind2(t *testing.T) {
assert.NoError(t, testEngine.Find(&boxes)) assert.NoError(t, testEngine.Find(&boxes))
assert.EqualValues(t, 2, len(boxes)) assert.EqualValues(t, 2, len(boxes))
for i, box := range boxes { for i, box := range boxes {
assert.Equal(t, inserts[i].Id, box.Id) assert.Equal(t, inserts[i].ID, box.ID)
assert.Equal(t, inserts[i].Username, box.Username) assert.Equal(t, inserts[i].Username, box.Username)
assert.Equal(t, inserts[i].Password, box.Password) assert.Equal(t, inserts[i].Password, box.Password)
} }
@ -141,7 +141,7 @@ func TestCacheGet(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type MailBox3 struct { type MailBox3 struct {
Id uint64 ID uint64
Username string Username string
Password string Password string
} }
@ -162,14 +162,14 @@ func TestCacheGet(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
var box1 MailBox3 var box1 MailBox3
has, err := testEngine.Where("id = ?", inserts[0].Id).Get(&box1) has, err := testEngine.Where("id = ?", inserts[0].ID).Get(&box1)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, "user1", box1.Username) assert.EqualValues(t, "user1", box1.Username)
assert.EqualValues(t, "pass1", box1.Password) assert.EqualValues(t, "pass1", box1.Password)
var box2 MailBox3 var box2 MailBox3
has, err = testEngine.Where("id = ?", inserts[0].Id).Get(&box2) has, err = testEngine.Where("id = ?", inserts[0].ID).Get(&box2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, "user1", box2.Username) assert.EqualValues(t, "user1", box2.Username)

62
processors_test.go
View File

@ -16,7 +16,7 @@ func TestBefore_Get(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type BeforeTable struct { type BeforeTable struct {
Id int64 ID int64
Name string Name string
Val string `xorm:"-"` Val string `xorm:"-"`
} }
@ -43,7 +43,7 @@ func TestBefore_Find(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type BeforeTable2 struct { type BeforeTable2 struct {
Id int64 ID int64
Name string Name string
Val string `xorm:"-"` Val string `xorm:"-"`
} }
@ -70,7 +70,7 @@ func TestBefore_Find(t *testing.T) {
} }
type ProcessorsStruct struct { type ProcessorsStruct struct {
Id int64 ID int64
B4InsertFlag int B4InsertFlag int
AfterInsertedFlag int AfterInsertedFlag int
@ -173,7 +173,7 @@ func TestProcessors(t *testing.T) {
} }
p2 := &ProcessorsStruct{} p2 := &ProcessorsStruct{}
_, err = testEngine.ID(p.Id).Get(p2) _, err = testEngine.ID(p.ID).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -308,7 +308,7 @@ func TestProcessors(t *testing.T) {
} }
p2 = &ProcessorsStruct{} p2 = &ProcessorsStruct{}
_, err = testEngine.ID(p.Id).Get(p2) _, err = testEngine.ID(p.ID).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -402,7 +402,7 @@ func TestProcessors(t *testing.T) {
for _, elem := range pslice { for _, elem := range pslice {
p = &ProcessorsStruct{} p = &ProcessorsStruct{}
_, err = testEngine.ID(elem.Id).Get(p) _, err = testEngine.ID(elem.ID).Get(p)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -508,12 +508,12 @@ func TestProcessorsTx(t *testing.T) {
} }
session.Close() session.Close()
p2 := &ProcessorsStruct{} p2 := &ProcessorsStruct{}
_, err = testEngine.ID(p.Id).Get(p2) _, err = testEngine.ID(p.ID).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} else { } else {
if p2.Id > 0 { if p2.ID > 0 {
err = errors.New("tx got committed upon insert!?") err = errors.New("tx got committed upon insert!?")
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -569,7 +569,7 @@ func TestProcessorsTx(t *testing.T) {
} }
session.Close() session.Close()
p2 = &ProcessorsStruct{} p2 = &ProcessorsStruct{}
_, err = testEngine.ID(p.Id).Get(p2) _, err = testEngine.ID(p.ID).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -587,7 +587,7 @@ func TestProcessorsTx(t *testing.T) {
t.Error(errors.New("AfterInsertedViaExt is set")) t.Error(errors.New("AfterInsertedViaExt is set"))
} }
} }
insertedId := p2.Id insertedID := p2.ID
// -- // --
// test update processors with tx rollback // test update processors with tx rollback
@ -616,7 +616,7 @@ func TestProcessorsTx(t *testing.T) {
p = p2 // reset p = p2 // reset
_, err = session.ID(insertedId).Before(b4UpdateFunc).After(afterUpdateFunc).Update(p) _, err = session.ID(insertedID).Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -656,7 +656,7 @@ func TestProcessorsTx(t *testing.T) {
session.Close() session.Close()
p2 = &ProcessorsStruct{} p2 = &ProcessorsStruct{}
_, err = testEngine.ID(insertedId).Get(p2) _, err = testEngine.ID(insertedID).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -684,7 +684,7 @@ func TestProcessorsTx(t *testing.T) {
panic(err) panic(err)
} }
p = &ProcessorsStruct{Id: insertedId} p = &ProcessorsStruct{ID: insertedID}
_, err = session.Update(p) _, err = session.Update(p)
if err != nil { if err != nil {
@ -729,7 +729,7 @@ func TestProcessorsTx(t *testing.T) {
p = &ProcessorsStruct{} p = &ProcessorsStruct{}
_, err = session.ID(insertedId).Before(b4UpdateFunc).After(afterUpdateFunc).Update(p) _, err = session.ID(insertedID).Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -767,7 +767,7 @@ func TestProcessorsTx(t *testing.T) {
} }
session.Close() session.Close()
p2 = &ProcessorsStruct{} p2 = &ProcessorsStruct{}
_, err = testEngine.ID(insertedId).Get(p2) _, err = testEngine.ID(insertedID).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -813,7 +813,7 @@ func TestProcessorsTx(t *testing.T) {
p = &ProcessorsStruct{} // reset p = &ProcessorsStruct{} // reset
_, err = session.ID(insertedId).Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p) _, err = session.ID(insertedID).Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -852,7 +852,7 @@ func TestProcessorsTx(t *testing.T) {
session.Close() session.Close()
p2 = &ProcessorsStruct{} p2 = &ProcessorsStruct{}
_, err = testEngine.ID(insertedId).Get(p2) _, err = testEngine.ID(insertedID).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -882,7 +882,7 @@ func TestProcessorsTx(t *testing.T) {
p = &ProcessorsStruct{} p = &ProcessorsStruct{}
_, err = session.ID(insertedId).Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p) _, err = session.ID(insertedID).Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -928,7 +928,7 @@ func TestProcessorsTx(t *testing.T) {
panic(err) panic(err)
} }
p = &ProcessorsStruct{Id: insertedId} p = &ProcessorsStruct{ID: insertedID}
fmt.Println("delete") fmt.Println("delete")
_, err = session.Delete(p) _, err = session.Delete(p)
@ -966,20 +966,20 @@ func TestProcessorsTx(t *testing.T) {
} }
type AfterLoadStructA struct { type AfterLoadStructA struct {
Id int64 ID int64
Content string Content string
} }
type AfterLoadStructB struct { type AfterLoadStructB struct {
Id int64 ID int64
Content string Content string
AId int64 AID int64
A AfterLoadStructA `xorm:"-"` A AfterLoadStructA `xorm:"-"`
Err error `xorm:"-"` Err error `xorm:"-"`
} }
func (s *AfterLoadStructB) AfterLoad(session *Session) { func (s *AfterLoadStructB) AfterLoad(session *Session) {
has, err := session.ID(s.AId).NoAutoCondition().Get(&s.A) has, err := session.ID(s.AID).NoAutoCondition().Get(&s.A)
if err != nil { if err != nil {
s.Err = err s.Err = err
return return
@ -1002,20 +1002,20 @@ func TestAfterLoadProcessor(t *testing.T) {
var b = AfterLoadStructB{ var b = AfterLoadStructB{
Content: "testb", Content: "testb",
AId: a.Id, AID: a.ID,
} }
_, err = testEngine.Insert(&b) _, err = testEngine.Insert(&b)
assert.NoError(t, err) assert.NoError(t, err)
var b2 AfterLoadStructB var b2 AfterLoadStructB
has, err := testEngine.ID(b.Id).Get(&b2) has, err := testEngine.ID(b.ID).Get(&b2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, a.Id, b2.A.Id) assert.EqualValues(t, a.ID, b2.A.ID)
assert.EqualValues(t, a.Content, b2.A.Content) assert.EqualValues(t, a.Content, b2.A.Content)
assert.NoError(t, b2.Err) assert.NoError(t, b2.Err)
b.Id = 0 b.ID = 0
_, err = testEngine.Insert(&b) _, err = testEngine.Insert(&b)
assert.NoError(t, err) assert.NoError(t, err)
@ -1024,19 +1024,19 @@ func TestAfterLoadProcessor(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 2, len(bs)) assert.EqualValues(t, 2, len(bs))
for i := 0; i < len(bs); i++ { for i := 0; i < len(bs); i++ {
assert.EqualValues(t, a.Id, bs[i].A.Id) assert.EqualValues(t, a.ID, bs[i].A.ID)
assert.EqualValues(t, a.Content, bs[i].A.Content) assert.EqualValues(t, a.Content, bs[i].A.Content)
assert.NoError(t, bs[i].Err) assert.NoError(t, bs[i].Err)
} }
} }
type AfterInsertStruct struct { type AfterInsertStruct struct {
Id int64 ID int64
} }
func (a *AfterInsertStruct) AfterInsert() { func (a *AfterInsertStruct) AfterInsert() {
if a.Id == 0 { if a.ID == 0 {
panic("a.Id") panic("a.ID")
} }
} }

2
rows_test.go
View File

@ -14,7 +14,7 @@ func TestRows(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserRows struct { type UserRows struct {
Id int64 ID int64
IsMan bool IsMan bool
} }

18
session_cols_test.go
View File

@ -15,7 +15,7 @@ func TestSetExpr(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserExpr struct { type UserExpr struct {
Id int64 ID int64
Show bool Show bool
} }
@ -40,7 +40,7 @@ func TestCols(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type ColsTable struct { type ColsTable struct {
Id int64 ID int64
Col1 string Col1 string
Col2 string Col2 string
} }
@ -72,14 +72,14 @@ func TestMustCol(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type CustomerUpdate struct { type CustomerUpdate struct {
Id int64 `form:"id" json:"id"` ID int64 `form:"id" json:"id"`
Username string `form:"username" json:"username" binding:"required"` Username string `form:"username" json:"username" binding:"required"`
Email string `form:"email" json:"email"` Email string `form:"email" json:"email"`
Sex int `form:"sex" json:"sex"` Sex int `form:"sex" json:"sex"`
Name string `form:"name" json:"name" binding:"required"` Name string `form:"name" json:"name" binding:"required"`
Telephone string `form:"telephone" json:"telephone"` Telephone string `form:"telephone" json:"telephone"`
Type int `form:"type" json:"type" binding:"required"` Type int `form:"type" json:"type" binding:"required"`
ParentId int64 `form:"parent_id" json:"parent_id" xorm:"int null"` ParentID int64 `form:"parent_id" json:"parent_id" xorm:"int null"`
Remark string `form:"remark" json:"remark"` Remark string `form:"remark" json:"remark"`
Status int `form:"status" json:"status" binding:"required"` Status int `form:"status" json:"status" binding:"required"`
Age int `form:"age" json:"age"` Age int `form:"age" json:"age"`
@ -92,18 +92,18 @@ func TestMustCol(t *testing.T) {
assertSync(t, new(CustomerUpdate)) assertSync(t, new(CustomerUpdate))
var customer = CustomerUpdate{ var customer = CustomerUpdate{
ParentId: 1, ParentID: 1,
} }
cnt, err := testEngine.Insert(&customer) cnt, err := testEngine.Insert(&customer)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
type CustomerOnlyId struct { type CustomerOnlyID struct {
Id int64 ID int64
} }
customer.ParentId = 0 customer.ParentID = 0
affected, err := testEngine.MustCols("parent_id").Update(&customer, &CustomerOnlyId{Id: customer.Id}) affected, err := testEngine.MustCols("parent_id").Update(&customer, &CustomerOnlyID{ID: customer.ID})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, affected) assert.EqualValues(t, 1, affected)
} }

4
session_cond_test.go
View File

@ -23,7 +23,7 @@ func TestBuilder(t *testing.T) {
) )
type Condition struct { type Condition struct {
Id int64 ID int64
TableName string TableName string
ColName string ColName string
Op int Op int
@ -202,7 +202,7 @@ func TestFindAndCount(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type FindAndCount struct { type FindAndCount struct {
Id int64 ID int64
Name string Name string
} }

40
session_delete_test.go
View File

@ -15,22 +15,22 @@ func TestDelete(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserinfoDelete struct { type UserinfoDelete struct {
Uid int64 `xorm:"id pk not null autoincr"` UID int64 `xorm:"id pk not null autoincr"`
IsMan bool IsMan bool
} }
assert.NoError(t, testEngine.Sync2(new(UserinfoDelete))) assert.NoError(t, testEngine.Sync2(new(UserinfoDelete)))
user := UserinfoDelete{Uid: 1} user := UserinfoDelete{UID: 1}
cnt, err := testEngine.Insert(&user) cnt, err := testEngine.Insert(&user)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
cnt, err = testEngine.Delete(&UserinfoDelete{Uid: user.Uid}) cnt, err = testEngine.Delete(&UserinfoDelete{UID: user.UID})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
user.Uid = 0 user.UID = 0
user.IsMan = true user.IsMan = true
has, err := testEngine.ID(1).Get(&user) has, err := testEngine.ID(1).Get(&user)
assert.NoError(t, err) assert.NoError(t, err)
@ -40,11 +40,11 @@ func TestDelete(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
cnt, err = testEngine.Where("id=?", user.Uid).Delete(&UserinfoDelete{}) cnt, err = testEngine.Where("id=?", user.UID).Delete(&UserinfoDelete{})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
user.Uid = 0 user.UID = 0
user.IsMan = true user.IsMan = true
has, err = testEngine.ID(2).Get(&user) has, err = testEngine.ID(2).Get(&user)
assert.NoError(t, err) assert.NoError(t, err)
@ -55,7 +55,7 @@ func TestDeleted(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type Deleted struct { type Deleted struct {
Id int64 `xorm:"pk"` ID int64 `xorm:"pk"`
Name string Name string
DeletedAt time.Time `xorm:"deleted"` DeletedAt time.Time `xorm:"deleted"`
} }
@ -66,18 +66,18 @@ func TestDeleted(t *testing.T) {
err = testEngine.CreateTables(&Deleted{}) err = testEngine.CreateTables(&Deleted{})
assert.NoError(t, err) assert.NoError(t, err)
_, err = testEngine.InsertOne(&Deleted{Id: 1, Name: "11111"}) _, err = testEngine.InsertOne(&Deleted{ID: 1, Name: "11111"})
assert.NoError(t, err) assert.NoError(t, err)
_, err = testEngine.InsertOne(&Deleted{Id: 2, Name: "22222"}) _, err = testEngine.InsertOne(&Deleted{ID: 2, Name: "22222"})
assert.NoError(t, err) assert.NoError(t, err)
_, err = testEngine.InsertOne(&Deleted{Id: 3, Name: "33333"}) _, err = testEngine.InsertOne(&Deleted{ID: 3, Name: "33333"})
assert.NoError(t, err) assert.NoError(t, err)
// Test normal Find() // Test normal Find()
var records1 []Deleted var records1 []Deleted
err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&records1, &Deleted{}) err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("ID")+"` > 0").Find(&records1, &Deleted{})
assert.EqualValues(t, 3, len(records1)) assert.EqualValues(t, 3, len(records1))
// Test normal Get() // Test normal Get()
@ -96,7 +96,7 @@ func TestDeleted(t *testing.T) {
assert.False(t, has) assert.False(t, has)
var records2 []Deleted var records2 []Deleted
err = testEngine.Where("`" + testEngine.GetColumnMapper().Obj2Table("Id") + "` > 0").Find(&records2) err = testEngine.Where("`" + testEngine.GetColumnMapper().Obj2Table("ID") + "` > 0").Find(&records2)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 2, len(records2)) assert.EqualValues(t, 2, len(records2))
@ -117,7 +117,7 @@ func TestDeleted(t *testing.T) {
// Test find all records whatever `deleted`. // Test find all records whatever `deleted`.
var unscopedRecords1 []Deleted var unscopedRecords1 []Deleted
err = testEngine.Unscoped().Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&unscopedRecords1, &Deleted{}) err = testEngine.Unscoped().Where("`"+testEngine.GetColumnMapper().Obj2Table("ID")+"` > 0").Find(&unscopedRecords1, &Deleted{})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 3, len(unscopedRecords1)) assert.EqualValues(t, 3, len(unscopedRecords1))
@ -127,13 +127,13 @@ func TestDeleted(t *testing.T) {
assert.EqualValues(t, 1, affected) assert.EqualValues(t, 1, affected)
var unscopedRecords2 []Deleted var unscopedRecords2 []Deleted
err = testEngine.Unscoped().Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&unscopedRecords2, &Deleted{}) err = testEngine.Unscoped().Where("`"+testEngine.GetColumnMapper().Obj2Table("ID")+"` > 0").Find(&unscopedRecords2, &Deleted{})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 2, len(unscopedRecords2)) assert.EqualValues(t, 2, len(unscopedRecords2))
var records3 []Deleted var records3 []Deleted
err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").And("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"`> 1"). err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("ID")+"` > 0").And("`"+testEngine.GetColumnMapper().Obj2Table("ID")+"`> 1").
Or("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` = ?", 3).Find(&records3) Or("`"+testEngine.GetColumnMapper().Obj2Table("ID")+"` = ?", 3).Find(&records3)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 2, len(records3)) assert.EqualValues(t, 2, len(records3))
} }
@ -146,7 +146,7 @@ func TestCacheDelete(t *testing.T) {
testEngine.SetDefaultCacher(cacher) testEngine.SetDefaultCacher(cacher)
type CacheDeleteStruct struct { type CacheDeleteStruct struct {
Id int64 ID int64
} }
err := testEngine.CreateTables(&CacheDeleteStruct{}) err := testEngine.CreateTables(&CacheDeleteStruct{})
@ -156,13 +156,13 @@ func TestCacheDelete(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
aff, err := testEngine.Delete(&CacheDeleteStruct{ aff, err := testEngine.Delete(&CacheDeleteStruct{
Id: 1, ID: 1,
}) })
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, aff, 1) assert.EqualValues(t, aff, 1)
aff, err = testEngine.Unscoped().Delete(&CacheDeleteStruct{ aff, err = testEngine.Unscoped().Delete(&CacheDeleteStruct{
Id: 1, ID: 1,
}) })
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, aff, 0) assert.EqualValues(t, aff, 0)
@ -174,7 +174,7 @@ func TestUnscopeDelete(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UnscopeDeleteStruct struct { type UnscopeDeleteStruct struct {
Id int64 ID int64
Name string Name string
DeletedAt time.Time `xorm:"deleted"` DeletedAt time.Time `xorm:"deleted"`
} }

2
session_exist_test.go
View File

@ -14,7 +14,7 @@ func TestExistStruct(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type RecordExist struct { type RecordExist struct {
Id int64 ID int64
Name string Name string
} }

30
session_find_test.go
View File

@ -18,17 +18,17 @@ func TestJoinLimit(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type Salary struct { type Salary struct {
Id int64 ID int64
Lid int64 Lid int64
} }
type CheckList struct { type CheckList struct {
Id int64 ID int64
Eid int64 Eid int64
} }
type Empsetting struct { type Empsetting struct {
Id int64 ID int64
Name string Name string
} }
@ -40,14 +40,14 @@ func TestJoinLimit(t *testing.T) {
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var checklist = CheckList{ var checklist = CheckList{
Eid: emp.Id, Eid: emp.ID,
} }
cnt, err = testEngine.Insert(&checklist) cnt, err = testEngine.Insert(&checklist)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var salary = Salary{ var salary = Salary{
Lid: checklist.Id, Lid: checklist.ID,
} }
cnt, err = testEngine.Insert(&salary) cnt, err = testEngine.Insert(&salary)
assert.NoError(t, err) assert.NoError(t, err)
@ -123,13 +123,13 @@ func TestFind2(t *testing.T) {
} }
type Team struct { type Team struct {
Id int64 ID int64
} }
type TeamUser struct { type TeamUser struct {
OrgId int64 OrgID int64
Uid int64 UID int64
TeamId int64 TeamID int64
} }
func (TeamUser) TableName() string { func (TeamUser) TableName() string {
@ -483,7 +483,7 @@ func TestFindMapPtrString(t *testing.T) {
func TestFindBit(t *testing.T) { func TestFindBit(t *testing.T) {
type FindBitStruct struct { type FindBitStruct struct {
Id int64 ID int64
Msg bool `xorm:"bit"` Msg bool `xorm:"bit"`
} }
@ -541,7 +541,7 @@ func TestFindMark(t *testing.T) {
func TestFindAndCountOneFunc(t *testing.T) { func TestFindAndCountOneFunc(t *testing.T) {
type FindAndCountStruct struct { type FindAndCountStruct struct {
Id int64 ID int64
Content string Content string
Msg bool `xorm:"bit"` Msg bool `xorm:"bit"`
} }
@ -604,7 +604,7 @@ func (device *FindMapDevice) TableName() string {
return "devices" return "devices"
} }
func TestFindMapStringId(t *testing.T) { func TestFindMapStringID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
assertSync(t, new(FindMapDevice)) assertSync(t, new(FindMapDevice))
@ -780,12 +780,12 @@ func TestFindCacheLimit(t *testing.T) {
func TestFindJoin(t *testing.T) { func TestFindJoin(t *testing.T) {
type SceneItem struct { type SceneItem struct {
Type int Type int
DeviceId int64 DeviceID int64
} }
type DeviceUserPrivrels struct { type DeviceUserPrivrels struct {
UserId int64 UserID int64
DeviceId int64 DeviceID int64
} }
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())

74
session_get_test.go
View File

@ -18,7 +18,7 @@ func TestGetVar(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type GetVar struct { type GetVar struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg string `xorm:"varchar(255)"` Msg string `xorm:"varchar(255)"`
Age int Age int
Money float32 Money float32
@ -61,7 +61,7 @@ func TestGetVar(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, true, has) assert.Equal(t, true, has)
assert.Equal(t, true, id.Valid) assert.Equal(t, true, id.Valid)
assert.EqualValues(t, data.Id, id.Int64) assert.EqualValues(t, data.ID, id.Int64)
var msgNull sql.NullString var msgNull sql.NullString
has, err = testEngine.Table("get_var").Cols("msg").Get(&msgNull) has, err = testEngine.Table("get_var").Cols("msg").Get(&msgNull)
@ -150,7 +150,7 @@ func TestGetStruct(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserinfoGet struct { type UserinfoGet struct {
Uid int `xorm:"pk autoincr"` UID int `xorm:"pk autoincr"`
IsMan bool IsMan bool
} }
@ -161,33 +161,33 @@ func TestGetStruct(t *testing.T) {
_, err = testEngine.Exec("SET IDENTITY_INSERT userinfo_get ON") _, err = testEngine.Exec("SET IDENTITY_INSERT userinfo_get ON")
assert.NoError(t, err) assert.NoError(t, err)
} }
cnt, err := testEngine.Insert(&UserinfoGet{Uid: 2}) cnt, err := testEngine.Insert(&UserinfoGet{UID: 2})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
user := UserinfoGet{Uid: 2} user := UserinfoGet{UID: 2}
has, err := testEngine.Get(&user) has, err := testEngine.Get(&user)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
type NoIdUser struct { type NoIDUser struct {
User string `xorm:"unique"` User string `xorm:"unique"`
Remain int64 Remain int64
Total int64 Total int64
} }
assert.NoError(t, testEngine.Sync2(&NoIdUser{})) assert.NoError(t, testEngine.Sync2(&NoIDUser{}))
userCol := testEngine.GetColumnMapper().Obj2Table("User") userCol := testEngine.GetColumnMapper().Obj2Table("User")
_, err = testEngine.Where("`"+userCol+"` = ?", "xlw").Delete(&NoIdUser{}) _, err = testEngine.Where("`"+userCol+"` = ?", "xlw").Delete(&NoIDUser{})
assert.NoError(t, err) assert.NoError(t, err)
cnt, err = testEngine.Insert(&NoIdUser{"xlw", 20, 100}) cnt, err = testEngine.Insert(&NoIDUser{"xlw", 20, 100})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
noIdUser := new(NoIdUser) noIDUser := new(NoIDUser)
has, err = testEngine.Where("`"+userCol+"` = ?", "xlw").Get(noIdUser) has, err = testEngine.Where("`"+userCol+"` = ?", "xlw").Get(noIDUser)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
} }
@ -196,7 +196,7 @@ func TestGetSlice(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserinfoSlice struct { type UserinfoSlice struct {
Uid int `xorm:"pk autoincr"` UID int `xorm:"pk autoincr"`
IsMan bool IsMan bool
} }
@ -212,7 +212,7 @@ func TestGetError(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type GetError struct { type GetError struct {
Uid int `xorm:"pk autoincr"` UID int `xorm:"pk autoincr"`
IsMan bool IsMan bool
} }
@ -231,30 +231,30 @@ func TestGetError(t *testing.T) {
func TestJSONString(t *testing.T) { func TestJSONString(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type JsonString struct { type JSONString struct {
Id int64 ID int64
Content string `xorm:"json"` Content string `xorm:"json"`
} }
type JsonJson struct { type JSONJSON struct {
Id int64 ID int64
Content []string `xorm:"json"` Content []string `xorm:"json"`
} }
assertSync(t, new(JsonJson)) assertSync(t, new(JSONJSON))
_, err := testEngine.Insert(&JsonJson{ _, err := testEngine.Insert(&JSONJSON{
Content: []string{"1", "2"}, Content: []string{"1", "2"},
}) })
assert.NoError(t, err) assert.NoError(t, err)
var js JsonString var js JSONString
has, err := testEngine.Table("json_json").Get(&js) has, err := testEngine.Table("json_json").Get(&js)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 1, js.Id) assert.EqualValues(t, 1, js.ID)
assert.EqualValues(t, `["1","2"]`, js.Content) assert.EqualValues(t, `["1","2"]`, js.Content)
var jss []JsonString var jss []JSONString
err = testEngine.Table("json_json").Find(&jss) err = testEngine.Table("json_json").Find(&jss)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, len(jss)) assert.EqualValues(t, 1, len(jss))
@ -265,10 +265,10 @@ func TestGetActionMapping(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type ActionMapping struct { type ActionMapping struct {
ActionId string `xorm:"pk"` ActionID string `xorm:"pk"`
ActionName string `xorm:"index"` ActionName string `xorm:"index"`
ScriptId string `xorm:"unique"` ScriptID string `xorm:"unique"`
RollbackId string `xorm:"unique"` RollbackID string `xorm:"unique"`
Env string Env string
Tags string Tags string
Description string Description string
@ -279,8 +279,8 @@ func TestGetActionMapping(t *testing.T) {
assertSync(t, new(ActionMapping)) assertSync(t, new(ActionMapping))
_, err := testEngine.Insert(&ActionMapping{ _, err := testEngine.Insert(&ActionMapping{
ActionId: "1", ActionID: "1",
ScriptId: "2", ScriptID: "2",
}) })
assert.NoError(t, err) assert.NoError(t, err)
@ -294,9 +294,9 @@ func TestGetActionMapping(t *testing.T) {
assert.EqualValues(t, "", valuesSlice[1]) assert.EqualValues(t, "", valuesSlice[1])
} }
func TestGetStructId(t *testing.T) { func TestGetStructID(t *testing.T) {
type TestGetStruct struct { type TestGetStruct struct {
Id int64 ID int64
} }
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
@ -308,7 +308,7 @@ func TestGetStructId(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
type maxidst struct { type maxidst struct {
Id int64 ID int64
} }
//var id int64 //var id int64
@ -317,12 +317,12 @@ func TestGetStructId(t *testing.T) {
has, err := testEngine.SQL(sql).Get(&maxid) has, err := testEngine.SQL(sql).Get(&maxid)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 2, maxid.Id) assert.EqualValues(t, 2, maxid.ID)
} }
func TestContextGet(t *testing.T) { func TestContextGet(t *testing.T) {
type ContextGetStruct struct { type ContextGetStruct struct {
Id int64 ID int64
Name string Name string
} }
@ -341,7 +341,7 @@ func TestContextGet(t *testing.T) {
has, err := sess.ID(1).NoCache().ContextCache(context).Get(&c2) has, err := sess.ID(1).NoCache().ContextCache(context).Get(&c2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 1, c2.Id) assert.EqualValues(t, 1, c2.ID)
assert.EqualValues(t, "1", c2.Name) assert.EqualValues(t, "1", c2.Name)
sql, args := sess.LastSQL() sql, args := sess.LastSQL()
assert.True(t, len(sql) > 0) assert.True(t, len(sql) > 0)
@ -351,7 +351,7 @@ func TestContextGet(t *testing.T) {
has, err = sess.ID(1).NoCache().ContextCache(context).Get(&c3) has, err = sess.ID(1).NoCache().ContextCache(context).Get(&c3)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 1, c3.Id) assert.EqualValues(t, 1, c3.ID)
assert.EqualValues(t, "1", c3.Name) assert.EqualValues(t, "1", c3.Name)
sql, args = sess.LastSQL() sql, args = sess.LastSQL()
assert.True(t, len(sql) == 0) assert.True(t, len(sql) == 0)
@ -360,7 +360,7 @@ func TestContextGet(t *testing.T) {
func TestContextGet2(t *testing.T) { func TestContextGet2(t *testing.T) {
type ContextGetStruct2 struct { type ContextGetStruct2 struct {
Id int64 ID int64
Name string Name string
} }
@ -376,13 +376,13 @@ func TestContextGet2(t *testing.T) {
has, err := testEngine.ID(1).NoCache().ContextCache(context).Get(&c2) has, err := testEngine.ID(1).NoCache().ContextCache(context).Get(&c2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 1, c2.Id) assert.EqualValues(t, 1, c2.ID)
assert.EqualValues(t, "1", c2.Name) assert.EqualValues(t, "1", c2.Name)
var c3 ContextGetStruct2 var c3 ContextGetStruct2
has, err = testEngine.ID(1).NoCache().ContextCache(context).Get(&c3) has, err = testEngine.ID(1).NoCache().ContextCache(context).Get(&c3)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 1, c3.Id) assert.EqualValues(t, 1, c3.ID)
assert.EqualValues(t, "1", c3.Name) assert.EqualValues(t, "1", c3.Name)
} }

90
session_insert_test.go
View File

@ -18,7 +18,7 @@ func TestInsertOne(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type Test struct { type Test struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg string `xorm:"varchar(255)"` Msg string `xorm:"varchar(255)"`
Created time.Time `xorm:"created"` Created time.Time `xorm:"created"`
} }
@ -34,7 +34,7 @@ func TestInsertMulti(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type TestMulti struct { type TestMulti struct {
Id int64 `xorm:"int(11) pk"` ID int64 `xorm:"int(11) pk"`
Name string `xorm:"varchar(255)"` Name string `xorm:"varchar(255)"`
} }
@ -110,7 +110,7 @@ func TestInsertOneIfPkIsPoint(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type TestPoint struct { type TestPoint struct {
Id *int64 `xorm:"autoincr pk notnull 'id'"` ID *int64 `xorm:"autoincr pk notnull 'id'"`
Msg *string `xorm:"varchar(255)"` Msg *string `xorm:"varchar(255)"`
Created *time.Time `xorm:"created"` Created *time.Time `xorm:"created"`
} }
@ -126,7 +126,7 @@ func TestInsertOneIfPkIsPointRename(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type ID *int64 type ID *int64
type TestPoint2 struct { type TestPoint2 struct {
Id ID `xorm:"autoincr pk notnull 'id'"` ID ID `xorm:"autoincr pk notnull 'id'"`
Msg *string `xorm:"varchar(255)"` Msg *string `xorm:"varchar(255)"`
Created *time.Time `xorm:"created"` Created *time.Time `xorm:"created"`
} }
@ -143,9 +143,9 @@ func TestInsert(t *testing.T) {
assertSync(t, new(Userinfo)) assertSync(t, new(Userinfo))
user := Userinfo{0, "xiaolunwen", "dev", "lunny", time.Now(), user := Userinfo{0, "xiaolunwen", "dev", "lunny", time.Now(),
Userdetail{Id: 1}, 1.78, []byte{1, 2, 3}, true} Userdetail{ID: 1}, 1.78, []byte{1, 2, 3}, true}
cnt, err := testEngine.Insert(&user) cnt, err := testEngine.Insert(&user)
fmt.Println(user.Uid) fmt.Println(user.UID)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -156,13 +156,13 @@ func TestInsert(t *testing.T) {
panic(err) panic(err)
} }
if user.Uid <= 0 { if user.UID <= 0 {
err = errors.New("not return id error") err = errors.New("not return id error")
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
user.Uid = 0 user.UID = 0
cnt, err = testEngine.Insert(&user) cnt, err = testEngine.Insert(&user)
if err == nil { if err == nil {
err = errors.New("insert failed but no return error") err = errors.New("insert failed but no return error")
@ -184,9 +184,9 @@ func TestInsertAutoIncr(t *testing.T) {
// auto increment insert // auto increment insert
user := Userinfo{Username: "xiaolunwen2", Departname: "dev", Alias: "lunny", Created: time.Now(), user := Userinfo{Username: "xiaolunwen2", Departname: "dev", Alias: "lunny", Created: time.Now(),
Detail: Userdetail{Id: 1}, Height: 1.78, Avatar: []byte{1, 2, 3}, IsMan: true} Detail: Userdetail{ID: 1}, Height: 1.78, Avatar: []byte{1, 2, 3}, IsMan: true}
cnt, err := testEngine.Insert(&user) cnt, err := testEngine.Insert(&user)
fmt.Println(user.Uid) fmt.Println(user.UID)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -196,13 +196,13 @@ func TestInsertAutoIncr(t *testing.T) {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if user.Uid <= 0 { if user.UID <= 0 {
t.Error(errors.New("not return id error")) t.Error(errors.New("not return id error"))
} }
} }
type DefaultInsert struct { type DefaultInsert struct {
Id int64 ID int64
Status int `xorm:"default -1"` Status int `xorm:"default -1"`
Name string Name string
Created time.Time `xorm:"created"` Created time.Time `xorm:"created"`
@ -251,9 +251,9 @@ func TestInsertDefault(t *testing.T) {
} }
type DefaultInsert2 struct { type DefaultInsert2 struct {
Id int64 ID int64
Name string Name string
Url string `xorm:"text"` URL string `xorm:"text"`
CheckTime time.Time `xorm:"not null default '2000-01-01 00:00:00' TIMESTAMP"` CheckTime time.Time `xorm:"not null default '2000-01-01 00:00:00' TIMESTAMP"`
} }
@ -312,32 +312,32 @@ func TestInsertDefault2(t *testing.T) {
} }
type CreatedInsert struct { type CreatedInsert struct {
Id int64 ID int64
Created time.Time `xorm:"created"` Created time.Time `xorm:"created"`
} }
type CreatedInsert2 struct { type CreatedInsert2 struct {
Id int64 ID int64
Created int64 `xorm:"created"` Created int64 `xorm:"created"`
} }
type CreatedInsert3 struct { type CreatedInsert3 struct {
Id int64 ID int64
Created int `xorm:"created bigint"` Created int `xorm:"created bigint"`
} }
type CreatedInsert4 struct { type CreatedInsert4 struct {
Id int64 ID int64
Created int `xorm:"created"` Created int `xorm:"created"`
} }
type CreatedInsert5 struct { type CreatedInsert5 struct {
Id int64 ID int64
Created time.Time `xorm:"created bigint"` Created time.Time `xorm:"created bigint"`
} }
type CreatedInsert6 struct { type CreatedInsert6 struct {
Id int64 ID int64
Created time.Time `xorm:"created bigint"` Created time.Time `xorm:"created bigint"`
} }
@ -480,9 +480,9 @@ func TestInsertCreated(t *testing.T) {
fmt.Println("ci6:", ci6, "di6:", di6) fmt.Println("ci6:", ci6, "di6:", di6)
} }
type JsonTime time.Time type JSONTime time.Time
func (j JsonTime) format() string { func (j JSONTime) format() string {
t := time.Time(j) t := time.Time(j)
if t.IsZero() { if t.IsZero() {
return "" return ""
@ -491,53 +491,53 @@ func (j JsonTime) format() string {
return t.Format("2006-01-02") return t.Format("2006-01-02")
} }
func (j JsonTime) MarshalText() ([]byte, error) { func (j JSONTime) MarshalText() ([]byte, error) {
return []byte(j.format()), nil return []byte(j.format()), nil
} }
func (j JsonTime) MarshalJSON() ([]byte, error) { func (j JSONTime) MarshalJSON() ([]byte, error) {
return []byte(`"` + j.format() + `"`), nil return []byte(`"` + j.format() + `"`), nil
} }
func TestDefaultTime3(t *testing.T) { func TestDefaultTime3(t *testing.T) {
type PrepareTask struct { type PrepareTask struct {
Id int `xorm:"not null pk autoincr INT(11)" json:"id"` ID int `xorm:"not null pk autoincr INT(11)" json:"id"`
// ... // ...
StartTime JsonTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP index" json:"start_time"` StartTime JSONTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP index" json:"start_time"`
EndTime JsonTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP" json:"end_time"` EndTime JSONTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP" json:"end_time"`
Cuser string `xorm:"not null default '' VARCHAR(64) index" json:"cuser"` Cuser string `xorm:"not null default '' VARCHAR(64) index" json:"cuser"`
Muser string `xorm:"not null default '' VARCHAR(64)" json:"muser"` Muser string `xorm:"not null default '' VARCHAR(64)" json:"muser"`
Ctime JsonTime `xorm:"not null default CURRENT_TIMESTAMP TIMESTAMP created" json:"ctime"` Ctime JSONTime `xorm:"not null default CURRENT_TIMESTAMP TIMESTAMP created" json:"ctime"`
Mtime JsonTime `xorm:"not null default CURRENT_TIMESTAMP TIMESTAMP updated" json:"mtime"` Mtime JSONTime `xorm:"not null default CURRENT_TIMESTAMP TIMESTAMP updated" json:"mtime"`
} }
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
assertSync(t, new(PrepareTask)) assertSync(t, new(PrepareTask))
prepareTask := &PrepareTask{ prepareTask := &PrepareTask{
StartTime: JsonTime(time.Now()), StartTime: JSONTime(time.Now()),
Cuser: "userId", Cuser: "userID",
Muser: "userId", Muser: "userID",
} }
cnt, err := testEngine.Omit("end_time").InsertOne(prepareTask) cnt, err := testEngine.Omit("end_time").InsertOne(prepareTask)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
} }
type MyJsonTime struct { type MyJSONTime struct {
Id int64 `json:"id"` ID int64 `json:"id"`
Created JsonTime `xorm:"created" json:"created_at"` Created JSONTime `xorm:"created" json:"created_at"`
} }
func TestCreatedJsonTime(t *testing.T) { func TestCreatedJSONTime(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
di5 := new(MyJsonTime) di5 := new(MyJSONTime)
err := testEngine.Sync2(di5) err := testEngine.Sync2(di5)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
ci5 := &MyJsonTime{} ci5 := &MyJSONTime{}
_, err = testEngine.Insert(ci5) _, err = testEngine.Insert(ci5)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -554,7 +554,7 @@ func TestCreatedJsonTime(t *testing.T) {
} }
fmt.Println("ci5:", ci5, "di5:", di5) fmt.Println("ci5:", ci5, "di5:", di5)
var dis = make([]MyJsonTime, 0) var dis = make([]MyJSONTime, 0)
err = testEngine.Find(&dis) err = testEngine.Find(&dis)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -598,7 +598,7 @@ func TestInsertMulti2(t *testing.T) {
} }
if cnt != int64(len(users2)) { if cnt != int64(len(users2)) {
err = errors.New(fmt.Sprintf("insert not returned %v", len(users2))) err = fmt.Errorf("insert not returned %v", len(users2))
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
@ -609,7 +609,7 @@ func TestInsertTwoTable(t *testing.T) {
assertSync(t, new(Userinfo), new(Userdetail)) assertSync(t, new(Userinfo), new(Userdetail))
userdetail := Userdetail{ /*Id: 1, */ Intro: "I'm a very beautiful women.", Profile: "sfsaf"} userdetail := Userdetail{ /*ID: 1, */ Intro: "I'm a very beautiful women.", Profile: "sfsaf"}
userinfo := Userinfo{Username: "xlw3", Departname: "dev", Alias: "lunny4", Created: time.Now(), Detail: userdetail} userinfo := Userinfo{Username: "xlw3", Departname: "dev", Alias: "lunny4", Created: time.Now(), Detail: userdetail}
cnt, err := testEngine.Insert(&userinfo, &userdetail) cnt, err := testEngine.Insert(&userinfo, &userdetail)
@ -618,13 +618,13 @@ func TestInsertTwoTable(t *testing.T) {
panic(err) panic(err)
} }
if userinfo.Uid <= 0 { if userinfo.UID <= 0 {
err = errors.New("not return id error") err = errors.New("not return id error")
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if userdetail.Id <= 0 { if userdetail.ID <= 0 {
err = errors.New("not return id error") err = errors.New("not return id error")
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -641,7 +641,7 @@ func TestInsertCreatedInt64(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type TestCreatedInt64 struct { type TestCreatedInt64 struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg string `xorm:"varchar(255)"` Msg string `xorm:"varchar(255)"`
Created int64 `xorm:"created"` Created int64 `xorm:"created"`
} }
@ -698,7 +698,7 @@ func TestInsertMulti3(t *testing.T) {
} }
type MyUserinfo2 struct { type MyUserinfo2 struct {
Uid int64 `xorm:"id pk not null autoincr"` UID int64 `xorm:"id pk not null autoincr"`
Username string `xorm:"unique"` Username string `xorm:"unique"`
Departname string Departname string
Alias string `xorm:"-"` Alias string `xorm:"-"`

12
session_iterate_test.go
View File

@ -14,7 +14,7 @@ func TestIterate(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserIterate struct { type UserIterate struct {
Id int64 ID int64
IsMan bool IsMan bool
} }
@ -29,7 +29,7 @@ func TestIterate(t *testing.T) {
cnt = 0 cnt = 0
err = testEngine.Iterate(new(UserIterate), func(i int, bean interface{}) error { err = testEngine.Iterate(new(UserIterate), func(i int, bean interface{}) error {
user := bean.(*UserIterate) user := bean.(*UserIterate)
assert.EqualValues(t, 1, user.Id) assert.EqualValues(t, 1, user.ID)
assert.EqualValues(t, true, user.IsMan) assert.EqualValues(t, true, user.IsMan)
cnt++ cnt++
return nil return nil
@ -42,7 +42,7 @@ func TestBufferIterate(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserBufferIterate struct { type UserBufferIterate struct {
Id int64 ID int64
IsMan bool IsMan bool
} }
@ -60,7 +60,7 @@ func TestBufferIterate(t *testing.T) {
var cnt = 0 var cnt = 0
err := testEngine.BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error { err := testEngine.BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error {
user := bean.(*UserBufferIterate) user := bean.(*UserBufferIterate)
assert.EqualValues(t, cnt+1, user.Id) assert.EqualValues(t, cnt+1, user.ID)
assert.EqualValues(t, true, user.IsMan) assert.EqualValues(t, true, user.IsMan)
cnt++ cnt++
return nil return nil
@ -71,7 +71,7 @@ func TestBufferIterate(t *testing.T) {
cnt = 0 cnt = 0
err = testEngine.Limit(20).BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error { err = testEngine.Limit(20).BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error {
user := bean.(*UserBufferIterate) user := bean.(*UserBufferIterate)
assert.EqualValues(t, cnt+1, user.Id) assert.EqualValues(t, cnt+1, user.ID)
assert.EqualValues(t, true, user.IsMan) assert.EqualValues(t, true, user.IsMan)
cnt++ cnt++
return nil return nil
@ -82,7 +82,7 @@ func TestBufferIterate(t *testing.T) {
cnt = 0 cnt = 0
err = testEngine.Limit(7).BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error { err = testEngine.Limit(7).BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error {
user := bean.(*UserBufferIterate) user := bean.(*UserBufferIterate)
assert.EqualValues(t, cnt+1, user.Id) assert.EqualValues(t, cnt+1, user.ID)
assert.EqualValues(t, true, user.IsMan) assert.EqualValues(t, true, user.IsMan)
cnt++ cnt++
return nil return nil

172
session_pk_test.go
View File

@ -13,43 +13,43 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
type IntId struct { type IntID struct {
Id int `xorm:"pk autoincr"` ID int `xorm:"pk autoincr"`
Name string Name string
} }
type Int16Id struct { type Int16ID struct {
Id int16 `xorm:"pk autoincr"` ID int16 `xorm:"pk autoincr"`
Name string Name string
} }
type Int32Id struct { type Int32ID struct {
Id int32 `xorm:"pk autoincr"` ID int32 `xorm:"pk autoincr"`
Name string Name string
} }
type UintId struct { type UintID struct {
Id uint `xorm:"pk autoincr"` ID uint `xorm:"pk autoincr"`
Name string Name string
} }
type Uint16Id struct { type Uint16ID struct {
Id uint16 `xorm:"pk autoincr"` ID uint16 `xorm:"pk autoincr"`
Name string Name string
} }
type Uint32Id struct { type Uint32ID struct {
Id uint32 `xorm:"pk autoincr"` ID uint32 `xorm:"pk autoincr"`
Name string Name string
} }
type Uint64Id struct { type Uint64ID struct {
Id uint64 `xorm:"pk autoincr"` ID uint64 `xorm:"pk autoincr"`
Name string Name string
} }
type StringPK struct { type StringPK struct {
Id string `xorm:"pk notnull"` ID string `xorm:"pk notnull"`
Name string Name string
} }
@ -65,22 +65,22 @@ type MyStringPK struct {
Name string Name string
} }
func TestIntId(t *testing.T) { func TestIntID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&IntId{}) err := testEngine.DropTables(&IntID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
err = testEngine.CreateTables(&IntId{}) err = testEngine.CreateTables(&IntID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
cnt, err := testEngine.Insert(&IntId{Name: "test"}) cnt, err := testEngine.Insert(&IntID{Name: "test"})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -91,7 +91,7 @@ func TestIntId(t *testing.T) {
panic(err) panic(err)
} }
bean := new(IntId) bean := new(IntID)
has, err := testEngine.Get(bean) has, err := testEngine.Get(bean)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -103,7 +103,7 @@ func TestIntId(t *testing.T) {
panic(err) panic(err)
} }
beans := make([]IntId, 0) beans := make([]IntID, 0)
err = testEngine.Find(&beans) err = testEngine.Find(&beans)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -115,7 +115,7 @@ func TestIntId(t *testing.T) {
panic(err) panic(err)
} }
beans2 := make(map[int]IntId) beans2 := make(map[int]IntID)
err = testEngine.Find(&beans2) err = testEngine.Find(&beans2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -127,7 +127,7 @@ func TestIntId(t *testing.T) {
panic(err) panic(err)
} }
cnt, err = testEngine.ID(bean.Id).Delete(&IntId{}) cnt, err = testEngine.ID(bean.ID).Delete(&IntID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -139,22 +139,22 @@ func TestIntId(t *testing.T) {
} }
} }
func TestInt16Id(t *testing.T) { func TestInt16ID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&Int16Id{}) err := testEngine.DropTables(&Int16ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
err = testEngine.CreateTables(&Int16Id{}) err = testEngine.CreateTables(&Int16ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
cnt, err := testEngine.Insert(&Int16Id{Name: "test"}) cnt, err := testEngine.Insert(&Int16ID{Name: "test"})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -166,7 +166,7 @@ func TestInt16Id(t *testing.T) {
panic(err) panic(err)
} }
bean := new(Int16Id) bean := new(Int16ID)
has, err := testEngine.Get(bean) has, err := testEngine.Get(bean)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -178,7 +178,7 @@ func TestInt16Id(t *testing.T) {
panic(err) panic(err)
} }
beans := make([]Int16Id, 0) beans := make([]Int16ID, 0)
err = testEngine.Find(&beans) err = testEngine.Find(&beans)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -190,7 +190,7 @@ func TestInt16Id(t *testing.T) {
panic(err) panic(err)
} }
beans2 := make(map[int16]Int16Id, 0) beans2 := make(map[int16]Int16ID, 0)
err = testEngine.Find(&beans2) err = testEngine.Find(&beans2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -202,7 +202,7 @@ func TestInt16Id(t *testing.T) {
panic(err) panic(err)
} }
cnt, err = testEngine.ID(bean.Id).Delete(&Int16Id{}) cnt, err = testEngine.ID(bean.ID).Delete(&Int16ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -214,22 +214,22 @@ func TestInt16Id(t *testing.T) {
} }
} }
func TestInt32Id(t *testing.T) { func TestInt32ID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&Int32Id{}) err := testEngine.DropTables(&Int32ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
err = testEngine.CreateTables(&Int32Id{}) err = testEngine.CreateTables(&Int32ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
cnt, err := testEngine.Insert(&Int32Id{Name: "test"}) cnt, err := testEngine.Insert(&Int32ID{Name: "test"})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -241,7 +241,7 @@ func TestInt32Id(t *testing.T) {
panic(err) panic(err)
} }
bean := new(Int32Id) bean := new(Int32ID)
has, err := testEngine.Get(bean) has, err := testEngine.Get(bean)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -253,7 +253,7 @@ func TestInt32Id(t *testing.T) {
panic(err) panic(err)
} }
beans := make([]Int32Id, 0) beans := make([]Int32ID, 0)
err = testEngine.Find(&beans) err = testEngine.Find(&beans)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -265,7 +265,7 @@ func TestInt32Id(t *testing.T) {
panic(err) panic(err)
} }
beans2 := make(map[int32]Int32Id, 0) beans2 := make(map[int32]Int32ID, 0)
err = testEngine.Find(&beans2) err = testEngine.Find(&beans2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -277,7 +277,7 @@ func TestInt32Id(t *testing.T) {
panic(err) panic(err)
} }
cnt, err = testEngine.ID(bean.Id).Delete(&Int32Id{}) cnt, err = testEngine.ID(bean.ID).Delete(&Int32ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -289,22 +289,22 @@ func TestInt32Id(t *testing.T) {
} }
} }
func TestUintId(t *testing.T) { func TestUintID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&UintId{}) err := testEngine.DropTables(&UintID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
err = testEngine.CreateTables(&UintId{}) err = testEngine.CreateTables(&UintID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
cnt, err := testEngine.Insert(&UintId{Name: "test"}) cnt, err := testEngine.Insert(&UintID{Name: "test"})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -315,7 +315,7 @@ func TestUintId(t *testing.T) {
panic(err) panic(err)
} }
var inserts = []UintId{ var inserts = []UintID{
{Name: "test1"}, {Name: "test1"},
{Name: "test2"}, {Name: "test2"},
} }
@ -330,7 +330,7 @@ func TestUintId(t *testing.T) {
panic(err) panic(err)
} }
bean := new(UintId) bean := new(UintID)
has, err := testEngine.Get(bean) has, err := testEngine.Get(bean)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -342,7 +342,7 @@ func TestUintId(t *testing.T) {
panic(err) panic(err)
} }
beans := make([]UintId, 0) beans := make([]UintID, 0)
err = testEngine.Find(&beans) err = testEngine.Find(&beans)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -354,7 +354,7 @@ func TestUintId(t *testing.T) {
panic(err) panic(err)
} }
beans2 := make(map[uint]UintId, 0) beans2 := make(map[uint]UintID, 0)
err = testEngine.Find(&beans2) err = testEngine.Find(&beans2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -366,7 +366,7 @@ func TestUintId(t *testing.T) {
panic(err) panic(err)
} }
cnt, err = testEngine.ID(bean.Id).Delete(&UintId{}) cnt, err = testEngine.ID(bean.ID).Delete(&UintID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -378,22 +378,22 @@ func TestUintId(t *testing.T) {
} }
} }
func TestUint16Id(t *testing.T) { func TestUint16ID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&Uint16Id{}) err := testEngine.DropTables(&Uint16ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
err = testEngine.CreateTables(&Uint16Id{}) err = testEngine.CreateTables(&Uint16ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
cnt, err := testEngine.Insert(&Uint16Id{Name: "test"}) cnt, err := testEngine.Insert(&Uint16ID{Name: "test"})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -405,7 +405,7 @@ func TestUint16Id(t *testing.T) {
panic(err) panic(err)
} }
bean := new(Uint16Id) bean := new(Uint16ID)
has, err := testEngine.Get(bean) has, err := testEngine.Get(bean)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -417,7 +417,7 @@ func TestUint16Id(t *testing.T) {
panic(err) panic(err)
} }
beans := make([]Uint16Id, 0) beans := make([]Uint16ID, 0)
err = testEngine.Find(&beans) err = testEngine.Find(&beans)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -429,7 +429,7 @@ func TestUint16Id(t *testing.T) {
panic(err) panic(err)
} }
beans2 := make(map[uint16]Uint16Id, 0) beans2 := make(map[uint16]Uint16ID, 0)
err = testEngine.Find(&beans2) err = testEngine.Find(&beans2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -441,7 +441,7 @@ func TestUint16Id(t *testing.T) {
panic(err) panic(err)
} }
cnt, err = testEngine.ID(bean.Id).Delete(&Uint16Id{}) cnt, err = testEngine.ID(bean.ID).Delete(&Uint16ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -453,22 +453,22 @@ func TestUint16Id(t *testing.T) {
} }
} }
func TestUint32Id(t *testing.T) { func TestUint32ID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&Uint32Id{}) err := testEngine.DropTables(&Uint32ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
err = testEngine.CreateTables(&Uint32Id{}) err = testEngine.CreateTables(&Uint32ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
cnt, err := testEngine.Insert(&Uint32Id{Name: "test"}) cnt, err := testEngine.Insert(&Uint32ID{Name: "test"})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -480,7 +480,7 @@ func TestUint32Id(t *testing.T) {
panic(err) panic(err)
} }
bean := new(Uint32Id) bean := new(Uint32ID)
has, err := testEngine.Get(bean) has, err := testEngine.Get(bean)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -492,7 +492,7 @@ func TestUint32Id(t *testing.T) {
panic(err) panic(err)
} }
beans := make([]Uint32Id, 0) beans := make([]Uint32ID, 0)
err = testEngine.Find(&beans) err = testEngine.Find(&beans)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -504,7 +504,7 @@ func TestUint32Id(t *testing.T) {
panic(err) panic(err)
} }
beans2 := make(map[uint32]Uint32Id, 0) beans2 := make(map[uint32]Uint32ID, 0)
err = testEngine.Find(&beans2) err = testEngine.Find(&beans2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -516,7 +516,7 @@ func TestUint32Id(t *testing.T) {
panic(err) panic(err)
} }
cnt, err = testEngine.ID(bean.Id).Delete(&Uint32Id{}) cnt, err = testEngine.ID(bean.ID).Delete(&Uint32ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -528,22 +528,22 @@ func TestUint32Id(t *testing.T) {
} }
} }
func TestUint64Id(t *testing.T) { func TestUint64ID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&Uint64Id{}) err := testEngine.DropTables(&Uint64ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
err = testEngine.CreateTables(&Uint64Id{}) err = testEngine.CreateTables(&Uint64ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
idbean := &Uint64Id{Name: "test"} idbean := &Uint64ID{Name: "test"}
cnt, err := testEngine.Insert(idbean) cnt, err := testEngine.Insert(idbean)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -556,7 +556,7 @@ func TestUint64Id(t *testing.T) {
panic(err) panic(err)
} }
bean := new(Uint64Id) bean := new(Uint64ID)
has, err := testEngine.Get(bean) has, err := testEngine.Get(bean)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -568,11 +568,11 @@ func TestUint64Id(t *testing.T) {
panic(err) panic(err)
} }
if bean.Id != idbean.Id { if bean.ID != idbean.ID {
panic(errors.New("should be equal")) panic(errors.New("should be equal"))
} }
beans := make([]Uint64Id, 0) beans := make([]Uint64ID, 0)
err = testEngine.Find(&beans) err = testEngine.Find(&beans)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -588,7 +588,7 @@ func TestUint64Id(t *testing.T) {
panic(errors.New("should be equal")) panic(errors.New("should be equal"))
} }
beans2 := make(map[uint64]Uint64Id, 0) beans2 := make(map[uint64]Uint64ID, 0)
err = testEngine.Find(&beans2) err = testEngine.Find(&beans2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -600,11 +600,11 @@ func TestUint64Id(t *testing.T) {
panic(err) panic(err)
} }
if *bean != beans2[bean.Id] { if *bean != beans2[bean.ID] {
panic(errors.New("should be equal")) panic(errors.New("should be equal"))
} }
cnt, err = testEngine.ID(bean.Id).Delete(&Uint64Id{}) cnt, err = testEngine.ID(bean.ID).Delete(&Uint64ID{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -631,7 +631,7 @@ func TestStringPK(t *testing.T) {
panic(err) panic(err)
} }
cnt, err := testEngine.Insert(&StringPK{Id: "1-1-2", Name: "test"}) cnt, err := testEngine.Insert(&StringPK{ID: "1-1-2", Name: "test"})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -679,7 +679,7 @@ func TestStringPK(t *testing.T) {
panic(err) panic(err)
} }
cnt, err = testEngine.ID(bean.Id).Delete(&StringPK{}) cnt, err = testEngine.ID(bean.ID).Delete(&StringPK{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -692,8 +692,8 @@ func TestStringPK(t *testing.T) {
} }
type CompositeKey struct { type CompositeKey struct {
Id1 int64 `xorm:"id1 pk"` ID1 int64 `xorm:"id1 pk"`
Id2 int64 `xorm:"id2 pk"` ID2 int64 `xorm:"id2 pk"`
UpdateStr string UpdateStr string
} }
@ -790,9 +790,9 @@ func TestCompositeKey2(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type User struct { type User struct {
UserId string `xorm:"varchar(19) not null pk"` UserID string `xorm:"varchar(19) not null pk"`
NickName string `xorm:"varchar(19) not null"` NickName string `xorm:"varchar(19) not null"`
GameId uint32 `xorm:"integer pk"` GameID uint32 `xorm:"integer pk"`
Score int32 `xorm:"integer"` Score int32 `xorm:"integer"`
} }
@ -855,9 +855,9 @@ func TestCompositeKey2(t *testing.T) {
type MyString string type MyString string
type UserPK2 struct { type UserPK2 struct {
UserId MyString `xorm:"varchar(19) not null pk"` UserID MyString `xorm:"varchar(19) not null pk"`
NickName string `xorm:"varchar(19) not null"` NickName string `xorm:"varchar(19) not null"`
GameId uint32 `xorm:"integer pk"` GameID uint32 `xorm:"integer pk"`
Score int32 `xorm:"integer"` Score int32 `xorm:"integer"`
} }
@ -921,7 +921,7 @@ func TestCompositeKey3(t *testing.T) {
} }
} }
func TestMyIntId(t *testing.T) { func TestMyIntID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&MyIntPK{}) err := testEngine.DropTables(&MyIntPK{})
@ -1009,7 +1009,7 @@ func TestMyIntId(t *testing.T) {
} }
} }
func TestMyStringId(t *testing.T) { func TestMyStringID(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&MyStringPK{}) err := testEngine.DropTables(&MyStringPK{})
@ -1099,7 +1099,7 @@ func TestMyStringId(t *testing.T) {
func TestSingleAutoIncrColumn(t *testing.T) { func TestSingleAutoIncrColumn(t *testing.T) {
type Account struct { type Account struct {
Id int64 `xorm:"pk autoincr"` ID int64 `xorm:"pk autoincr"`
} }
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
@ -1145,7 +1145,7 @@ func TestCompositePK(t *testing.T) {
assert.EqualValues(t, "tid", pkCols[1].Name) assert.EqualValues(t, "tid", pkCols[1].Name)
} }
func TestNoPKIdQueryUpdate(t *testing.T) { func TestNoPKIDQueryUpdate(t *testing.T) {
type NoPKTable struct { type NoPKTable struct {
Username string Username string
} }

14
session_query_test.go
View File

@ -20,7 +20,7 @@ func TestQueryString(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type GetVar2 struct { type GetVar2 struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg string `xorm:"varchar(255)"` Msg string `xorm:"varchar(255)"`
Age int Age int
Money float32 Money float32
@ -51,7 +51,7 @@ func TestQueryString2(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type GetVar3 struct { type GetVar3 struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg bool `xorm:"bit"` Msg bool `xorm:"bit"`
} }
@ -111,7 +111,7 @@ func TestQueryInterface(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type GetVarInterface struct { type GetVarInterface struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg string `xorm:"varchar(255)"` Msg string `xorm:"varchar(255)"`
Age int Age int
Money float32 Money float32
@ -142,7 +142,7 @@ func TestQueryNoParams(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type QueryNoParams struct { type QueryNoParams struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg string `xorm:"varchar(255)"` Msg string `xorm:"varchar(255)"`
Age int Age int
Money float32 Money float32
@ -191,7 +191,7 @@ func TestQueryStringNoParam(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type GetVar4 struct { type GetVar4 struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg bool `xorm:"bit"` Msg bool `xorm:"bit"`
} }
@ -228,7 +228,7 @@ func TestQueryInterfaceNoParam(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type GetVar5 struct { type GetVar5 struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg bool `xorm:"bit"` Msg bool `xorm:"bit"`
} }
@ -257,7 +257,7 @@ func TestQueryWithBuilder(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type QueryWithBuilder struct { type QueryWithBuilder struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg string `xorm:"varchar(255)"` Msg string `xorm:"varchar(255)"`
Age int Age int
Money float32 Money float32

2
session_raw_test.go
View File

@ -15,7 +15,7 @@ func TestExecAndQuery(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserinfoQuery struct { type UserinfoQuery struct {
Uid int UID int
Name string Name string
} }

38
session_schema_test.go
View File

@ -19,7 +19,7 @@ func TestStoreEngine(t *testing.T) {
assert.NoError(t, testEngine.DropTables("user_store_engine")) assert.NoError(t, testEngine.DropTables("user_store_engine"))
type UserinfoStoreEngine struct { type UserinfoStoreEngine struct {
Id int64 ID int64
Name string Name string
} }
@ -32,7 +32,7 @@ func TestCreateTable(t *testing.T) {
assert.NoError(t, testEngine.DropTables("user_user")) assert.NoError(t, testEngine.DropTables("user_user"))
type UserinfoCreateTable struct { type UserinfoCreateTable struct {
Id int64 ID int64
Name string Name string
} }
@ -46,7 +46,7 @@ func TestCreateMultiTables(t *testing.T) {
defer session.Close() defer session.Close()
type UserinfoMultiTable struct { type UserinfoMultiTable struct {
Id int64 ID int64
Name string Name string
} }
@ -65,13 +65,13 @@ func TestCreateMultiTables(t *testing.T) {
} }
type SyncTable1 struct { type SyncTable1 struct {
Id int64 ID int64
Name string Name string
Dev int `xorm:"index"` Dev int `xorm:"index"`
} }
type SyncTable2 struct { type SyncTable2 struct {
Id int64 ID int64
Name string `xorm:"unique"` Name string `xorm:"unique"`
Number string `xorm:"index"` Number string `xorm:"index"`
Dev int Dev int
@ -83,7 +83,7 @@ func (SyncTable2) TableName() string {
} }
type SyncTable3 struct { type SyncTable3 struct {
Id int64 ID int64
Name string `xorm:"unique"` Name string `xorm:"unique"`
Number string `xorm:"index"` Number string `xorm:"index"`
Dev int Dev int
@ -141,16 +141,16 @@ func TestIsTableEmpty(t *testing.T) {
} }
type PictureEmpty struct { type PictureEmpty struct {
Id int64 ID int64
Url string `xorm:"unique"` //image's url URL string `xorm:"unique"` //image's url
Title string Title string
Description string Description string
Created time.Time `xorm:"created"` Created time.Time `xorm:"created"`
ILike int ILike int
PageView int PageView int
From_url string FormURL string
Pre_url string `xorm:"unique"` //pre view image's url PreURL string `xorm:"unique"` //pre view image's url
Uid int64 UID int64
} }
assert.NoError(t, testEngine.DropTables(&PictureEmpty{}, &NumericEmpty{})) assert.NoError(t, testEngine.DropTables(&PictureEmpty{}, &NumericEmpty{}))
@ -168,7 +168,7 @@ func TestIsTableEmpty(t *testing.T) {
} }
type CustomTableName struct { type CustomTableName struct {
Id int64 ID int64
Name string Name string
} }
@ -194,7 +194,7 @@ func TestDump(t *testing.T) {
} }
type IndexOrUnique struct { type IndexOrUnique struct {
Id int64 ID int64
Index int `xorm:"index"` Index int `xorm:"index"`
Unique int `xorm:"unique"` Unique int `xorm:"unique"`
Group1 int `xorm:"index(ttt)"` Group1 int `xorm:"index(ttt)"`
@ -249,9 +249,9 @@ func TestCharst(t *testing.T) {
func TestSync2_1(t *testing.T) { func TestSync2_1(t *testing.T) {
type WxTest struct { type WxTest struct {
Id int `xorm:"not null pk autoincr INT(64)` ID int `xorm:"not null pk autoincr INT(64)`
Passport_user_type int16 `xorm:"null int"` PassportUserType int16 `xorm:"null int"`
Id_delete int8 `xorm:"null int default 1"` IDDelete int8 `xorm:"null int default 1"`
} }
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
@ -263,7 +263,7 @@ func TestSync2_1(t *testing.T) {
func TestUnique_1(t *testing.T) { func TestUnique_1(t *testing.T) {
type UserUnique struct { type UserUnique struct {
Id int64 ID int64
UserName string `xorm:"unique varchar(25) not null"` UserName string `xorm:"unique varchar(25) not null"`
Password string `xorm:"varchar(255) not null"` Password string `xorm:"varchar(255) not null"`
Admin bool `xorm:"not null"` Admin bool `xorm:"not null"`
@ -283,8 +283,8 @@ func TestUnique_1(t *testing.T) {
func TestSync2_2(t *testing.T) { func TestSync2_2(t *testing.T) {
type TestSync2Index struct { type TestSync2Index struct {
Id int64 ID int64
UserId int64 `xorm:"index"` UserID int64 `xorm:"index"`
} }
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())

6
session_stats_test.go
View File

@ -141,12 +141,12 @@ func TestSQLCount(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserinfoCount2 struct { type UserinfoCount2 struct {
Id int64 ID int64
Departname string Departname string
} }
type UserinfoBooks struct { type UserinfoBooks struct {
Id int64 ID int64
Pid int64 Pid int64
IsOpen bool IsOpen bool
} }
@ -163,7 +163,7 @@ func TestCountWithOthers(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type CountWithOthers struct { type CountWithOthers struct {
Id int64 ID int64
Name string Name string
} }

4
session_tx_test.go
View File

@ -133,7 +133,7 @@ func TestMultipleTransaction(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type MultipleTransaction struct { type MultipleTransaction struct {
Id int64 ID int64
Name string Name string
} }
@ -164,7 +164,7 @@ func TestMultipleTransaction(t *testing.T) {
err = session.Begin() err = session.Begin()
assert.NoError(t, err) assert.NoError(t, err)
_, err = session.Where("id=?", m1.Id).Delete(new(MultipleTransaction)) _, err = session.Where("id=?", m1.ID).Delete(new(MultipleTransaction))
assert.NoError(t, err) assert.NoError(t, err)
err = session.Commit() err = session.Commit()

150
session_update_test.go
View File

@ -19,7 +19,7 @@ func TestUpdateMap(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UpdateTable struct { type UpdateTable struct {
Id int64 ID int64
Name string Name string
Age int Age int
} }
@ -32,7 +32,7 @@ func TestUpdateMap(t *testing.T) {
_, err := testEngine.Insert(&tb) _, err := testEngine.Insert(&tb)
assert.NoError(t, err) assert.NoError(t, err)
cnt, err := testEngine.Table("update_table").Where("id = ?", tb.Id).Update(map[string]interface{}{ cnt, err := testEngine.Table("update_table").Where("id = ?", tb.ID).Update(map[string]interface{}{
"name": "test2", "name": "test2",
"age": 36, "age": 36,
}) })
@ -44,7 +44,7 @@ func TestUpdateLimit(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UpdateTable2 struct { type UpdateTable2 struct {
Id int64 ID int64
Name string Name string
Age int Age int
} }
@ -59,7 +59,7 @@ func TestUpdateLimit(t *testing.T) {
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
tb.Name = "test2" tb.Name = "test2"
tb.Id = 0 tb.ID = 0
cnt, err = testEngine.Insert(&tb) cnt, err = testEngine.Insert(&tb)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
@ -79,7 +79,7 @@ func TestUpdateLimit(t *testing.T) {
} }
type ForUpdate struct { type ForUpdate struct {
Id int64 `xorm:"pk"` ID int64 `xorm:"pk"`
Name string Name string
} }
@ -208,7 +208,7 @@ func TestForUpdate(t *testing.T) {
func TestWithIn(t *testing.T) { func TestWithIn(t *testing.T) {
type temp3 struct { type temp3 struct {
Id int64 `xorm:"Id pk autoincr"` ID int64 `xorm:"ID pk autoincr"`
Name string `xorm:"Name"` Name string `xorm:"Name"`
Test bool `xorm:"Test"` Test bool `xorm:"Test"`
} }
@ -228,7 +228,7 @@ func TestWithIn(t *testing.T) {
}, },
}) })
cnt, err := testEngine.In("Id", 1, 2, 3, 4).Update(&temp3{Name: "aa"}, &temp3{Name: "user1"}) cnt, err := testEngine.In("ID", 1, 2, 3, 4).Update(&temp3{Name: "aa"}, &temp3{Name: "user1"})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 3, cnt) assert.EqualValues(t, 3, cnt)
} }
@ -236,26 +236,26 @@ func TestWithIn(t *testing.T) {
type Condi map[string]interface{} type Condi map[string]interface{}
type UpdateAllCols struct { type UpdateAllCols struct {
Id int64 ID int64
Bool bool Bool bool
String string String string
Ptr *string Ptr *string
} }
type UpdateMustCols struct { type UpdateMustCols struct {
Id int64 ID int64
Bool bool Bool bool
String string String string
} }
type UpdateIncr struct { type UpdateIncr struct {
Id int64 ID int64
Cnt int Cnt int
Name string Name string
} }
type Article struct { type Article struct {
Id int32 `xorm:"pk INT autoincr"` ID int32 `xorm:"pk INT autoincr"`
Name string `xorm:"VARCHAR(45)"` Name string `xorm:"VARCHAR(45)"`
Img string `xorm:"VARCHAR(100)"` Img string `xorm:"VARCHAR(100)"`
Aside string `xorm:"VARCHAR(200)"` Aside string `xorm:"VARCHAR(200)"`
@ -434,25 +434,25 @@ func TestUpdate1(t *testing.T) {
} }
if cnt != 1 { if cnt != 1 {
err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) err = fmt.Errorf("insert not returned 1 but %d", cnt)
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if a.Id == 0 { if a.ID == 0 {
err = errors.New("insert returned id is 0") err = errors.New("insert returned id is 0")
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
cnt, err = testEngine.ID(a.Id).Update(&Article{Name: "6"}) cnt, err = testEngine.ID(a.ID).Update(&Article{Name: "6"})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if cnt != 1 { if cnt != 1 {
err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) err = fmt.Errorf("insert not returned 1 but %d", cnt)
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
@ -467,23 +467,23 @@ func TestUpdate1(t *testing.T) {
_, err = testEngine.Insert(col1) _, err = testEngine.Insert(col1)
assert.NoError(t, err) assert.NoError(t, err)
col2 := &UpdateAllCols{col1.Id, true, "", nil} col2 := &UpdateAllCols{col1.ID, true, "", nil}
_, err = testEngine.ID(col2.Id).AllCols().Update(col2) _, err = testEngine.ID(col2.ID).AllCols().Update(col2)
assert.NoError(t, err) assert.NoError(t, err)
col3 := &UpdateAllCols{} col3 := &UpdateAllCols{}
has, err = testEngine.ID(col2.Id).Get(col3) has, err = testEngine.ID(col2.ID).Get(col3)
assert.NoError(t, err) assert.NoError(t, err)
if !has { if !has {
err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) err = fmt.Errorf("cannot get id %d", col2.ID)
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
} }
if *col2 != *col3 { if *col2 != *col3 {
err = errors.New(fmt.Sprintf("col2 should eq col3")) err = fmt.Errorf("col2 should eq col3")
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
@ -504,31 +504,31 @@ func TestUpdate1(t *testing.T) {
panic(err) panic(err)
} }
col2 := &UpdateMustCols{col1.Id, true, ""} col2 := &UpdateMustCols{col1.ID, true, ""}
boolStr := testEngine.GetColumnMapper().Obj2Table("Bool") boolStr := testEngine.GetColumnMapper().Obj2Table("Bool")
stringStr := testEngine.GetColumnMapper().Obj2Table("String") stringStr := testEngine.GetColumnMapper().Obj2Table("String")
_, err = testEngine.ID(col2.Id).MustCols(boolStr, stringStr).Update(col2) _, err = testEngine.ID(col2.ID).MustCols(boolStr, stringStr).Update(col2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
col3 := &UpdateMustCols{} col3 := &UpdateMustCols{}
has, err := testEngine.ID(col2.Id).Get(col3) has, err := testEngine.ID(col2.ID).Get(col3)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if !has { if !has {
err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) err = fmt.Errorf("cannot get id %d", col2.ID)
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
} }
if *col2 != *col3 { if *col2 != *col3 {
err = errors.New(fmt.Sprintf("col2 should eq col3")) err = fmt.Errorf("col2 should eq col3")
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
@ -549,53 +549,53 @@ func TestUpdateIncrDecr(t *testing.T) {
colName := testEngine.GetColumnMapper().Obj2Table("Cnt") colName := testEngine.GetColumnMapper().Obj2Table("Cnt")
cnt, err := testEngine.ID(col1.Id).Incr(colName).Update(col1) cnt, err := testEngine.ID(col1.ID).Incr(colName).Update(col1)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
newCol := new(UpdateIncr) newCol := new(UpdateIncr)
has, err := testEngine.ID(col1.Id).Get(newCol) has, err := testEngine.ID(col1.ID).Get(newCol)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 1, newCol.Cnt) assert.EqualValues(t, 1, newCol.Cnt)
cnt, err = testEngine.ID(col1.Id).Decr(colName).Update(col1) cnt, err = testEngine.ID(col1.ID).Decr(colName).Update(col1)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
newCol = new(UpdateIncr) newCol = new(UpdateIncr)
has, err = testEngine.ID(col1.Id).Get(newCol) has, err = testEngine.ID(col1.ID).Get(newCol)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 0, newCol.Cnt) assert.EqualValues(t, 0, newCol.Cnt)
cnt, err = testEngine.ID(col1.Id).Cols(colName).Incr(colName).Update(col1) cnt, err = testEngine.ID(col1.ID).Cols(colName).Incr(colName).Update(col1)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
} }
type UpdatedUpdate struct { type UpdatedUpdate struct {
Id int64 ID int64
Updated time.Time `xorm:"updated"` Updated time.Time `xorm:"updated"`
} }
type UpdatedUpdate2 struct { type UpdatedUpdate2 struct {
Id int64 ID int64
Updated int64 `xorm:"updated"` Updated int64 `xorm:"updated"`
} }
type UpdatedUpdate3 struct { type UpdatedUpdate3 struct {
Id int64 ID int64
Updated int `xorm:"updated bigint"` Updated int `xorm:"updated bigint"`
} }
type UpdatedUpdate4 struct { type UpdatedUpdate4 struct {
Id int64 ID int64
Updated int `xorm:"updated"` Updated int `xorm:"updated"`
} }
type UpdatedUpdate5 struct { type UpdatedUpdate5 struct {
Id int64 ID int64
Updated time.Time `xorm:"updated bigint"` Updated time.Time `xorm:"updated bigint"`
} }
@ -643,7 +643,7 @@ func TestUpdateUpdated(t *testing.T) {
assert.True(t, now.Unix() <= di20.Updated) assert.True(t, now.Unix() <= di20.Updated)
var di21 UpdatedUpdate2 var di21 UpdatedUpdate2
has, err = testEngine.ID(di20.Id).Get(&di21) has, err = testEngine.ID(di20.ID).Get(&di21)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, di20.Updated, di21.Updated) assert.EqualValues(t, di20.Updated, di21.Updated)
@ -808,22 +808,22 @@ func TestUpdateSameMapper(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
if cnt != 1 { if cnt != 1 {
err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) err = fmt.Errorf("insert not returned 1 but %d", cnt)
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if a.Id == 0 { if a.ID == 0 {
err = errors.New("insert returned id is 0") err = errors.New("insert returned id is 0")
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
cnt, err = testEngine.ID(a.Id).Update(&Article{Name: "6"}) cnt, err = testEngine.ID(a.ID).Update(&Article{Name: "6"})
assert.NoError(t, err) assert.NoError(t, err)
if cnt != 1 { if cnt != 1 {
err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) err = fmt.Errorf("insert not returned 1 but %d", cnt)
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
@ -836,23 +836,23 @@ func TestUpdateSameMapper(t *testing.T) {
_, err = testEngine.Insert(col1) _, err = testEngine.Insert(col1)
assert.NoError(t, err) assert.NoError(t, err)
col2 := &UpdateAllCols{col1.Id, true, "", nil} col2 := &UpdateAllCols{col1.ID, true, "", nil}
_, err = testEngine.ID(col2.Id).AllCols().Update(col2) _, err = testEngine.ID(col2.ID).AllCols().Update(col2)
assert.NoError(t, err) assert.NoError(t, err)
col3 := &UpdateAllCols{} col3 := &UpdateAllCols{}
has, err = testEngine.ID(col2.Id).Get(col3) has, err = testEngine.ID(col2.ID).Get(col3)
assert.NoError(t, err) assert.NoError(t, err)
if !has { if !has {
err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) err = fmt.Errorf("cannot get id %d", col2.ID)
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
} }
if *col2 != *col3 { if *col2 != *col3 {
err = errors.New(fmt.Sprintf("col2 should eq col3")) err = fmt.Errorf("col2 should eq col3")
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
@ -866,25 +866,25 @@ func TestUpdateSameMapper(t *testing.T) {
_, err = testEngine.Insert(col1) _, err = testEngine.Insert(col1)
assert.NoError(t, err) assert.NoError(t, err)
col2 := &UpdateMustCols{col1.Id, true, ""} col2 := &UpdateMustCols{col1.ID, true, ""}
boolStr := testEngine.GetColumnMapper().Obj2Table("Bool") boolStr := testEngine.GetColumnMapper().Obj2Table("Bool")
stringStr := testEngine.GetColumnMapper().Obj2Table("String") stringStr := testEngine.GetColumnMapper().Obj2Table("String")
_, err = testEngine.ID(col2.Id).MustCols(boolStr, stringStr).Update(col2) _, err = testEngine.ID(col2.ID).MustCols(boolStr, stringStr).Update(col2)
assert.NoError(t, err) assert.NoError(t, err)
col3 := &UpdateMustCols{} col3 := &UpdateMustCols{}
has, err := testEngine.ID(col2.Id).Get(col3) has, err := testEngine.ID(col2.ID).Get(col3)
assert.NoError(t, err) assert.NoError(t, err)
if !has { if !has {
err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) err = fmt.Errorf("cannot get id %d", col2.ID)
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
} }
if *col2 != *col3 { if *col2 != *col3 {
err = errors.New(fmt.Sprintf("col2 should eq col3")) err = fmt.Errorf("col2 should eq col3")
t.Error(err) t.Error(err)
panic(err) panic(err)
return return
@ -905,7 +905,7 @@ func TestUpdateSameMapper(t *testing.T) {
panic(err) panic(err)
} }
cnt, err := testEngine.ID(col1.Id).Incr("`Cnt`").Update(col1) cnt, err := testEngine.ID(col1.ID).Incr("`Cnt`").Update(col1)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -917,7 +917,7 @@ func TestUpdateSameMapper(t *testing.T) {
} }
newCol := new(UpdateIncr) newCol := new(UpdateIncr)
has, err := testEngine.ID(col1.Id).Get(newCol) has, err := testEngine.ID(col1.ID).Get(newCol)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -954,7 +954,7 @@ func TestUseBool(t *testing.T) {
var fNumber int64 var fNumber int64
for _, u := range users { for _, u := range users {
if u.IsMan == false { if u.IsMan == false {
fNumber += 1 fNumber++
} }
} }
@ -1025,7 +1025,7 @@ func TestNoUpdate(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type NoUpdate struct { type NoUpdate struct {
Id int64 ID int64
Content string Content string
} }
@ -1046,7 +1046,7 @@ func TestNewUpdate(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type TbUserInfo struct { type TbUserInfo struct {
Id int64 `xorm:"pk autoincr unique BIGINT" json:"id"` ID int64 `xorm:"pk autoincr unique BIGINT" json:"id"`
Phone string `xorm:"not null unique VARCHAR(20)" json:"phone"` Phone string `xorm:"not null unique VARCHAR(20)" json:"phone"`
UserName string `xorm:"VARCHAR(20)" json:"user_name"` UserName string `xorm:"VARCHAR(20)" json:"user_name"`
Gender int `xorm:"default 0 INTEGER" json:"gender"` Gender int `xorm:"default 0 INTEGER" json:"gender"`
@ -1076,7 +1076,7 @@ func TestUpdateUpdate(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type PublicKeyUpdate struct { type PublicKeyUpdate struct {
Id int64 ID int64
UpdatedUnix int64 `xorm:"updated"` UpdatedUnix int64 `xorm:"updated"`
} }
@ -1093,7 +1093,7 @@ func TestCreatedUpdated2(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type CreatedUpdatedStruct struct { type CreatedUpdatedStruct struct {
Id int64 ID int64
Name string Name string
CreateAt time.Time `xorm:"created" json:"create_at"` CreateAt time.Time `xorm:"created" json:"create_at"`
UpdateAt time.Time `xorm:"updated" json:"update_at"` UpdateAt time.Time `xorm:"updated" json:"update_at"`
@ -1137,7 +1137,7 @@ func TestDeletedUpdate(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type DeletedUpdatedStruct struct { type DeletedUpdatedStruct struct {
Id int64 ID int64
Name string Name string
DeletedAt time.Time `xorm:"deleted"` DeletedAt time.Time `xorm:"deleted"`
} }
@ -1151,7 +1151,7 @@ func TestDeletedUpdate(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
cnt, err = testEngine.ID(s.Id).Delete(&DeletedUpdatedStruct{}) cnt, err = testEngine.ID(s.ID).Delete(&DeletedUpdatedStruct{})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
@ -1161,23 +1161,23 @@ func TestDeletedUpdate(t *testing.T) {
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var s1 DeletedUpdatedStruct var s1 DeletedUpdatedStruct
has, err := testEngine.ID(s.Id).Get(&s1) has, err := testEngine.ID(s.ID).Get(&s1)
assert.EqualValues(t, true, has) assert.EqualValues(t, true, has)
cnt, err = testEngine.ID(s.Id).Delete(&DeletedUpdatedStruct{}) cnt, err = testEngine.ID(s.ID).Delete(&DeletedUpdatedStruct{})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
cnt, err = testEngine.ID(s.Id).Cols("deleted_at").Update(&DeletedUpdatedStruct{}) cnt, err = testEngine.ID(s.ID).Cols("deleted_at").Update(&DeletedUpdatedStruct{})
assert.EqualValues(t, "No content found to be updated", err.Error()) assert.EqualValues(t, "No content found to be updated", err.Error())
assert.EqualValues(t, 0, cnt) assert.EqualValues(t, 0, cnt)
cnt, err = testEngine.ID(s.Id).Unscoped().Cols("deleted_at").Update(&DeletedUpdatedStruct{}) cnt, err = testEngine.ID(s.ID).Unscoped().Cols("deleted_at").Update(&DeletedUpdatedStruct{})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var s2 DeletedUpdatedStruct var s2 DeletedUpdatedStruct
has, err = testEngine.ID(s.Id).Get(&s2) has, err = testEngine.ID(s.ID).Get(&s2)
assert.EqualValues(t, true, has) assert.EqualValues(t, true, has)
} }
@ -1185,7 +1185,7 @@ func TestUpdateMapCondition(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UpdateMapCondition struct { type UpdateMapCondition struct {
Id int64 ID int64
String string String string
} }
@ -1200,13 +1200,13 @@ func TestUpdateMapCondition(t *testing.T) {
cnt, err := testEngine.Update(&UpdateMapCondition{ cnt, err := testEngine.Update(&UpdateMapCondition{
String: "string1", String: "string1",
}, map[string]interface{}{ }, map[string]interface{}{
"id": c.Id, "id": c.ID,
}) })
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var c2 UpdateMapCondition var c2 UpdateMapCondition
has, err := testEngine.ID(c.Id).Get(&c2) has, err := testEngine.ID(c.ID).Get(&c2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, "string1", c2.String) assert.EqualValues(t, "string1", c2.String)
@ -1216,7 +1216,7 @@ func TestUpdateMapContent(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UpdateMapContent struct { type UpdateMapContent struct {
Id int64 ID int64
Name string Name string
IsMan bool IsMan bool
Age int Age int
@ -1235,17 +1235,17 @@ func TestUpdateMapContent(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 18, c.Age) assert.EqualValues(t, 18, c.Age)
cnt, err := testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]interface{}{"age": 0}) cnt, err := testEngine.Table(new(UpdateMapContent)).ID(c.ID).Update(map[string]interface{}{"age": 0})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var c1 UpdateMapContent var c1 UpdateMapContent
has, err := testEngine.ID(c.Id).Get(&c1) has, err := testEngine.ID(c.ID).Get(&c1)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 0, c1.Age) assert.EqualValues(t, 0, c1.Age)
cnt, err = testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]interface{}{ cnt, err = testEngine.Table(new(UpdateMapContent)).ID(c.ID).Update(map[string]interface{}{
"age": 16, "age": 16,
"is_man": false, "is_man": false,
"gender": 2, "gender": 2,
@ -1254,14 +1254,14 @@ func TestUpdateMapContent(t *testing.T) {
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var c2 UpdateMapContent var c2 UpdateMapContent
has, err = testEngine.ID(c.Id).Get(&c2) has, err = testEngine.ID(c.ID).Get(&c2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 16, c2.Age) assert.EqualValues(t, 16, c2.Age)
assert.EqualValues(t, false, c2.IsMan) assert.EqualValues(t, false, c2.IsMan)
assert.EqualValues(t, 2, c2.Gender) assert.EqualValues(t, 2, c2.Gender)
cnt, err = testEngine.Table(testEngine.TableName(new(UpdateMapContent))).ID(c.Id).Update(map[string]interface{}{ cnt, err = testEngine.Table(testEngine.TableName(new(UpdateMapContent))).ID(c.ID).Update(map[string]interface{}{
"age": 15, "age": 15,
"is_man": true, "is_man": true,
"gender": 1, "gender": 1,
@ -1270,7 +1270,7 @@ func TestUpdateMapContent(t *testing.T) {
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var c3 UpdateMapContent var c3 UpdateMapContent
has, err = testEngine.ID(c.Id).Get(&c3) has, err = testEngine.ID(c.ID).Get(&c3)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 15, c3.Age) assert.EqualValues(t, 15, c3.Age)
@ -1280,7 +1280,7 @@ func TestUpdateMapContent(t *testing.T) {
func TestUpdateCondiBean(t *testing.T) { func TestUpdateCondiBean(t *testing.T) {
type NeedUpdateBean struct { type NeedUpdateBean struct {
Id int64 ID int64
Name string Name string
} }

6
statement_test.go
View File

@ -184,7 +184,7 @@ func createTestStatement() *Statement {
func TestDistinctAndCols(t *testing.T) { func TestDistinctAndCols(t *testing.T) {
type DistinctAndCols struct { type DistinctAndCols struct {
Id int64 ID int64
Name string Name string
} }
@ -206,7 +206,7 @@ func TestDistinctAndCols(t *testing.T) {
func TestUpdateIgnoreOnlyFromDBFields(t *testing.T) { func TestUpdateIgnoreOnlyFromDBFields(t *testing.T) {
type TestOnlyFromDBField struct { type TestOnlyFromDBField struct {
Id int64 `xorm:"PK"` ID int64 `xorm:"PK"`
OnlyFromDBField string `xorm:"<-"` OnlyFromDBField string `xorm:"<-"`
OnlyToDBField string `xorm:"->"` OnlyToDBField string `xorm:"->"`
IngoreField string `xorm:"-"` IngoreField string `xorm:"-"`
@ -225,7 +225,7 @@ func TestUpdateIgnoreOnlyFromDBFields(t *testing.T) {
assertSync(t, new(TestOnlyFromDBField)) assertSync(t, new(TestOnlyFromDBField))
_, err := testEngine.Insert(&TestOnlyFromDBField{ _, err := testEngine.Insert(&TestOnlyFromDBField{
Id: 1, ID: 1,
OnlyFromDBField: "a", OnlyFromDBField: "a",
OnlyToDBField: "b", OnlyToDBField: "b",
IngoreField: "c", IngoreField: "c",

4
tag_cache_test.go
View File

@ -14,7 +14,7 @@ func TestCacheTag(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type CacheDomain struct { type CacheDomain struct {
Id int64 `xorm:"pk cache"` ID int64 `xorm:"pk cache"`
Name string Name string
} }
@ -26,7 +26,7 @@ func TestNoCacheTag(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type NoCacheDomain struct { type NoCacheDomain struct {
Id int64 `xorm:"pk nocache"` ID int64 `xorm:"pk nocache"`
Name string Name string
} }

80
tag_extends_test.go
View File

@ -15,7 +15,7 @@ import (
) )
type tempUser struct { type tempUser struct {
Id int64 ID int64
Username string Username string
} }
@ -34,7 +34,7 @@ type tempUser4 struct {
} }
type Userinfo struct { type Userinfo struct {
Uid int64 `xorm:"id pk not null autoincr"` UID int64 `xorm:"id pk not null autoincr"`
Username string `xorm:"unique"` Username string `xorm:"unique"`
Departname string Departname string
Alias string `xorm:"-"` Alias string `xorm:"-"`
@ -46,7 +46,7 @@ type Userinfo struct {
} }
type Userdetail struct { type Userdetail struct {
Id int64 ID int64
Intro string `xorm:"text"` Intro string `xorm:"text"`
Profile string `xorm:"varchar(2000)"` Profile string `xorm:"varchar(2000)"`
} }
@ -86,7 +86,7 @@ func TestExtends(t *testing.T) {
} }
tu3 := &tempUser2{tempUser{0, "extends update"}, ""} tu3 := &tempUser2{tempUser{0, "extends update"}, ""}
_, err = testEngine.ID(tu2.TempUser.Id).Update(tu3) _, err = testEngine.ID(tu2.TempUser.ID).Update(tu3)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -124,7 +124,7 @@ func TestExtends(t *testing.T) {
} }
tu10 := &tempUser4{tempUser2{tempUser{0, "extends update"}, ""}} tu10 := &tempUser4{tempUser2{tempUser{0, "extends update"}, ""}}
_, err = testEngine.ID(tu9.TempUser2.TempUser.Id).Update(tu10) _, err = testEngine.ID(tu9.TempUser2.TempUser.ID).Update(tu10)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -160,7 +160,7 @@ func TestExtends(t *testing.T) {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if tu5.Temp.Id != 1 || tu5.Temp.Username != "extends" || if tu5.Temp.ID != 1 || tu5.Temp.Username != "extends" ||
tu5.Departname != "dev depart" { tu5.Departname != "dev depart" {
err = errors.New("error get data extends") err = errors.New("error get data extends")
t.Error(err) t.Error(err)
@ -168,7 +168,7 @@ func TestExtends(t *testing.T) {
} }
tu6 := &tempUser3{&tempUser{0, "extends update"}, ""} tu6 := &tempUser3{&tempUser{0, "extends update"}, ""}
_, err = testEngine.ID(tu5.Temp.Id).Update(tu6) _, err = testEngine.ID(tu5.Temp.ID).Update(tu6)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -204,7 +204,7 @@ func TestExtends(t *testing.T) {
qt := testEngine.Quote qt := testEngine.Quote
ui := testEngine.TableName(new(Userinfo), true) ui := testEngine.TableName(new(Userinfo), true)
ud := testEngine.TableName(&detail, true) ud := testEngine.TableName(&detail, true)
uiid := testEngine.GetColumnMapper().Obj2Table("Id") uiid := testEngine.GetColumnMapper().Obj2Table("ID")
udid := "detail_id" udid := "detail_id"
sql := fmt.Sprintf("select * from %s, %s where %s.%s = %s.%s", sql := fmt.Sprintf("select * from %s, %s where %s.%s = %s.%s",
qt(ui), qt(ud), qt(ui), qt(udid), qt(ud), qt(uiid)) qt(ui), qt(ud), qt(ui), qt(udid), qt(ud), qt(uiid))
@ -216,7 +216,7 @@ func TestExtends(t *testing.T) {
panic(err) panic(err)
} }
fmt.Println(info) fmt.Println(info)
if info.Userinfo.Uid == 0 || info.Userdetail.Id == 0 { if info.Userinfo.UID == 0 || info.Userdetail.ID == 0 {
err = errors.New("all of the id should has value") err = errors.New("all of the id should has value")
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -236,7 +236,7 @@ func TestExtends(t *testing.T) {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if info2.Userinfo.Uid == 0 || info2.Userdetail.Id == 0 { if info2.Userinfo.UID == 0 || info2.Userdetail.ID == 0 {
err = errors.New("all of the id should has value") err = errors.New("all of the id should has value")
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -257,26 +257,26 @@ func TestExtends(t *testing.T) {
} }
type MessageBase struct { type MessageBase struct {
Id int64 `xorm:"int(11) pk autoincr"` ID int64 `xorm:"int(11) pk autoincr"`
TypeId int64 `xorm:"int(11) notnull"` TypeID int64 `xorm:"int(11) notnull"`
} }
type Message struct { type Message struct {
MessageBase `xorm:"extends"` MessageBase `xorm:"extends"`
Title string `xorm:"varchar(100) notnull"` Title string `xorm:"varchar(100) notnull"`
Content string `xorm:"text notnull"` Content string `xorm:"text notnull"`
Uid int64 `xorm:"int(11) notnull"` UID int64 `xorm:"int(11) notnull"`
ToUid int64 `xorm:"int(11) notnull"` ToUID int64 `xorm:"int(11) notnull"`
CreateTime time.Time `xorm:"datetime notnull created"` CreateTime time.Time `xorm:"datetime notnull created"`
} }
type MessageUser struct { type MessageUser struct {
Id int64 ID int64
Name string Name string
} }
type MessageType struct { type MessageType struct {
Id int64 ID int64
Name string Name string
} }
@ -319,12 +319,12 @@ func TestExtends2(t *testing.T) {
msg := Message{ msg := Message{
MessageBase: MessageBase{ MessageBase: MessageBase{
Id: msgtype.Id, ID: msgtype.ID,
}, },
Title: "test", Title: "test",
Content: "test", Content: "test",
Uid: sender.Id, UID: sender.ID,
ToUid: receiver.Id, ToUID: receiver.ID,
} }
if testEngine.Dialect().DBType() == core.MSSQL { if testEngine.Dialect().DBType() == core.MSSQL {
_, err = testEngine.Exec("SET IDENTITY_INSERT message ON") _, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
@ -344,9 +344,9 @@ func TestExtends2(t *testing.T) {
msgTableName := quote(testEngine.TableName(mapper("Message"), true)) msgTableName := quote(testEngine.TableName(mapper("Message"), true))
list := make([]Message, 0) list := make([]Message, 0)
err = testEngine.Table(msgTableName).Join("LEFT", []string{userTableName, "sender"}, "`sender`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`"). err = testEngine.Table(msgTableName).Join("LEFT", []string{userTableName, "sender"}, "`sender`.`"+mapper("ID")+"`="+msgTableName+".`"+mapper("UID")+"`").
Join("LEFT", []string{userTableName, "receiver"}, "`receiver`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("ToUid")+"`"). Join("LEFT", []string{userTableName, "receiver"}, "`receiver`.`"+mapper("ID")+"`="+msgTableName+".`"+mapper("ToUID")+"`").
Join("LEFT", []string{typeTableName, "type"}, "`type`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Id")+"`"). Join("LEFT", []string{typeTableName, "type"}, "`type`.`"+mapper("ID")+"`="+msgTableName+".`"+mapper("ID")+"`").
Find(&list) Find(&list)
assert.NoError(t, err) assert.NoError(t, err)
@ -356,7 +356,7 @@ func TestExtends2(t *testing.T) {
panic(err) panic(err)
} }
if list[0].Id != msg.Id { if list[0].ID != msg.ID {
err = errors.New(fmt.Sprintln("should message equal", list[0], msg)) err = errors.New(fmt.Sprintln("should message equal", list[0], msg))
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -389,12 +389,12 @@ func TestExtends3(t *testing.T) {
msg := Message{ msg := Message{
MessageBase: MessageBase{ MessageBase: MessageBase{
Id: msgtype.Id, ID: msgtype.ID,
}, },
Title: "test", Title: "test",
Content: "test", Content: "test",
Uid: sender.Id, UID: sender.ID,
ToUid: receiver.Id, ToUID: receiver.ID,
} }
if testEngine.Dialect().DBType() == core.MSSQL { if testEngine.Dialect().DBType() == core.MSSQL {
_, err = testEngine.Exec("SET IDENTITY_INSERT message ON") _, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
@ -410,9 +410,9 @@ func TestExtends3(t *testing.T) {
msgTableName := quote(testEngine.TableName(mapper("Message"), true)) msgTableName := quote(testEngine.TableName(mapper("Message"), true))
list := make([]MessageExtend3, 0) list := make([]MessageExtend3, 0)
err = testEngine.Table(msgTableName).Join("LEFT", []string{userTableName, "sender"}, "`sender`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`"). err = testEngine.Table(msgTableName).Join("LEFT", []string{userTableName, "sender"}, "`sender`.`"+mapper("ID")+"`="+msgTableName+".`"+mapper("UID")+"`").
Join("LEFT", []string{userTableName, "receiver"}, "`receiver`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("ToUid")+"`"). Join("LEFT", []string{userTableName, "receiver"}, "`receiver`.`"+mapper("ID")+"`="+msgTableName+".`"+mapper("ToUID")+"`").
Join("LEFT", []string{typeTableName, "type"}, "`type`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Id")+"`"). Join("LEFT", []string{typeTableName, "type"}, "`type`.`"+mapper("ID")+"`="+msgTableName+".`"+mapper("ID")+"`").
Find(&list) Find(&list)
assert.NoError(t, err) assert.NoError(t, err)
@ -422,25 +422,25 @@ func TestExtends3(t *testing.T) {
panic(err) panic(err)
} }
if list[0].Message.Id != msg.Id { if list[0].Message.ID != msg.ID {
err = errors.New(fmt.Sprintln("should message equal", list[0].Message, msg)) err = errors.New(fmt.Sprintln("should message equal", list[0].Message, msg))
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if list[0].Sender.Id != sender.Id || list[0].Sender.Name != sender.Name { if list[0].Sender.ID != sender.ID || list[0].Sender.Name != sender.Name {
err = errors.New(fmt.Sprintln("should sender equal", list[0].Sender, sender)) err = errors.New(fmt.Sprintln("should sender equal", list[0].Sender, sender))
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if list[0].Receiver.Id != receiver.Id || list[0].Receiver.Name != receiver.Name { if list[0].Receiver.ID != receiver.ID || list[0].Receiver.Name != receiver.Name {
err = errors.New(fmt.Sprintln("should receiver equal", list[0].Receiver, receiver)) err = errors.New(fmt.Sprintln("should receiver equal", list[0].Receiver, receiver))
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if list[0].Type.Id != msgtype.Id || list[0].Type.Name != msgtype.Name { if list[0].Type.ID != msgtype.ID || list[0].Type.Name != msgtype.Name {
err = errors.New(fmt.Sprintln("should msgtype equal", list[0].Type, msgtype)) err = errors.New(fmt.Sprintln("should msgtype equal", list[0].Type, msgtype))
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -472,11 +472,11 @@ func TestExtends4(t *testing.T) {
msg := Message{ msg := Message{
MessageBase: MessageBase{ MessageBase: MessageBase{
Id: msgtype.Id, ID: msgtype.ID,
}, },
Title: "test", Title: "test",
Content: "test", Content: "test",
Uid: sender.Id, UID: sender.ID,
} }
if testEngine.Dialect().DBType() == core.MSSQL { if testEngine.Dialect().DBType() == core.MSSQL {
_, err = testEngine.Exec("SET IDENTITY_INSERT message ON") _, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
@ -495,8 +495,8 @@ func TestExtends4(t *testing.T) {
msgTableName := quote(testEngine.TableName(mapper("Message"), true)) msgTableName := quote(testEngine.TableName(mapper("Message"), true))
list := make([]MessageExtend4, 0) list := make([]MessageExtend4, 0)
err = testEngine.Table(msgTableName).Join("LEFT", userTableName, userTableName+".`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`"). err = testEngine.Table(msgTableName).Join("LEFT", userTableName, userTableName+".`"+mapper("ID")+"`="+msgTableName+".`"+mapper("UID")+"`").
Join("LEFT", typeTableName, typeTableName+".`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Id")+"`"). Join("LEFT", typeTableName, typeTableName+".`"+mapper("ID")+"`="+msgTableName+".`"+mapper("ID")+"`").
Find(&list) Find(&list)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
@ -509,19 +509,19 @@ func TestExtends4(t *testing.T) {
panic(err) panic(err)
} }
if list[0].Message.Id != msg.Id { if list[0].Message.ID != msg.ID {
err = errors.New(fmt.Sprintln("should message equal", list[0].Message, msg)) err = errors.New(fmt.Sprintln("should message equal", list[0].Message, msg))
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if list[0].MessageUser.Id != sender.Id || list[0].MessageUser.Name != sender.Name { if list[0].MessageUser.ID != sender.ID || list[0].MessageUser.Name != sender.Name {
err = errors.New(fmt.Sprintln("should sender equal", list[0].MessageUser, sender)) err = errors.New(fmt.Sprintln("should sender equal", list[0].MessageUser, sender))
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if list[0].MessageType.Id != msgtype.Id || list[0].MessageType.Name != msgtype.Name { if list[0].MessageType.ID != msgtype.ID || list[0].MessageType.Name != msgtype.Name {
err = errors.New(fmt.Sprintln("should msgtype equal", list[0].MessageType, msgtype)) err = errors.New(fmt.Sprintln("should msgtype equal", list[0].MessageType, msgtype))
t.Error(err) t.Error(err)
panic(err) panic(err)

62
tag_test.go
View File

@ -16,7 +16,7 @@ import (
) )
type UserCU struct { type UserCU struct {
Id int64 ID int64
Name string Name string
Created time.Time `xorm:"created"` Created time.Time `xorm:"created"`
Updated time.Time `xorm:"updated"` Updated time.Time `xorm:"updated"`
@ -52,7 +52,7 @@ func TestCreatedAndUpdated(t *testing.T) {
} }
u.Name = "xxx" u.Name = "xxx"
cnt, err = testEngine.ID(u.Id).Update(u) cnt, err = testEngine.ID(u.ID).Update(u)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -64,7 +64,7 @@ func TestCreatedAndUpdated(t *testing.T) {
return return
} }
u.Id = 0 u.ID = 0
u.Created = time.Now().Add(-time.Hour * 24 * 365) u.Created = time.Now().Add(-time.Hour * 24 * 365)
u.Updated = u.Created u.Updated = u.Created
fmt.Println(u) fmt.Println(u)
@ -82,7 +82,7 @@ func TestCreatedAndUpdated(t *testing.T) {
} }
type StrangeName struct { type StrangeName struct {
Id_t int64 `xorm:"pk autoincr"` IDT int64 `xorm:"pk autoincr"`
Name string Name string
} }
@ -115,7 +115,7 @@ func TestCreatedUpdated(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type CreatedUpdated struct { type CreatedUpdated struct {
Id int64 ID int64
Name string Name string
Value float64 `xorm:"numeric"` Value float64 `xorm:"numeric"`
Created time.Time `xorm:"created"` Created time.Time `xorm:"created"`
@ -131,13 +131,13 @@ func TestCreatedUpdated(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
c2 := new(CreatedUpdated) c2 := new(CreatedUpdated)
has, err := testEngine.ID(c.Id).Get(c2) has, err := testEngine.ID(c.ID).Get(c2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
c2.Value -= 1 c2.Value--
_, err = testEngine.ID(c2.Id).Update(c2) _, err = testEngine.ID(c2.ID).Update(c2)
assert.NoError(t, err) assert.NoError(t, err)
} }
@ -145,7 +145,7 @@ func TestCreatedUpdatedInt64(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type CreatedUpdatedInt64 struct { type CreatedUpdatedInt64 struct {
Id int64 ID int64
Name string Name string
Value float64 `xorm:"numeric"` Value float64 `xorm:"numeric"`
Created int64 `xorm:"created"` Created int64 `xorm:"created"`
@ -160,17 +160,17 @@ func TestCreatedUpdatedInt64(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
c2 := new(CreatedUpdatedInt64) c2 := new(CreatedUpdatedInt64)
has, err := testEngine.ID(c.Id).Get(c2) has, err := testEngine.ID(c.ID).Get(c2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
c2.Value -= 1 c2.Value--
_, err = testEngine.ID(c2.Id).Update(c2) _, err = testEngine.ID(c2.ID).Update(c2)
assert.NoError(t, err) assert.NoError(t, err)
} }
type Lowercase struct { type Lowercase struct {
Id int64 ID int64
Name string Name string
ended int64 `xorm:"-"` ended int64 `xorm:"-"`
} }
@ -208,7 +208,7 @@ func TestAutoIncrTag(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type TestAutoIncr1 struct { type TestAutoIncr1 struct {
Id int64 ID int64
} }
tb := testEngine.TableInfo(new(TestAutoIncr1)) tb := testEngine.TableInfo(new(TestAutoIncr1))
@ -219,7 +219,7 @@ func TestAutoIncrTag(t *testing.T) {
assert.Equal(t, "id", cols[0].Name) assert.Equal(t, "id", cols[0].Name)
type TestAutoIncr2 struct { type TestAutoIncr2 struct {
Id int64 `xorm:"id"` ID int64 `xorm:"id"`
} }
tb = testEngine.TableInfo(new(TestAutoIncr2)) tb = testEngine.TableInfo(new(TestAutoIncr2))
@ -230,7 +230,7 @@ func TestAutoIncrTag(t *testing.T) {
assert.Equal(t, "id", cols[0].Name) assert.Equal(t, "id", cols[0].Name)
type TestAutoIncr3 struct { type TestAutoIncr3 struct {
Id int64 `xorm:"'ID'"` ID int64 `xorm:"'ID'"`
} }
tb = testEngine.TableInfo(new(TestAutoIncr3)) tb = testEngine.TableInfo(new(TestAutoIncr3))
@ -241,7 +241,7 @@ func TestAutoIncrTag(t *testing.T) {
assert.Equal(t, "ID", cols[0].Name) assert.Equal(t, "ID", cols[0].Name)
type TestAutoIncr4 struct { type TestAutoIncr4 struct {
Id int64 `xorm:"pk"` ID int64 `xorm:"pk"`
} }
tb = testEngine.TableInfo(new(TestAutoIncr4)) tb = testEngine.TableInfo(new(TestAutoIncr4))
@ -260,7 +260,7 @@ func TestTagComment(t *testing.T) {
} }
type TestComment1 struct { type TestComment1 struct {
Id int64 `xorm:"comment(主键)"` ID int64 `xorm:"comment(主键)"`
} }
assert.NoError(t, testEngine.Sync2(new(TestComment1))) assert.NoError(t, testEngine.Sync2(new(TestComment1)))
@ -274,7 +274,7 @@ func TestTagComment(t *testing.T) {
assert.NoError(t, testEngine.DropTables(new(TestComment1))) assert.NoError(t, testEngine.DropTables(new(TestComment1)))
type TestComment2 struct { type TestComment2 struct {
Id int64 `xorm:"comment('主键')"` ID int64 `xorm:"comment('主键')"`
} }
assert.NoError(t, testEngine.Sync2(new(TestComment2))) assert.NoError(t, testEngine.Sync2(new(TestComment2)))
@ -290,7 +290,7 @@ func TestTagDefault(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type DefaultStruct struct { type DefaultStruct struct {
Id int64 ID int64
Name string Name string
Age int `xorm:"default(10)"` Age int `xorm:"default(10)"`
} }
@ -316,16 +316,16 @@ func TestTagsDirection(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type OnlyFromDBStruct struct { type OnlyFromDBStruct struct {
Id int64 ID int64
Name string Name string
Uuid string `xorm:"<- default '1'"` UUID string `xorm:"<- default '1'"`
} }
assertSync(t, new(OnlyFromDBStruct)) assertSync(t, new(OnlyFromDBStruct))
cnt, err := testEngine.Insert(&OnlyFromDBStruct{ cnt, err := testEngine.Insert(&OnlyFromDBStruct{
Name: "test", Name: "test",
Uuid: "2", UUID: "2",
}) })
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
@ -334,11 +334,11 @@ func TestTagsDirection(t *testing.T) {
has, err := testEngine.ID(1).Get(&s) has, err := testEngine.ID(1).Get(&s)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, "1", s.Uuid) assert.EqualValues(t, "1", s.UUID)
assert.EqualValues(t, "test", s.Name) assert.EqualValues(t, "test", s.Name)
cnt, err = testEngine.ID(1).Update(&OnlyFromDBStruct{ cnt, err = testEngine.ID(1).Update(&OnlyFromDBStruct{
Uuid: "3", UUID: "3",
Name: "test1", Name: "test1",
}) })
assert.NoError(t, err) assert.NoError(t, err)
@ -348,20 +348,20 @@ func TestTagsDirection(t *testing.T) {
has, err = testEngine.ID(1).Get(&s3) has, err = testEngine.ID(1).Get(&s3)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, "1", s3.Uuid) assert.EqualValues(t, "1", s3.UUID)
assert.EqualValues(t, "test1", s3.Name) assert.EqualValues(t, "test1", s3.Name)
type OnlyToDBStruct struct { type OnlyToDBStruct struct {
Id int64 ID int64
Name string Name string
Uuid string `xorm:"->"` UUID string `xorm:"->"`
} }
assertSync(t, new(OnlyToDBStruct)) assertSync(t, new(OnlyToDBStruct))
cnt, err = testEngine.Insert(&OnlyToDBStruct{ cnt, err = testEngine.Insert(&OnlyToDBStruct{
Name: "test", Name: "test",
Uuid: "2", UUID: "2",
}) })
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
@ -370,7 +370,7 @@ func TestTagsDirection(t *testing.T) {
has, err = testEngine.ID(1).Get(&s2) has, err = testEngine.ID(1).Get(&s2)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, "", s2.Uuid) assert.EqualValues(t, "", s2.UUID)
assert.EqualValues(t, "test", s2.Name) assert.EqualValues(t, "test", s2.Name)
} }
@ -378,7 +378,7 @@ func TestTagTime(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type TagUTCStruct struct { type TagUTCStruct struct {
Id int64 ID int64
Name string Name string
Created time.Time `xorm:"created utc"` Created time.Time `xorm:"created utc"`
} }

10
tag_version_test.go
View File

@ -14,7 +14,7 @@ import (
) )
type VersionS struct { type VersionS struct {
Id int64 ID int64
Name string Name string
Ver int `xorm:"version"` Ver int `xorm:"version"`
Created time.Time `xorm:"created"` Created time.Time `xorm:"created"`
@ -49,14 +49,14 @@ func TestVersion1(t *testing.T) {
} }
newVer := new(VersionS) newVer := new(VersionS)
has, err := testEngine.ID(ver.Id).Get(newVer) has, err := testEngine.ID(ver.ID).Get(newVer)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
if !has { if !has {
t.Error(errors.New(fmt.Sprintf("no version id is %v", ver.Id))) t.Error(fmt.Errorf("no version id is %v", ver.ID))
panic(err) panic(err)
} }
fmt.Println(newVer) fmt.Println(newVer)
@ -67,7 +67,7 @@ func TestVersion1(t *testing.T) {
} }
newVer.Name = "-------" newVer.Name = "-------"
_, err = testEngine.ID(ver.Id).Update(newVer) _, err = testEngine.ID(ver.ID).Update(newVer)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -78,7 +78,7 @@ func TestVersion1(t *testing.T) {
} }
newVer = new(VersionS) newVer = new(VersionS)
has, err = testEngine.ID(ver.Id).Get(newVer) has, err = testEngine.ID(ver.ID).Get(newVer)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)

66
time_test.go
View File

@ -17,14 +17,14 @@ func TestTimeUserTime(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type TimeUser struct { type TimeUser struct {
Id string ID string
OperTime time.Time OperTime time.Time
} }
assertSync(t, new(TimeUser)) assertSync(t, new(TimeUser))
var user = TimeUser{ var user = TimeUser{
Id: "lunny", ID: "lunny",
OperTime: time.Now(), OperTime: time.Now(),
} }
@ -53,14 +53,14 @@ func TestTimeUserTimeDiffLoc(t *testing.T) {
testEngine.SetTZDatabase(dbLoc) testEngine.SetTZDatabase(dbLoc)
type TimeUser2 struct { type TimeUser2 struct {
Id string ID string
OperTime time.Time OperTime time.Time
} }
assertSync(t, new(TimeUser2)) assertSync(t, new(TimeUser2))
var user = TimeUser2{ var user = TimeUser2{
Id: "lunny", ID: "lunny",
OperTime: time.Now(), OperTime: time.Now(),
} }
@ -83,14 +83,14 @@ func TestTimeUserCreated(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserCreated struct { type UserCreated struct {
Id string ID string
CreatedAt time.Time `xorm:"created"` CreatedAt time.Time `xorm:"created"`
} }
assertSync(t, new(UserCreated)) assertSync(t, new(UserCreated))
var user = UserCreated{ var user = UserCreated{
Id: "lunny", ID: "lunny",
} }
fmt.Println("user", user.CreatedAt) fmt.Println("user", user.CreatedAt)
@ -118,14 +118,14 @@ func TestTimeUserCreatedDiffLoc(t *testing.T) {
testEngine.SetTZDatabase(dbLoc) testEngine.SetTZDatabase(dbLoc)
type UserCreated2 struct { type UserCreated2 struct {
Id string ID string
CreatedAt time.Time `xorm:"created"` CreatedAt time.Time `xorm:"created"`
} }
assertSync(t, new(UserCreated2)) assertSync(t, new(UserCreated2))
var user = UserCreated2{ var user = UserCreated2{
Id: "lunny", ID: "lunny",
} }
fmt.Println("user", user.CreatedAt) fmt.Println("user", user.CreatedAt)
@ -147,7 +147,7 @@ func TestTimeUserUpdated(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserUpdated struct { type UserUpdated struct {
Id string ID string
CreatedAt time.Time `xorm:"created"` CreatedAt time.Time `xorm:"created"`
UpdatedAt time.Time `xorm:"updated"` UpdatedAt time.Time `xorm:"updated"`
} }
@ -155,7 +155,7 @@ func TestTimeUserUpdated(t *testing.T) {
assertSync(t, new(UserUpdated)) assertSync(t, new(UserUpdated))
var user = UserUpdated{ var user = UserUpdated{
Id: "lunny", ID: "lunny",
} }
fmt.Println("user", user.CreatedAt, user.UpdatedAt) fmt.Println("user", user.CreatedAt, user.UpdatedAt)
@ -175,7 +175,7 @@ func TestTimeUserUpdated(t *testing.T) {
fmt.Println("user2", user2.CreatedAt, user2.UpdatedAt) fmt.Println("user2", user2.CreatedAt, user2.UpdatedAt)
var user3 = UserUpdated{ var user3 = UserUpdated{
Id: "lunny2", ID: "lunny2",
} }
cnt, err = testEngine.Update(&user3) cnt, err = testEngine.Update(&user3)
@ -204,7 +204,7 @@ func TestTimeUserUpdatedDiffLoc(t *testing.T) {
testEngine.SetTZDatabase(dbLoc) testEngine.SetTZDatabase(dbLoc)
type UserUpdated2 struct { type UserUpdated2 struct {
Id string ID string
CreatedAt time.Time `xorm:"created"` CreatedAt time.Time `xorm:"created"`
UpdatedAt time.Time `xorm:"updated"` UpdatedAt time.Time `xorm:"updated"`
} }
@ -212,7 +212,7 @@ func TestTimeUserUpdatedDiffLoc(t *testing.T) {
assertSync(t, new(UserUpdated2)) assertSync(t, new(UserUpdated2))
var user = UserUpdated2{ var user = UserUpdated2{
Id: "lunny", ID: "lunny",
} }
fmt.Println("user", user.CreatedAt, user.UpdatedAt) fmt.Println("user", user.CreatedAt, user.UpdatedAt)
@ -232,7 +232,7 @@ func TestTimeUserUpdatedDiffLoc(t *testing.T) {
fmt.Println("user2", user2.CreatedAt, user2.UpdatedAt) fmt.Println("user2", user2.CreatedAt, user2.UpdatedAt)
var user3 = UserUpdated2{ var user3 = UserUpdated2{
Id: "lunny2", ID: "lunny2",
} }
cnt, err = testEngine.Update(&user3) cnt, err = testEngine.Update(&user3)
@ -255,7 +255,7 @@ func TestTimeUserDeleted(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserDeleted struct { type UserDeleted struct {
Id string ID string
CreatedAt time.Time `xorm:"created"` CreatedAt time.Time `xorm:"created"`
UpdatedAt time.Time `xorm:"updated"` UpdatedAt time.Time `xorm:"updated"`
DeletedAt time.Time `xorm:"deleted"` DeletedAt time.Time `xorm:"deleted"`
@ -264,7 +264,7 @@ func TestTimeUserDeleted(t *testing.T) {
assertSync(t, new(UserDeleted)) assertSync(t, new(UserDeleted))
var user = UserDeleted{ var user = UserDeleted{
Id: "lunny", ID: "lunny",
} }
cnt, err := testEngine.Insert(&user) cnt, err := testEngine.Insert(&user)
@ -308,7 +308,7 @@ func TestTimeUserDeletedDiffLoc(t *testing.T) {
testEngine.SetTZDatabase(dbLoc) testEngine.SetTZDatabase(dbLoc)
type UserDeleted2 struct { type UserDeleted2 struct {
Id string ID string
CreatedAt time.Time `xorm:"created"` CreatedAt time.Time `xorm:"created"`
UpdatedAt time.Time `xorm:"updated"` UpdatedAt time.Time `xorm:"updated"`
DeletedAt time.Time `xorm:"deleted"` DeletedAt time.Time `xorm:"deleted"`
@ -317,7 +317,7 @@ func TestTimeUserDeletedDiffLoc(t *testing.T) {
assertSync(t, new(UserDeleted2)) assertSync(t, new(UserDeleted2))
var user = UserDeleted2{ var user = UserDeleted2{
Id: "lunny", ID: "lunny",
} }
cnt, err := testEngine.Insert(&user) cnt, err := testEngine.Insert(&user)
@ -351,27 +351,27 @@ func TestTimeUserDeletedDiffLoc(t *testing.T) {
fmt.Println("user3", user3.DeletedAt, user4.DeletedAt) fmt.Println("user3", user3.DeletedAt, user4.DeletedAt)
} }
type JsonDate time.Time type JSONDate time.Time
func (j JsonDate) MarshalJSON() ([]byte, error) { func (j JSONDate) MarshalJSON() ([]byte, error) {
if time.Time(j).IsZero() { if time.Time(j).IsZero() {
return []byte(`""`), nil return []byte(`""`), nil
} }
return []byte(`"` + time.Time(j).Format("2006-01-02 15:04:05") + `"`), nil return []byte(`"` + time.Time(j).Format("2006-01-02 15:04:05") + `"`), nil
} }
func (j *JsonDate) UnmarshalJSON(value []byte) error { func (j *JSONDate) UnmarshalJSON(value []byte) error {
var v = strings.TrimSpace(strings.Trim(string(value), "\"")) var v = strings.TrimSpace(strings.Trim(string(value), "\""))
t, err := time.ParseInLocation("2006-01-02 15:04:05", v, time.Local) t, err := time.ParseInLocation("2006-01-02 15:04:05", v, time.Local)
if err != nil { if err != nil {
return err return err
} }
*j = JsonDate(t) *j = JSONDate(t)
return nil return nil
} }
func (j *JsonDate) Unix() int64 { func (j *JSONDate) Unix() int64 {
return (*time.Time)(j).Unix() return (*time.Time)(j).Unix()
} }
@ -379,16 +379,16 @@ func TestCustomTimeUserDeleted(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type UserDeleted3 struct { type UserDeleted3 struct {
Id string ID string
CreatedAt JsonDate `xorm:"created"` CreatedAt JSONDate `xorm:"created"`
UpdatedAt JsonDate `xorm:"updated"` UpdatedAt JSONDate `xorm:"updated"`
DeletedAt JsonDate `xorm:"deleted"` DeletedAt JSONDate `xorm:"deleted"`
} }
assertSync(t, new(UserDeleted3)) assertSync(t, new(UserDeleted3))
var user = UserDeleted3{ var user = UserDeleted3{
Id: "lunny", ID: "lunny",
} }
cnt, err := testEngine.Insert(&user) cnt, err := testEngine.Insert(&user)
@ -432,16 +432,16 @@ func TestCustomTimeUserDeletedDiffLoc(t *testing.T) {
testEngine.SetTZDatabase(dbLoc) testEngine.SetTZDatabase(dbLoc)
type UserDeleted4 struct { type UserDeleted4 struct {
Id string ID string
CreatedAt JsonDate `xorm:"created"` CreatedAt JSONDate `xorm:"created"`
UpdatedAt JsonDate `xorm:"updated"` UpdatedAt JSONDate `xorm:"updated"`
DeletedAt JsonDate `xorm:"deleted"` DeletedAt JSONDate `xorm:"deleted"`
} }
assertSync(t, new(UserDeleted4)) assertSync(t, new(UserDeleted4))
var user = UserDeleted4{ var user = UserDeleted4{
Id: "lunny", ID: "lunny",
} }
cnt, err := testEngine.Insert(&user) cnt, err := testEngine.Insert(&user)

2
transancation_test.go
View File

@ -16,7 +16,7 @@ func TestAutoTransaction(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type TestTx struct { type TestTx struct {
Id int64 `xorm:"autoincr pk"` ID int64 `xorm:"autoincr pk"`
Msg string `xorm:"varchar(255)"` Msg string `xorm:"varchar(255)"`
Created time.Time `xorm:"created"` Created time.Time `xorm:"created"`
} }

10
types_null_test.go
View File

@ -17,7 +17,7 @@ import (
) )
type NullType struct { type NullType struct {
Id int `xorm:"pk autoincr"` ID int `xorm:"pk autoincr"`
Name sql.NullString Name sql.NullString
Age sql.NullInt64 Age sql.NullInt64
Height sql.NullFloat64 Height sql.NullFloat64
@ -88,7 +88,7 @@ func TestNullStructInsert(t *testing.T) {
panic(err) panic(err)
} }
fmt.Println(item) fmt.Println(item)
if item.Id != 1 { if item.ID != 1 {
err = errors.New("insert error") err = errors.New("insert error")
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -108,7 +108,7 @@ func TestNullStructInsert(t *testing.T) {
panic(err) panic(err)
} }
fmt.Println(item) fmt.Println(item)
if item.Id != 2 { if item.ID != 2 {
err = errors.New("insert error") err = errors.New("insert error")
t.Error(err) t.Error(err)
panic(err) panic(err)
@ -278,7 +278,7 @@ func TestNullStructFind(t *testing.T) {
panic(err) panic(err)
} }
fmt.Println(item) fmt.Println(item)
if item.Id != 1 || item.Name.Valid || item.Age.Valid || item.Height.Valid || if item.ID != 1 || item.Name.Valid || item.Age.Valid || item.Height.Valid ||
item.IsMan.Valid { item.IsMan.Valid {
err = errors.New("insert error") err = errors.New("insert error")
t.Error(err) t.Error(err)
@ -288,7 +288,7 @@ func TestNullStructFind(t *testing.T) {
if true { if true {
item := new(NullType) item := new(NullType)
item.Id = 2 item.ID = 2
has, err := testEngine.Get(item) has, err := testEngine.Get(item)
if err != nil { if err != nil {

17
types_test.go
View File

@ -18,7 +18,7 @@ func TestArrayField(t *testing.T) {
assert.NoError(t, prepareEngine()) assert.NoError(t, prepareEngine())
type ArrayStruct struct { type ArrayStruct struct {
Id int64 ID int64
Name [20]byte `xorm:"char(80)"` Name [20]byte `xorm:"char(80)"`
} }
@ -113,7 +113,7 @@ func (s *ConvString) ToDB() ([]byte, error) {
type ConvConfig struct { type ConvConfig struct {
Name string Name string
Id int64 ID int64
} }
func (s *ConvConfig) FromDB(data []byte) error { func (s *ConvConfig) FromDB(data []byte) error {
@ -269,10 +269,10 @@ type Status struct {
var ( var (
_ core.Conversion = &Status{} _ core.Conversion = &Status{}
Registed Status = Status{"Registed", "white"} Registed = Status{"Registed", "white"}
Approved Status = Status{"Approved", "green"} Approved = Status{"Approved", "green"}
Removed Status = Status{"Removed", "red"} Removed = Status{"Removed", "red"}
Statuses map[string]Status = map[string]Status{ Statuses = map[string]Status{
Registed.Name: Registed, Registed.Name: Registed,
Approved.Name: Approved, Approved.Name: Approved,
Removed.Name: Removed, Removed.Name: Removed,
@ -283,9 +283,8 @@ func (s *Status) FromDB(bytes []byte) error {
if r, ok := Statuses[string(bytes)]; ok { if r, ok := Statuses[string(bytes)]; ok {
*s = r *s = r
return nil return nil
} else {
return errors.New("no this data")
} }
return errors.New("no this data")
} }
func (s *Status) ToDB() ([]byte, error) { func (s *Status) ToDB() ([]byte, error) {
@ -293,7 +292,7 @@ func (s *Status) ToDB() ([]byte, error) {
} }
type UserCus struct { type UserCus struct {
Id int64 ID int64
Name string Name string
Status Status `xorm:"varchar(40)"` Status Status `xorm:"varchar(40)"`
} }