From d2bd37962eddcd4298e4c2b1f46c2967bf53fd3e Mon Sep 17 00:00:00 2001 From: John Guo Date: Sat, 27 Feb 2021 23:58:36 +0800 Subject: [PATCH] add unit testing case of UnmarshalValue for struct converting of querying result; improve package gdb --- database/gdb/gdb_model.go | 4 +- database/gdb/gdb_schema.go | 4 +- database/gdb/gdb_z_driver_test.go | 4 +- database/gdb/gdb_z_init_test.go | 41 +- database/gdb/gdb_z_mysql_association_test.go | 117 ++- database/gdb/gdb_z_mysql_internal_test.go | 30 +- database/gdb/gdb_z_mysql_method_test.go | 76 +- database/gdb/gdb_z_mysql_model_test.go | 710 +++++++++--------- database/gdb/gdb_z_mysql_raw_test.go | 8 +- database/gdb/gdb_z_mysql_struct_test.go | 101 ++- .../gdb/gdb_z_mysql_time_maintain_test.go | 164 ++-- database/gdb/gdb_z_mysql_transaction_test.go | 42 +- database/gdb/gdb_z_mysql_types_test.go | 6 +- 13 files changed, 676 insertions(+), 631 deletions(-) diff --git a/database/gdb/gdb_model.go b/database/gdb/gdb_model.go index 04f0bbd25..4b109534f 100644 --- a/database/gdb/gdb_model.go +++ b/database/gdb/gdb_model.go @@ -183,9 +183,9 @@ func (m *Model) Schema(schema string) *Model { func (m *Model) Clone() *Model { newModel := (*Model)(nil) if m.tx != nil { - newModel = m.tx.Table(m.tablesInit) + newModel = m.tx.Model(m.tablesInit) } else { - newModel = m.db.Table(m.tablesInit) + newModel = m.db.Model(m.tablesInit) } *newModel = *m // Shallow copy slice attributes. diff --git a/database/gdb/gdb_schema.go b/database/gdb/gdb_schema.go index c7f5fb2a7..7794eada4 100644 --- a/database/gdb/gdb_schema.go +++ b/database/gdb/gdb_schema.go @@ -36,9 +36,9 @@ func (tx *TX) Schema(schema string) *Schema { func (s *Schema) Table(table string) *Model { var m *Model if s.tx != nil { - m = s.tx.Table(table) + m = s.tx.Model(table) } else { - m = s.db.Table(table) + m = s.db.Model(table) } // Do not change the schema of the original db, // it here creates a new db and changes its schema. diff --git a/database/gdb/gdb_z_driver_test.go b/database/gdb/gdb_z_driver_test.go index 3d2d10154..80686d203 100644 --- a/database/gdb/gdb_z_driver_test.go +++ b/database/gdb/gdb_z_driver_test.go @@ -56,8 +56,8 @@ func Test_Custom_Driver(t *testing.T) { gdb.AddConfigNode("driver-test", gdb.ConfigNode{ Host: "127.0.0.1", Port: "3306", - User: USER, - Pass: PASS, + User: TestDbUser, + Pass: TestDbPass, Name: "test", Type: customDriverName, Role: "master", diff --git a/database/gdb/gdb_z_init_test.go b/database/gdb/gdb_z_init_test.go index 6208c9577..fe9fcc47a 100644 --- a/database/gdb/gdb_z_init_test.go +++ b/database/gdb/gdb_z_init_test.go @@ -18,13 +18,14 @@ import ( ) const ( - SIZE = 10 - TABLE = "user" - SCHEMA1 = "test1" - SCHEMA2 = "test2" - PREFIX1 = "gf_" - USER = "root" - PASS = "12345678" + TableSize = 10 + TableName = "user" + TestSchema1 = "test1" + TestSchema2 = "test2" + TableNamePrefix1 = "gf_" + TestDbUser = "root" + TestDbPass = "12345678" + CreateTime = "2018-10-24 10:00:00" ) var ( @@ -42,8 +43,8 @@ func init() { configNode = gdb.ConfigNode{ Host: "127.0.0.1", Port: "3306", - User: USER, - Pass: PASS, + User: TestDbUser, + Pass: TestDbPass, Name: parser.GetOpt("name", ""), Type: parser.GetOpt("type", "mysql"), Role: "master", @@ -54,7 +55,7 @@ func init() { MaxConnLifetime: 600, } nodePrefix := configNode - nodePrefix.Prefix = PREFIX1 + nodePrefix.Prefix = TableNamePrefix1 gdb.AddConfigNode("test", configNode) gdb.AddConfigNode("prefix", nodePrefix) gdb.AddConfigNode(gdb.DefaultGroupName, configNode) @@ -65,13 +66,13 @@ func init() { db = r } schemaTemplate := "CREATE DATABASE IF NOT EXISTS `%s` CHARACTER SET UTF8" - if _, err := db.Exec(fmt.Sprintf(schemaTemplate, SCHEMA1)); err != nil { + if _, err := db.Exec(fmt.Sprintf(schemaTemplate, TestSchema1)); err != nil { gtest.Error(err) } - if _, err := db.Exec(fmt.Sprintf(schemaTemplate, SCHEMA2)); err != nil { + if _, err := db.Exec(fmt.Sprintf(schemaTemplate, TestSchema2)); err != nil { gtest.Error(err) } - db.SetSchema(SCHEMA1) + db.SetSchema(TestSchema1) // Prefix db. if r, err := gdb.New("prefix"); err != nil { @@ -79,13 +80,13 @@ func init() { } else { dbPrefix = r } - if _, err := dbPrefix.Exec(fmt.Sprintf(schemaTemplate, SCHEMA1)); err != nil { + if _, err := dbPrefix.Exec(fmt.Sprintf(schemaTemplate, TestSchema1)); err != nil { gtest.Error(err) } - if _, err := dbPrefix.Exec(fmt.Sprintf(schemaTemplate, SCHEMA2)); err != nil { + if _, err := dbPrefix.Exec(fmt.Sprintf(schemaTemplate, TestSchema2)); err != nil { gtest.Error(err) } - dbPrefix.SetSchema(SCHEMA1) + dbPrefix.SetSchema(TestSchema1) } func createTable(table ...string) string { @@ -104,7 +105,7 @@ func createTableWithDb(db gdb.DB, table ...string) (name string) { if len(table) > 0 { name = table[0] } else { - name = fmt.Sprintf(`%s_%d`, TABLE, gtime.TimestampNano()) + name = fmt.Sprintf(`%s_%d`, TableName, gtime.TimestampNano()) } dropTableWithDb(db, name) @@ -184,13 +185,13 @@ func createTableWithDb(db gdb.DB, table ...string) (name string) { func createInitTableWithDb(db gdb.DB, table ...string) (name string) { name = createTableWithDb(db, table...) array := garray.New(true) - for i := 1; i <= SIZE; i++ { + for i := 1; i <= TableSize; i++ { array.Append(g.Map{ "id": i, "passport": fmt.Sprintf(`user_%d`, i), "password": fmt.Sprintf(`pass_%d`, i), "nickname": fmt.Sprintf(`name_%d`, i), - "create_time": gtime.NewFromStr("2018-10-24 10:00:00").String(), + "create_time": gtime.NewFromStr(CreateTime).String(), }) } @@ -199,7 +200,7 @@ func createInitTableWithDb(db gdb.DB, table ...string) (name string) { n, e := result.RowsAffected() gtest.Assert(e, nil) - gtest.Assert(n, SIZE) + gtest.Assert(n, TableSize) return } diff --git a/database/gdb/gdb_z_mysql_association_test.go b/database/gdb/gdb_z_mysql_association_test.go index 4dbbf7db3..b853a8662 100644 --- a/database/gdb/gdb_z_mysql_association_test.go +++ b/database/gdb/gdb_z_mysql_association_test.go @@ -112,19 +112,19 @@ CREATE TABLE %s ( }) // Data check. gtest.C(t, func(t *gtest.T) { - r, err := db.Table(tableUser).All() + r, err := db.Model(tableUser).All() t.AssertNil(err) t.Assert(r.Len(), 1) t.Assert(r[0]["uid"].Int(), 1) t.Assert(r[0]["name"].String(), "john") - r, err = db.Table(tableUserDetail).Where("uid", r[0]["uid"].Int()).All() + r, err = db.Model(tableUserDetail).Where("uid", r[0]["uid"].Int()).All() t.AssertNil(err) t.Assert(r.Len(), 1) t.Assert(r[0]["uid"].Int(), 1) t.Assert(r[0]["address"].String(), `Beijing DongZhiMen #66`) - r, err = db.Table(tableUserScores).Where("uid", r[0]["uid"].Int()).All() + r, err = db.Model(tableUserScores).Where("uid", r[0]["uid"].Int()).All() t.AssertNil(err) t.Assert(r.Len(), 2) t.Assert(r[0]["uid"].Int(), 1) @@ -136,15 +136,15 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var user Entity // SELECT * FROM `user` WHERE `name`='john' - err := db.Table(tableUser).Scan(&user.User, "name", "john") + err := db.Model(tableUser).Scan(&user.User, "name", "john") t.AssertNil(err) // SELECT * FROM `user_detail` WHERE `uid`=1 - err = db.Table(tableUserDetail).Scan(&user.UserDetail, "uid", user.User.Uid) + err = db.Model(tableUserDetail).Scan(&user.UserDetail, "uid", user.User.Uid) t.AssertNil(err) // SELECT * FROM `user_scores` WHERE `uid`=1 - err = db.Table(tableUserScores).Scan(&user.UserScores, "uid", user.User.Uid) + err = db.Model(tableUserScores).Scan(&user.UserScores, "uid", user.User.Uid) t.AssertNil(err) t.Assert(user.User, EntityUser{ @@ -250,13 +250,13 @@ CREATE TABLE %s ( // MapKeyValue. gtest.C(t, func(t *gtest.T) { - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) t.Assert(all.Len(), 2) t.Assert(len(all.MapKeyValue("uid")), 2) t.Assert(all.MapKeyValue("uid")["3"].Map()["uid"], 3) t.Assert(all.MapKeyValue("uid")["4"].Map()["uid"], 4) - all, err = db.Table(tableUserScores).Where("uid", g.Slice{3, 4}).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", g.Slice{3, 4}).Order("id asc").All() t.AssertNil(err) t.Assert(all.Len(), 10) t.Assert(len(all.MapKeyValue("uid")), 2) @@ -271,7 +271,7 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var users []Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) @@ -279,14 +279,14 @@ CREATE TABLE %s ( t.Assert(users[0].User, &EntityUser{3, "name_3"}) t.Assert(users[1].User, &EntityUser{4, "name_4"}) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"}) t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"}) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "uid:Uid") t.AssertNil(err) @@ -304,7 +304,7 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var users []*Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) @@ -312,14 +312,14 @@ CREATE TABLE %s ( t.Assert(users[0].User, &EntityUser{3, "name_3"}) t.Assert(users[1].User, &EntityUser{4, "name_4"}) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"}) t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"}) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "uid:Uid") t.AssertNil(err) @@ -355,7 +355,7 @@ CREATE TABLE %s ( } var users []Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) @@ -363,14 +363,14 @@ CREATE TABLE %s ( t.Assert(users[0].User, &EntityUser{3, "name_3"}) t.Assert(users[1].User, &EntityUser{4, "name_4"}) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"}) t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"}) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "uid:Uid") t.AssertNil(err) @@ -407,7 +407,7 @@ CREATE TABLE %s ( var users []*Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) @@ -415,14 +415,14 @@ CREATE TABLE %s ( t.Assert(users[0].User, &EntityUser{3, "name_3"}) t.Assert(users[1].User, &EntityUser{4, "name_4"}) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"}) t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"}) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "uid:Uid") t.AssertNil(err) @@ -440,19 +440,19 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var users []*Entity // User - err := db.Table(tableUser). + err := db.Model(tableUser). Where("uid", g.Slice{3, 4}). Order("uid asc"). ScanList(&users, "User") t.AssertNil(err) // Detail - err = db.Table(tableUserDetail). + err = db.Model(tableUserDetail). Where("uid", gdb.ListItemValues(users, "User", "Uid")). Order("uid asc"). ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) // Scores - err = db.Table(tableUserScores). + err = db.Model(tableUserScores). Where("uid", gdb.ListItemValues(users, "User", "Uid")). Order("id asc"). ScanList(&users, "UserScores", "User", "uid:Uid") @@ -564,13 +564,13 @@ CREATE TABLE %s ( // MapKeyValue. gtest.C(t, func(t *gtest.T) { - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) t.Assert(all.Len(), 2) t.Assert(len(all.MapKeyValue("uid")), 2) t.Assert(all.MapKeyValue("uid")["3"].Map()["uid"], 3) t.Assert(all.MapKeyValue("uid")["4"].Map()["uid"], 4) - all, err = db.Table(tableUserScores).Where("uid", g.Slice{3, 4}).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", g.Slice{3, 4}).Order("id asc").All() t.AssertNil(err) t.Assert(all.Len(), 10) t.Assert(len(all.MapKeyValue("uid")), 2) @@ -585,7 +585,7 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var users []Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) @@ -593,14 +593,14 @@ CREATE TABLE %s ( t.Assert(users[0].User, &EntityUser{3, "name_3"}) t.Assert(users[1].User, &EntityUser{4, "name_4"}) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:uid") t.AssertNil(err) t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"}) t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"}) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "uid:uid") t.AssertNil(err) @@ -618,7 +618,7 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var users []*Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) @@ -626,14 +626,14 @@ CREATE TABLE %s ( t.Assert(users[0].User, &EntityUser{3, "name_3"}) t.Assert(users[1].User, &EntityUser{4, "name_4"}) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "Uid:UID") t.AssertNil(err) t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"}) t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"}) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "Uid:UID") t.AssertNil(err) @@ -669,7 +669,7 @@ CREATE TABLE %s ( } var users []Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) @@ -677,14 +677,14 @@ CREATE TABLE %s ( t.Assert(users[0].User, &EntityUser{3, "name_3"}) t.Assert(users[1].User, &EntityUser{4, "name_4"}) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:UId") t.AssertNil(err) t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"}) t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"}) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "UId:Uid") t.AssertNil(err) @@ -721,7 +721,7 @@ CREATE TABLE %s ( var users []*Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) @@ -729,14 +729,14 @@ CREATE TABLE %s ( t.Assert(users[0].User, &EntityUser{3, "name_3"}) t.Assert(users[1].User, &EntityUser{4, "name_4"}) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"}) t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"}) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "UID:Uid") t.AssertNil(err) @@ -754,19 +754,19 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var users []*Entity // User - err := db.Table(tableUser). + err := db.Model(tableUser). Where("uid", g.Slice{3, 4}). Order("uid asc"). ScanList(&users, "User") t.AssertNil(err) // Detail - err = db.Table(tableUserDetail). + err = db.Model(tableUserDetail). Where("uid", gdb.ListItemValues(users, "User", "Uid")). Order("uid asc"). ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) // Scores - err = db.Table(tableUserScores). + err = db.Model(tableUserScores). Where("uid", gdb.ListItemValues(users, "User", "Uid")). Order("id asc"). ScanList(&users, "UserScores", "User", "uid:Uid") @@ -851,22 +851,21 @@ CREATE TABLE %s ( // Result ScanList with struct elements and pointer attributes. gtest.C(t, func(t *gtest.T) { - db.SetDebug(true) var users []Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) t.Assert(len(users), 0) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:uid") t.AssertNil(err) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "uid:uid") t.AssertNil(err) @@ -876,20 +875,20 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var users []*Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) t.Assert(len(users), 0) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "Uid:UID") t.AssertNil(err) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "Uid:UID") t.AssertNil(err) @@ -917,19 +916,19 @@ CREATE TABLE %s ( } var users []Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:UId") t.AssertNil(err) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "UId:Uid") t.AssertNil(err) @@ -958,19 +957,19 @@ CREATE TABLE %s ( var users []*Entity // User - all, err := db.Table(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() + all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "User") t.AssertNil(err) t.Assert(len(users), 0) // Detail - all, err = db.Table(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() + all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) // Scores - all, err = db.Table(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() + all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All() t.AssertNil(err) err = all.ScanList(&users, "UserScores", "User", "UID:Uid") t.AssertNil(err) @@ -980,19 +979,19 @@ CREATE TABLE %s ( gtest.C(t, func(t *gtest.T) { var users []*Entity // User - err := db.Table(tableUser). + err := db.Model(tableUser). Where("uid", g.Slice{3, 4}). Order("uid asc"). ScanList(&users, "User") t.AssertNil(err) // Detail - err = db.Table(tableUserDetail). + err = db.Model(tableUserDetail). Where("uid", gdb.ListItemValues(users, "User", "Uid")). Order("uid asc"). ScanList(&users, "UserDetail", "User", "uid:Uid") t.AssertNil(err) // Scores - err = db.Table(tableUserScores). + err = db.Model(tableUserScores). Where("uid", gdb.ListItemValues(users, "User", "Uid")). Order("id asc"). ScanList(&users, "UserScores", "User", "uid:Uid") @@ -1092,17 +1091,17 @@ CREATE TABLE %s ( scores []*EntityUserScores ) // SELECT * FROM `user_scores` - err = db.Table(tableUserScores).Scan(&scores) + err = db.Model(tableUserScores).Scan(&scores) t.AssertNil(err) // SELECT * FROM `user_scores` WHERE `uid` IN(1,2,3,4,5) - err = db.Table(tableUser). + err = db.Model(tableUser). Where("uid", gdb.ListItemValuesUnique(&scores, "Uid")). ScanList(&scores, "EntityUser", "uid:Uid") t.AssertNil(err) // SELECT * FROM `user_detail` WHERE `uid` IN(1,2,3,4,5) - err = db.Table(tableUserDetail). + err = db.Model(tableUserDetail). Where("uid", gdb.ListItemValuesUnique(&scores, "Uid")). ScanList(&scores, "EntityUserDetail", "uid:Uid") t.AssertNil(err) diff --git a/database/gdb/gdb_z_mysql_internal_test.go b/database/gdb/gdb_z_mysql_internal_test.go index a606b3215..736a1c1f0 100644 --- a/database/gdb/gdb_z_mysql_internal_test.go +++ b/database/gdb/gdb_z_mysql_internal_test.go @@ -17,9 +17,9 @@ import ( ) const ( - SCHEMA = "test_internal" - USER = "root" - PASS = "12345678" + SCHEMA = "test_internal" + TestDbUser = "root" + TestDbPass = "12345678" ) var ( @@ -36,8 +36,8 @@ func init() { configNode = ConfigNode{ Host: "127.0.0.1", Port: "3306", - User: USER, - Pass: PASS, + User: TestDbUser, + Pass: TestDbPass, Name: parser.GetOpt("name", ""), Type: parser.GetOpt("type", "mysql"), Role: "master", @@ -204,7 +204,7 @@ CREATE TABLE %s ( defer dropTable(table2) gtest.C(t, func(t *gtest.T) { - model := db.Table(table1) + model := db.Model(table1) gtest.Assert(model.getSoftFieldNameCreated(table2), "createat") gtest.Assert(model.getSoftFieldNameUpdated(table2), "updateat") gtest.Assert(model.getSoftFieldNameDeleted(table2), "deleteat") @@ -243,48 +243,48 @@ CREATE TABLE %s ( defer dropTable(table2) gtest.C(t, func(t *gtest.T) { - model := db.Table(table1) + model := db.Model(table1) t.Assert(model.getConditionForSoftDeleting(), "`delete_at` IS NULL") }) gtest.C(t, func(t *gtest.T) { - model := db.Table(fmt.Sprintf(`%s as t`, table1)) + model := db.Model(fmt.Sprintf(`%s as t`, table1)) t.Assert(model.getConditionForSoftDeleting(), "`delete_at` IS NULL") }) gtest.C(t, func(t *gtest.T) { - model := db.Table(fmt.Sprintf(`%s, %s`, table1, table2)) + model := db.Model(fmt.Sprintf(`%s, %s`, table1, table2)) t.Assert(model.getConditionForSoftDeleting(), fmt.Sprintf( "`%s`.`delete_at` IS NULL AND `%s`.`deleteat` IS NULL", table1, table2, )) }) gtest.C(t, func(t *gtest.T) { - model := db.Table(fmt.Sprintf(`%s t1, %s as t2`, table1, table2)) + model := db.Model(fmt.Sprintf(`%s t1, %s as t2`, table1, table2)) t.Assert(model.getConditionForSoftDeleting(), "`t1`.`delete_at` IS NULL AND `t2`.`deleteat` IS NULL") }) gtest.C(t, func(t *gtest.T) { - model := db.Table(fmt.Sprintf(`%s as t1, %s as t2`, table1, table2)) + model := db.Model(fmt.Sprintf(`%s as t1, %s as t2`, table1, table2)) t.Assert(model.getConditionForSoftDeleting(), "`t1`.`delete_at` IS NULL AND `t2`.`deleteat` IS NULL") }) gtest.C(t, func(t *gtest.T) { - model := db.Table(fmt.Sprintf(`%s as t1`, table1)).LeftJoin(table2+" t2", "t2.id2=t1.id1") + model := db.Model(fmt.Sprintf(`%s as t1`, table1)).LeftJoin(table2+" t2", "t2.id2=t1.id1") t.Assert(model.getConditionForSoftDeleting(), "`t1`.`delete_at` IS NULL AND `t2`.`deleteat` IS NULL") }) gtest.C(t, func(t *gtest.T) { - model := db.Table(fmt.Sprintf(`%s`, table1)).LeftJoin(table2, "t2.id2=t1.id1") + model := db.Model(fmt.Sprintf(`%s`, table1)).LeftJoin(table2, "t2.id2=t1.id1") t.Assert(model.getConditionForSoftDeleting(), fmt.Sprintf( "`%s`.`delete_at` IS NULL AND `%s`.`deleteat` IS NULL", table1, table2, )) }) gtest.C(t, func(t *gtest.T) { - model := db.Table(fmt.Sprintf(`%s`, table1)).LeftJoin(table2, "t2.id2=t1.id1").RightJoin(table2, "t2.id2=t1.id1") + model := db.Model(fmt.Sprintf(`%s`, table1)).LeftJoin(table2, "t2.id2=t1.id1").RightJoin(table2, "t2.id2=t1.id1") t.Assert(model.getConditionForSoftDeleting(), fmt.Sprintf( "`%s`.`delete_at` IS NULL AND `%s`.`deleteat` IS NULL AND `%s`.`deleteat` IS NULL", table1, table2, table2, )) }) gtest.C(t, func(t *gtest.T) { - model := db.Table(table1+" as t1").LeftJoin(table2+" as t2", "t2.id2=t1.id1").RightJoin(table2+" as t3 ", "t2.id2=t1.id1") + model := db.Model(table1+" as t1").LeftJoin(table2+" as t2", "t2.id2=t1.id1").RightJoin(table2+" as t3 ", "t2.id2=t1.id1") t.Assert( model.getConditionForSoftDeleting(), "`t1`.`delete_at` IS NULL AND `t2`.`deleteat` IS NULL AND `t3`.`deleteat` IS NULL", diff --git a/database/gdb/gdb_z_mysql_method_test.go b/database/gdb/gdb_z_mysql_method_test.go index 74b348686..9db3b9f6c 100644 --- a/database/gdb/gdb_z_mysql_method_test.go +++ b/database/gdb/gdb_z_mysql_method_test.go @@ -124,7 +124,7 @@ func Test_DB_Insert(t *testing.T) { n, _ = result.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).Where("id", 3).One() + one, err := db.Model(table).Where("id", 3).One() t.AssertNil(err) t.Assert(one["id"].Int(), 3) @@ -146,7 +146,7 @@ func Test_DB_Insert(t *testing.T) { n, _ = result.RowsAffected() t.Assert(n, 1) - one, err = db.Table(table).Where("id", 4).One() + one, err = db.Model(table).Where("id", 4).One() t.AssertNil(err) t.Assert(one["id"].Int(), 4) t.Assert(one["passport"].String(), "t4") @@ -176,7 +176,7 @@ func Test_DB_Insert(t *testing.T) { n, _ = r.RowsAffected() t.Assert(n, 2) - one, err = db.Table(table).Where("id", 200).One() + one, err = db.Model(table).Where("id", 200).One() t.AssertNil(err) t.Assert(one["id"].Int(), 200) t.Assert(one["passport"].String(), "t200") @@ -437,7 +437,7 @@ func Test_DB_Save(t *testing.T) { }) t.AssertNil(err) - one, err := db.Table(table).Where("id", 1).One() + one, err := db.Model(table).Where("id", 1).One() t.AssertNil(err) t.Assert(one["id"].Int(), 1) t.Assert(one["passport"].String(), "t1") @@ -462,7 +462,7 @@ func Test_DB_Replace(t *testing.T) { }) t.AssertNil(err) - one, err := db.Table(table).Where("id", 1).One() + one, err := db.Model(table).Where("id", 1).One() t.AssertNil(err) t.Assert(one["id"].Int(), 1) t.Assert(one["passport"].String(), "t1") @@ -482,7 +482,7 @@ func Test_DB_Update(t *testing.T) { n, _ := result.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).Where("id", 3).One() + one, err := db.Model(table).Where("id", 3).One() t.AssertNil(err) t.Assert(one["id"].Int(), 3) t.Assert(one["passport"].String(), "user_3") @@ -567,7 +567,7 @@ func Test_DB_GetCount(t *testing.T) { gtest.C(t, func(t *gtest.T) { count, err := db.GetCount(fmt.Sprintf("SELECT * FROM %s", table)) t.AssertNil(err) - t.Assert(count, SIZE) + t.Assert(count, TableSize) }) } @@ -616,7 +616,7 @@ func Test_DB_GetStructs(t *testing.T) { var users []User err := db.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>?", table), 1) t.AssertNil(err) - t.Assert(len(users), SIZE-1) + t.Assert(len(users), TableSize-1) t.Assert(users[0].Id, 2) t.Assert(users[1].Id, 3) t.Assert(users[2].Id, 4) @@ -636,7 +636,7 @@ func Test_DB_GetStructs(t *testing.T) { var users []User err := db.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>?", table), 1) t.AssertNil(err) - t.Assert(len(users), SIZE-1) + t.Assert(len(users), TableSize-1) t.Assert(users[0].Id, 2) t.Assert(users[1].Id, 3) t.Assert(users[2].Id, 4) @@ -687,7 +687,7 @@ func Test_DB_GetScan(t *testing.T) { var users []User err := db.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>?", table), 1) t.AssertNil(err) - t.Assert(len(users), SIZE-1) + t.Assert(len(users), TableSize-1) t.Assert(users[0].Id, 2) t.Assert(users[1].Id, 3) t.Assert(users[2].Id, 4) @@ -707,7 +707,7 @@ func Test_DB_GetScan(t *testing.T) { var users []User err := db.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>?", table), 1) t.AssertNil(err) - t.Assert(len(users), SIZE-1) + t.Assert(len(users), TableSize-1) t.Assert(users[0].Id, 2) t.Assert(users[1].Id, 3) t.Assert(users[2].Id, 4) @@ -724,7 +724,7 @@ func Test_DB_Delete(t *testing.T) { result, err := db.Delete(table, 1) t.AssertNil(err) n, _ := result.RowsAffected() - t.Assert(n, SIZE) + t.Assert(n, TableSize) }) } @@ -784,7 +784,7 @@ func Test_DB_ToJson(t *testing.T) { gtest.AssertNil(err) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Fields("*").Where("id =? ", 1).Select() + result, err := db.Model(table).Fields("*").Where("id =? ", 1).Select() if err != nil { gtest.Fatal(err) } @@ -825,7 +825,7 @@ func Test_DB_ToJson(t *testing.T) { }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Fields("*").Where("id =? ", 1).One() + result, err := db.Model(table).Fields("*").Where("id =? ", 1).One() if err != nil { gtest.Fatal(err) } @@ -858,7 +858,7 @@ func Test_DB_ToXml(t *testing.T) { gtest.AssertNil(err) gtest.C(t, func(t *gtest.T) { - record, err := db.Table(table).Fields("*").Where("id = ?", 1).One() + record, err := db.Model(table).Fields("*").Where("id = ?", 1).One() if err != nil { gtest.Fatal(err) } @@ -924,7 +924,7 @@ func Test_DB_ToStringMap(t *testing.T) { gtest.AssertNil(err) gtest.C(t, func(t *gtest.T) { id := "1" - result, err := db.Table(table).Fields("*").Where("id = ?", 1).Select() + result, err := db.Model(table).Fields("*").Where("id = ?", 1).Select() if err != nil { gtest.Fatal(err) } @@ -961,7 +961,7 @@ func Test_DB_ToIntMap(t *testing.T) { gtest.C(t, func(t *gtest.T) { id := 1 - result, err := db.Table(table).Fields("*").Where("id = ?", id).Select() + result, err := db.Model(table).Fields("*").Where("id = ?", id).Select() if err != nil { gtest.Fatal(err) } @@ -997,7 +997,7 @@ func Test_DB_ToUintMap(t *testing.T) { gtest.C(t, func(t *gtest.T) { id := 1 - result, err := db.Table(table).Fields("*").Where("id = ?", id).Select() + result, err := db.Model(table).Fields("*").Where("id = ?", id).Select() if err != nil { gtest.Fatal(err) } @@ -1035,7 +1035,7 @@ func Test_DB_ToStringRecord(t *testing.T) { gtest.C(t, func(t *gtest.T) { id := 1 ids := "1" - result, err := db.Table(table).Fields("*").Where("id = ?", id).Select() + result, err := db.Model(table).Fields("*").Where("id = ?", id).Select() if err != nil { gtest.Fatal(err) } @@ -1072,7 +1072,7 @@ func Test_DB_ToIntRecord(t *testing.T) { gtest.C(t, func(t *gtest.T) { id := 1 - result, err := db.Table(table).Fields("*").Where("id = ?", id).Select() + result, err := db.Model(table).Fields("*").Where("id = ?", id).Select() if err != nil { gtest.Fatal(err) } @@ -1109,7 +1109,7 @@ func Test_DB_ToUintRecord(t *testing.T) { gtest.C(t, func(t *gtest.T) { id := 1 - result, err := db.Table(table).Fields("*").Where("id = ?", id).Select() + result, err := db.Model(table).Fields("*").Where("id = ?", id).Select() if err != nil { gtest.Fatal(err) } @@ -1169,7 +1169,7 @@ func Test_DB_TableField(t *testing.T) { "field_varchar": "abc", "field_varbinary": "aaa", } - res, err := db.Table(name).Data(data).Insert() + res, err := db.Model(name).Data(data).Insert() if err != nil { gtest.Fatal(err) } @@ -1181,7 +1181,7 @@ func Test_DB_TableField(t *testing.T) { gtest.Assert(n, 1) } - result, err := db.Table(name).Fields("*").Where("field_int = ?", 2).Select() + result, err := db.Model(name).Fields("*").Where("field_int = ?", 2).Select() if err != nil { gtest.Fatal(err) } @@ -1191,8 +1191,8 @@ func Test_DB_TableField(t *testing.T) { func Test_DB_Prefix(t *testing.T) { db := dbPrefix - name := fmt.Sprintf(`%s_%d`, TABLE, gtime.TimestampNano()) - table := PREFIX1 + name + name := fmt.Sprintf(`%s_%d`, TableName, gtime.TimestampNano()) + table := TableNamePrefix1 + name createTableWithDb(db, table) defer dropTable(table) @@ -1272,7 +1272,7 @@ func Test_DB_Prefix(t *testing.T) { gtest.C(t, func(t *gtest.T) { array := garray.New(true) - for i := 1; i <= SIZE; i++ { + for i := 1; i <= TableSize; i++ { array.Append(g.Map{ "id": i, "passport": fmt.Sprintf(`user_%d`, i), @@ -1287,7 +1287,7 @@ func Test_DB_Prefix(t *testing.T) { n, e := result.RowsAffected() t.Assert(e, nil) - t.Assert(n, SIZE) + t.Assert(n, TableSize) }) } @@ -1300,7 +1300,7 @@ func Test_Model_InnerJoin(t *testing.T) { defer dropTable(table1) defer dropTable(table2) - res, err := db.Table(table1).Where("id > ?", 5).Delete() + res, err := db.Model(table1).Where("id > ?", 5).Delete() if err != nil { t.Fatal(err) } @@ -1312,14 +1312,14 @@ func Test_Model_InnerJoin(t *testing.T) { t.Assert(n, 5) - result, err := db.Table(table1+" u1").InnerJoin(table2+" u2", "u1.id = u2.id").OrderBy("u1.id").Select() + result, err := db.Model(table1+" u1").InnerJoin(table2+" u2", "u1.id = u2.id").OrderBy("u1.id").Select() if err != nil { t.Fatal(err) } t.Assert(len(result), 5) - result, err = db.Table(table1+" u1").InnerJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > ?", 1).OrderBy("u1.id").Select() + result, err = db.Model(table1+" u1").InnerJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > ?", 1).OrderBy("u1.id").Select() if err != nil { t.Fatal(err) } @@ -1336,7 +1336,7 @@ func Test_Model_LeftJoin(t *testing.T) { defer dropTable(table1) defer dropTable(table2) - res, err := db.Table(table2).Where("id > ?", 3).Delete() + res, err := db.Model(table2).Where("id > ?", 3).Delete() if err != nil { t.Fatal(err) } @@ -1348,14 +1348,14 @@ func Test_Model_LeftJoin(t *testing.T) { t.Assert(n, 7) } - result, err := db.Table(table1+" u1").LeftJoin(table2+" u2", "u1.id = u2.id").Select() + result, err := db.Model(table1+" u1").LeftJoin(table2+" u2", "u1.id = u2.id").Select() if err != nil { t.Fatal(err) } t.Assert(len(result), 10) - result, err = db.Table(table1+" u1").LeftJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > ? ", 2).Select() + result, err = db.Model(table1+" u1").LeftJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > ? ", 2).Select() if err != nil { t.Fatal(err) } @@ -1372,7 +1372,7 @@ func Test_Model_RightJoin(t *testing.T) { defer dropTable(table1) defer dropTable(table2) - res, err := db.Table(table1).Where("id > ?", 3).Delete() + res, err := db.Model(table1).Where("id > ?", 3).Delete() if err != nil { t.Fatal(err) } @@ -1384,13 +1384,13 @@ func Test_Model_RightJoin(t *testing.T) { t.Assert(n, 7) - result, err := db.Table(table1+" u1").RightJoin(table2+" u2", "u1.id = u2.id").Select() + result, err := db.Model(table1+" u1").RightJoin(table2+" u2", "u1.id = u2.id").Select() if err != nil { t.Fatal(err) } t.Assert(len(result), 10) - result, err = db.Table(table1+" u1").RightJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > 2").Select() + result, err = db.Model(table1+" u1").RightJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > 2").Select() if err != nil { t.Fatal(err) } @@ -1445,7 +1445,7 @@ func Test_DB_UpdateCounter(t *testing.T) { t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 1) - one, err := db.Table(tableName).Where("id", 1).One() + one, err := db.Model(tableName).Where("id", 1).One() t.AssertNil(err) t.Assert(one["id"].Int(), 1) t.Assert(one["views"].Int(), 1) @@ -1464,7 +1464,7 @@ func Test_DB_UpdateCounter(t *testing.T) { t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 1) - one, err := db.Table(tableName).Where("id", 1).One() + one, err := db.Model(tableName).Where("id", 1).One() t.AssertNil(err) t.Assert(one["id"].Int(), 1) t.Assert(one["views"].Int(), 0) diff --git a/database/gdb/gdb_z_mysql_model_test.go b/database/gdb/gdb_z_mysql_model_test.go index a1f14f511..0eb1b454a 100644 --- a/database/gdb/gdb_z_mysql_model_test.go +++ b/database/gdb/gdb_z_mysql_model_test.go @@ -29,7 +29,7 @@ func Test_Model_Insert(t *testing.T) { table := createTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - user := db.Table(table) + user := db.Model(table) result, err := user.Filter().Data(g.Map{ "id": 1, "uid": 1, @@ -42,7 +42,7 @@ func Test_Model_Insert(t *testing.T) { n, _ := result.LastInsertId() t.Assert(n, 1) - result, err = db.Table(table).Filter().Data(g.Map{ + result, err = db.Model(table).Filter().Data(g.Map{ "id": "2", "uid": "2", "passport": "t2", @@ -63,7 +63,7 @@ func Test_Model_Insert(t *testing.T) { CreateTime *gtime.Time `json:"create_time"` } // Model inserting. - result, err = db.Table(table).Filter().Data(User{ + result, err = db.Model(table).Filter().Data(User{ Id: 3, Uid: 3, Passport: "t3", @@ -73,11 +73,11 @@ func Test_Model_Insert(t *testing.T) { t.AssertNil(err) n, _ = result.RowsAffected() t.Assert(n, 1) - value, err := db.Table(table).Fields("passport").Where("id=3").Value() + value, err := db.Model(table).Fields("passport").Where("id=3").Value() t.AssertNil(err) t.Assert(value.String(), "t3") - result, err = db.Table(table).Filter().Data(&User{ + result, err = db.Model(table).Filter().Data(&User{ Id: 4, Uid: 4, Passport: "t4", @@ -88,11 +88,11 @@ func Test_Model_Insert(t *testing.T) { t.AssertNil(err) n, _ = result.RowsAffected() t.Assert(n, 1) - value, err = db.Table(table).Fields("passport").Where("id=4").Value() + value, err = db.Model(table).Fields("passport").Where("id=4").Value() t.AssertNil(err) t.Assert(value.String(), "t4") - result, err = db.Table(table).Where("id>?", 1).Delete() + result, err = db.Model(table).Where("id>?", 1).Delete() t.AssertNil(err) n, _ = result.RowsAffected() t.Assert(n, 3) @@ -113,7 +113,7 @@ func Test_Model_Insert_Filter(t *testing.T) { "nickname": "name_1", "create_time": gtime.Now().String(), } - result, err := db.Table(table).Filter().Data(data).Insert() + result, err := db.Model(table).Filter().Data(data).Insert() t.AssertNil(err) n, _ := result.LastInsertId() t.Assert(n, 1) @@ -143,7 +143,7 @@ func Test_Model_Insert_Filter(t *testing.T) { }, } - result, err := db.Table(table).Filter().Data(data).Insert() + result, err := db.Model(table).Filter().Data(data).Insert() t.AssertNil(err) n, _ := result.LastInsertId() t.Assert(n, 2) @@ -169,10 +169,10 @@ func Test_Model_Insert_WithStructAndSliceAttribute(t *testing.T) { "nickname": []string{"A", "B", "C"}, "create_time": gtime.Now().String(), } - _, err := db.Table(table).Data(data).Insert() + _, err := db.Model(table).Data(data).Insert() t.AssertNil(err) - one, err := db.Table(table).One("id", 1) + one, err := db.Model(table).One("id", 1) t.AssertNil(err) t.Assert(one["passport"], data["passport"]) t.Assert(one["create_time"], data["create_time"]) @@ -276,10 +276,10 @@ func Test_Model_Insert_Time(t *testing.T) { "nickname": "n1", "create_time": "2020-10-10 20:09:18.334", } - _, err := db.Table(table).Data(data).Insert() + _, err := db.Model(table).Data(data).Insert() t.AssertNil(err) - one, err := db.Table(table).One("id", 1) + one, err := db.Model(table).One("id", 1) t.AssertNil(err) t.Assert(one["passport"], data["passport"]) t.Assert(one["create_time"], "2020-10-10 20:09:18") @@ -291,9 +291,9 @@ func Test_Model_BatchInsertWithArrayStruct(t *testing.T) { table := createTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - user := db.Table(table) + user := db.Model(table) array := garray.New() - for i := 1; i <= SIZE; i++ { + for i := 1; i <= TableSize; i++ { array.Append(g.Map{ "id": i, "uid": i, @@ -307,7 +307,7 @@ func Test_Model_BatchInsertWithArrayStruct(t *testing.T) { result, err := user.Filter().Data(array).Insert() t.AssertNil(err) n, _ := result.LastInsertId() - t.Assert(n, SIZE) + t.Assert(n, TableSize) }) } @@ -315,7 +315,7 @@ func Test_Model_InsertIgnore(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - _, err := db.Table(table).Filter().Data(g.Map{ + _, err := db.Model(table).Filter().Data(g.Map{ "id": 1, "uid": 1, "passport": "t1", @@ -326,7 +326,7 @@ func Test_Model_InsertIgnore(t *testing.T) { t.AssertNE(err, nil) }) gtest.C(t, func(t *gtest.T) { - _, err := db.Table(table).Filter().Data(g.Map{ + _, err := db.Model(table).Filter().Data(g.Map{ "id": 1, "uid": 1, "passport": "t1", @@ -343,7 +343,7 @@ func Test_Model_Batch(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createTable() defer dropTable(table) - result, err := db.Table(table).Filter().Data(g.List{ + result, err := db.Model(table).Filter().Data(g.List{ { "id": 2, "uid": 2, @@ -372,7 +372,7 @@ func Test_Model_Batch(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createTable() defer dropTable(table) - result, err := db.Table(table).Data(g.List{ + result, err := db.Model(table).Data(g.List{ {"passport": "t1"}, {"passport": "t2"}, {"passport": "t3"}, @@ -390,34 +390,34 @@ func Test_Model_Batch(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createInitTable() defer dropTable(table) - result, err := db.Table(table).All() + result, err := db.Model(table).All() t.AssertNil(err) - t.Assert(len(result), SIZE) + t.Assert(len(result), TableSize) for _, v := range result { v["nickname"].Set(v["nickname"].String() + v["id"].String()) } - r, e := db.Table(table).Data(result).Save() + r, e := db.Model(table).Data(result).Save() t.Assert(e, nil) n, e := r.RowsAffected() t.Assert(e, nil) - t.Assert(n, SIZE*2) + t.Assert(n, TableSize*2) }) // batch replace gtest.C(t, func(t *gtest.T) { table := createInitTable() defer dropTable(table) - result, err := db.Table(table).All() + result, err := db.Model(table).All() t.AssertNil(err) - t.Assert(len(result), SIZE) + t.Assert(len(result), TableSize) for _, v := range result { v["nickname"].Set(v["nickname"].String() + v["id"].String()) } - r, e := db.Table(table).Data(result).Replace() + r, e := db.Model(table).Data(result).Replace() t.Assert(e, nil) n, e := r.RowsAffected() t.Assert(e, nil) - t.Assert(n, SIZE*2) + t.Assert(n, TableSize*2) }) } @@ -426,7 +426,7 @@ func Test_Model_Replace(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Data(g.Map{ + result, err := db.Model(table).Data(g.Map{ "id": 1, "passport": "t11", "password": "25d55ad283aa400af464c76d713c07ad", @@ -443,7 +443,7 @@ func Test_Model_Save(t *testing.T) { table := createTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Data(g.Map{ + result, err := db.Model(table).Data(g.Map{ "id": 1, "passport": "t111", "password": "25d55ad283aa400af464c76d713c07ad", @@ -461,29 +461,29 @@ func Test_Model_Update(t *testing.T) { defer dropTable(table) // UPDATE...LIMIT gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Data("nickname", "T100").Where(1).Order("id desc").Limit(2).Update() + result, err := db.Model(table).Data("nickname", "T100").Where(1).Order("id desc").Limit(2).Update() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 2) - v1, err := db.Table(table).Fields("nickname").Where("id", 10).Value() + v1, err := db.Model(table).Fields("nickname").Where("id", 10).Value() t.AssertNil(err) t.Assert(v1.String(), "T100") - v2, err := db.Table(table).Fields("nickname").Where("id", 8).Value() + v2, err := db.Model(table).Fields("nickname").Where("id", 8).Value() t.AssertNil(err) t.Assert(v2.String(), "name_8") }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Data("passport", "user_22").Where("passport=?", "user_2").Update() + result, err := db.Model(table).Data("passport", "user_22").Where("passport=?", "user_2").Update() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 1) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Data("passport", "user_2").Where("passport='user_22'").Update() + result, err := db.Model(table).Data("passport", "user_2").Where("passport='user_22'").Update() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 1) @@ -491,14 +491,14 @@ func Test_Model_Update(t *testing.T) { // Update + Data(string) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Data("passport='user_33'").Where("passport='user_3'").Update() + result, err := db.Model(table).Data("passport='user_33'").Where("passport='user_3'").Update() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 1) }) // Update + Fields(string) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Fields("passport").Data(g.Map{ + result, err := db.Model(table).Fields("passport").Data(g.Map{ "passport": "user_44", "none": "none", }).Where("passport='user_4'").Update() @@ -513,7 +513,7 @@ func Test_Model_Clone(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - md := db.Table(table).Where("id IN(?)", g.Slice{1, 3}) + md := db.Model(table).Where("id IN(?)", g.Slice{1, 3}) count, err := md.Count() t.AssertNil(err) @@ -536,7 +536,7 @@ func Test_Model_Safe(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - md := db.Table(table).Safe(false).Where("id IN(?)", g.Slice{1, 3}) + md := db.Model(table).Safe(false).Where("id IN(?)", g.Slice{1, 3}) count, err := md.Count() t.AssertNil(err) t.Assert(count, 2) @@ -547,7 +547,7 @@ func Test_Model_Safe(t *testing.T) { t.Assert(count, 1) }) gtest.C(t, func(t *gtest.T) { - md := db.Table(table).Safe(true).Where("id IN(?)", g.Slice{1, 3}) + md := db.Model(table).Safe(true).Where("id IN(?)", g.Slice{1, 3}) count, err := md.Count() t.AssertNil(err) t.Assert(count, 2) @@ -559,7 +559,7 @@ func Test_Model_Safe(t *testing.T) { }) gtest.C(t, func(t *gtest.T) { - md := db.Table(table).Safe().Where("id IN(?)", g.Slice{1, 3}) + md := db.Model(table).Safe().Where("id IN(?)", g.Slice{1, 3}) count, err := md.Count() t.AssertNil(err) t.Assert(count, 2) @@ -570,7 +570,7 @@ func Test_Model_Safe(t *testing.T) { t.Assert(count, 2) }) gtest.C(t, func(t *gtest.T) { - md1 := db.Table(table).Safe() + md1 := db.Model(table).Safe() md2 := md1.Where("id in (?)", g.Slice{1, 3}) count, err := md2.Count() t.AssertNil(err) @@ -589,7 +589,7 @@ func Test_Model_Safe(t *testing.T) { table := createInitTable() defer dropTable(table) - md1 := db.Table(table).Where("id>", 0).Safe() + md1 := db.Model(table).Where("id>", 0).Safe() md2 := md1.Where("id in (?)", g.Slice{1, 3}) md3 := md1.Where("id in (?)", g.Slice{4, 5, 6}) @@ -631,12 +631,12 @@ func Test_Model_All(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).All() + result, err := db.Model(table).All() t.AssertNil(err) - t.Assert(len(result), SIZE) + t.Assert(len(result), TableSize) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id<0").All() + result, err := db.Model(table).Where("id<0").All() t.Assert(result, nil) t.AssertNil(err) }) @@ -670,13 +670,13 @@ func Test_Model_Fields(t *testing.T) { gtest.Assert(n, 1) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(tableName1).As("u").Fields("u.passport,u.id").Where("u.id<2").All() + all, err := db.Model(tableName1).As("u").Fields("u.passport,u.id").Where("u.id<2").All() t.AssertNil(err) t.Assert(len(all), 1) t.Assert(len(all[0]), 2) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(tableName1).As("u1"). + all, err := db.Model(tableName1).As("u1"). LeftJoin(tableName1, "u2", "u2.id=u1.id"). Fields("u1.passport,u1.id,u2.id AS u2id"). Where("u1.id<2"). @@ -686,7 +686,7 @@ func Test_Model_Fields(t *testing.T) { t.Assert(len(all[0]), 3) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(tableName1).As("u1"). + all, err := db.Model(tableName1).As("u1"). LeftJoin(tableName2, "u2", "u2.id=u1.id"). Fields("u1.passport,u1.id,u2.name,u2.age"). Where("u1.id<2"). @@ -706,21 +706,21 @@ func Test_Model_FindAll(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).FindAll(5) + result, err := db.Model(table).FindAll(5) t.AssertNil(err) t.Assert(len(result), 1) t.Assert(result[0]["id"].Int(), 5) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Order("id asc").FindAll("id", 8) + result, err := db.Model(table).Order("id asc").FindAll("id", 8) t.AssertNil(err) t.Assert(len(result), 1) t.Assert(result[0]["id"].Int(), 8) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Order("id asc").FindAll(g.Slice{3, 9}) + result, err := db.Model(table).Order("id asc").FindAll(g.Slice{3, 9}) t.AssertNil(err) t.Assert(len(result), 2) t.Assert(result[0]["id"].Int(), 3) @@ -728,12 +728,12 @@ func Test_Model_FindAll(t *testing.T) { }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).FindAll() + result, err := db.Model(table).FindAll() t.AssertNil(err) - t.Assert(len(result), SIZE) + t.Assert(len(result), TableSize) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id<0").FindAll() + result, err := db.Model(table).Where("id<0").FindAll() t.Assert(result, nil) t.AssertNil(err) }) @@ -744,28 +744,28 @@ func Test_Model_FindAll_GTime(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).FindAll("create_time < ?", gtime.NewFromStr("2000-01-01 00:00:00")) + result, err := db.Model(table).FindAll("create_time < ?", gtime.NewFromStr("2000-01-01 00:00:00")) t.AssertNil(err) t.Assert(len(result), 0) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).FindAll("create_time > ?", gtime.NewFromStr("2000-01-01 00:00:00")) + result, err := db.Model(table).FindAll("create_time > ?", gtime.NewFromStr("2000-01-01 00:00:00")) t.AssertNil(err) - t.Assert(len(result), SIZE) + t.Assert(len(result), TableSize) }) gtest.C(t, func(t *gtest.T) { v := g.NewVar("2000-01-01 00:00:00") - result, err := db.Table(table).FindAll("create_time < ?", v) + result, err := db.Model(table).FindAll("create_time < ?", v) t.AssertNil(err) t.Assert(len(result), 0) }) gtest.C(t, func(t *gtest.T) { v := g.NewVar("2000-01-01 00:00:00") - result, err := db.Table(table).FindAll("create_time > ?", v) + result, err := db.Model(table).FindAll("create_time > ?", v) t.AssertNil(err) - t.Assert(len(result), SIZE) + t.Assert(len(result), TableSize) }) } @@ -773,13 +773,13 @@ func Test_Model_One(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - record, err := db.Table(table).Where("id", 1).One() + record, err := db.Model(table).Where("id", 1).One() t.AssertNil(err) t.Assert(record["nickname"].String(), "name_1") }) gtest.C(t, func(t *gtest.T) { - record, err := db.Table(table).Where("id", 0).One() + record, err := db.Model(table).Where("id", 0).One() t.AssertNil(err) t.Assert(record, nil) }) @@ -790,31 +790,31 @@ func Test_Model_FindOne(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - record, err := db.Table(table).FindOne(1) + record, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(record["nickname"].String(), "name_1") }) gtest.C(t, func(t *gtest.T) { - record, err := db.Table(table).FindOne(3) + record, err := db.Model(table).FindOne(3) t.AssertNil(err) t.Assert(record["nickname"].String(), "name_3") }) gtest.C(t, func(t *gtest.T) { - record, err := db.Table(table).Where("id", 1).FindOne() + record, err := db.Model(table).Where("id", 1).FindOne() t.AssertNil(err) t.Assert(record["nickname"].String(), "name_1") }) gtest.C(t, func(t *gtest.T) { - record, err := db.Table(table).FindOne("id", 9) + record, err := db.Model(table).FindOne("id", 9) t.AssertNil(err) t.Assert(record["nickname"].String(), "name_9") }) gtest.C(t, func(t *gtest.T) { - record, err := db.Table(table).Where("id", 0).FindOne() + record, err := db.Model(table).Where("id", 0).FindOne() t.AssertNil(err) t.Assert(record, nil) }) @@ -825,13 +825,13 @@ func Test_Model_Value(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).Fields("nickname").Where("id", 1).Value() + value, err := db.Model(table).Fields("nickname").Where("id", 1).Value() t.AssertNil(err) t.Assert(value.String(), "name_1") }) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).Fields("nickname").Where("id", 0).Value() + value, err := db.Model(table).Fields("nickname").Where("id", 0).Value() t.AssertNil(err) t.Assert(value, nil) }) @@ -842,28 +842,28 @@ func Test_Model_Array(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id", g.Slice{1, 2, 3}).All() + all, err := db.Model(table).Where("id", g.Slice{1, 2, 3}).All() t.AssertNil(err) t.Assert(all.Array("id"), g.Slice{1, 2, 3}) t.Assert(all.Array("nickname"), g.Slice{"name_1", "name_2", "name_3"}) }) gtest.C(t, func(t *gtest.T) { - array, err := db.Table(table).Fields("nickname").Where("id", g.Slice{1, 2, 3}).Array() + array, err := db.Model(table).Fields("nickname").Where("id", g.Slice{1, 2, 3}).Array() t.AssertNil(err) t.Assert(array, g.Slice{"name_1", "name_2", "name_3"}) }) gtest.C(t, func(t *gtest.T) { - array, err := db.Table(table).Array("nickname", "id", g.Slice{1, 2, 3}) + array, err := db.Model(table).Array("nickname", "id", g.Slice{1, 2, 3}) t.AssertNil(err) t.Assert(array, g.Slice{"name_1", "name_2", "name_3"}) }) gtest.C(t, func(t *gtest.T) { - array, err := db.Table(table).FindArray("nickname", "id", g.Slice{1, 2, 3}) + array, err := db.Model(table).FindArray("nickname", "id", g.Slice{1, 2, 3}) t.AssertNil(err) t.Assert(array, g.Slice{"name_1", "name_2", "name_3"}) }) gtest.C(t, func(t *gtest.T) { - array, err := db.Table(table).FindArray("nickname", g.Slice{1, 2, 3}) + array, err := db.Model(table).FindArray("nickname", g.Slice{1, 2, 3}) t.AssertNil(err) t.Assert(array, g.Slice{"name_1", "name_2", "name_3"}) }) @@ -874,25 +874,25 @@ func Test_Model_FindValue(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).FindValue("nickname", 1) + value, err := db.Model(table).FindValue("nickname", 1) t.AssertNil(err) t.Assert(value.String(), "name_1") }) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).Order("id desc").FindValue("nickname") + value, err := db.Model(table).Order("id desc").FindValue("nickname") t.AssertNil(err) t.Assert(value.String(), "name_10") }) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).Fields("nickname").Where("id", 1).FindValue() + value, err := db.Model(table).Fields("nickname").Where("id", 1).FindValue() t.AssertNil(err) t.Assert(value.String(), "name_1") }) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).Fields("nickname").Where("id", 0).FindValue() + value, err := db.Model(table).Fields("nickname").Where("id", 0).FindValue() t.AssertNil(err) t.Assert(value, nil) }) @@ -902,33 +902,33 @@ func Test_Model_Count(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - count, err := db.Table(table).Count() + count, err := db.Model(table).Count() t.AssertNil(err) - t.Assert(count, SIZE) + t.Assert(count, TableSize) }) gtest.C(t, func(t *gtest.T) { - count, err := db.Table(table).FieldsEx("id").Where("id>8").Count() + count, err := db.Model(table).FieldsEx("id").Where("id>8").Count() t.AssertNil(err) t.Assert(count, 2) }) gtest.C(t, func(t *gtest.T) { - count, err := db.Table(table).Fields("distinct id,nickname").Where("id>8").Count() + count, err := db.Model(table).Fields("distinct id,nickname").Where("id>8").Count() t.AssertNil(err) t.Assert(count, 2) }) // COUNT...LIMIT... gtest.C(t, func(t *gtest.T) { - count, err := db.Table(table).Page(1, 2).Count() + count, err := db.Model(table).Page(1, 2).Count() t.AssertNil(err) - t.Assert(count, SIZE) + t.Assert(count, TableSize) }) //gtest.C(t, func(t *gtest.T) { - // count, err := db.Table(table).Fields("id myid").Where("id>8").Count() + // count, err := db.Model(table).Fields("id myid").Where("id>8").Count() // t.AssertNil(err) // t.Assert(count, 2) //}) //gtest.C(t, func(t *gtest.T) { - // count, err := db.Table(table).As("u1").LeftJoin(table, "u2", "u2.id=u1.id").Fields("u2.id u2id").Where("u1.id>8").Count() + // count, err := db.Model(table).As("u1").LeftJoin(table, "u2", "u2.id=u1.id").Fields("u2.id u2id").Where("u1.id>8").Count() // t.AssertNil(err) // t.Assert(count, 2) //}) @@ -938,19 +938,19 @@ func Test_Model_FindCount(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - count, err := db.Table(table).FindCount(g.Slice{1, 3}) + count, err := db.Model(table).FindCount(g.Slice{1, 3}) t.AssertNil(err) t.Assert(count, 2) }) gtest.C(t, func(t *gtest.T) { - count, err := db.Table(table).FindCount(g.Slice{1, 300000}) + count, err := db.Model(table).FindCount(g.Slice{1, 300000}) t.AssertNil(err) t.Assert(count, 1) }) gtest.C(t, func(t *gtest.T) { - count, err := db.Table(table).FindCount() + count, err := db.Model(table).FindCount() t.AssertNil(err) - t.Assert(count, SIZE) + t.Assert(count, TableSize) }) } @@ -958,9 +958,9 @@ func Test_Model_Select(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Select() + result, err := db.Model(table).Select() t.AssertNil(err) - t.Assert(len(result), SIZE) + t.Assert(len(result), TableSize) }) } @@ -976,7 +976,7 @@ func Test_Model_Struct(t *testing.T) { CreateTime gtime.Time } user := new(User) - err := db.Table(table).Where("id=1").Struct(user) + err := db.Model(table).Where("id=1").Struct(user) t.AssertNil(err) t.Assert(user.NickName, "name_1") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") @@ -990,7 +990,7 @@ func Test_Model_Struct(t *testing.T) { CreateTime *gtime.Time } user := new(User) - err := db.Table(table).Where("id=1").Struct(user) + err := db.Model(table).Where("id=1").Struct(user) t.AssertNil(err) t.Assert(user.NickName, "name_1") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") @@ -1005,7 +1005,7 @@ func Test_Model_Struct(t *testing.T) { CreateTime *gtime.Time } user := (*User)(nil) - err := db.Table(table).Where("id=1").Struct(&user) + err := db.Model(table).Where("id=1").Struct(&user) t.AssertNil(err) t.Assert(user.NickName, "name_1") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") @@ -1020,7 +1020,7 @@ func Test_Model_Struct(t *testing.T) { CreateTime *gtime.Time } user := (*User)(nil) - err := db.Table(table).Where("id=1").Scan(&user) + err := db.Model(table).Where("id=1").Scan(&user) if err != nil { gtest.Error(err) } @@ -1037,7 +1037,7 @@ func Test_Model_Struct(t *testing.T) { CreateTime *gtime.Time } user := new(User) - err := db.Table(table).Where("id=-1").Struct(user) + err := db.Model(table).Where("id=-1").Struct(user) t.Assert(err, sql.ErrNoRows) }) gtest.C(t, func(t *gtest.T) { @@ -1049,7 +1049,7 @@ func Test_Model_Struct(t *testing.T) { CreateTime *gtime.Time } var user *User - err := db.Table(table).Where("id=-1").Struct(&user) + err := db.Model(table).Where("id=-1").Struct(&user) t.AssertNil(err) }) } @@ -1069,7 +1069,7 @@ func Test_Model_Struct_CustomType(t *testing.T) { CreateTime gtime.Time } user := new(User) - err := db.Table(table).Where("id=1").Struct(user) + err := db.Model(table).Where("id=1").Struct(user) t.AssertNil(err) t.Assert(user.NickName, "name_1") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") @@ -1089,11 +1089,11 @@ func Test_Model_Structs(t *testing.T) { CreateTime gtime.Time } var users []User - err := db.Table(table).Order("id asc").Structs(&users) + err := db.Model(table).Order("id asc").Structs(&users) if err != nil { gtest.Error(err) } - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -1112,11 +1112,11 @@ func Test_Model_Structs(t *testing.T) { CreateTime *gtime.Time } var users []*User - err := db.Table(table).Order("id asc").Structs(&users) + err := db.Model(table).Order("id asc").Structs(&users) if err != nil { gtest.Error(err) } - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -1135,11 +1135,11 @@ func Test_Model_Structs(t *testing.T) { CreateTime *gtime.Time } var users []*User - err := db.Table(table).Order("id asc").Scan(&users) + err := db.Model(table).Order("id asc").Scan(&users) if err != nil { gtest.Error(err) } - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -1158,7 +1158,7 @@ func Test_Model_Structs(t *testing.T) { CreateTime *gtime.Time } var users []*User - err := db.Table(table).Where("id<0").Structs(&users) + err := db.Model(table).Where("id<0").Structs(&users) t.AssertNil(err) }) } @@ -1176,11 +1176,11 @@ func Test_Model_StructsWithJsonTag(t *testing.T) { Time gtime.Time `json:"create_time"` } var users []User - err := db.Table(table).Order("id asc").Structs(&users) + err := db.Model(table).Order("id asc").Structs(&users) if err != nil { gtest.Error(err) } - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Uid, 1) t.Assert(users[1].Uid, 2) t.Assert(users[2].Uid, 3) @@ -1204,7 +1204,7 @@ func Test_Model_Scan(t *testing.T) { CreateTime gtime.Time } user := new(User) - err := db.Table(table).Where("id=1").Scan(user) + err := db.Model(table).Where("id=1").Scan(user) t.AssertNil(err) t.Assert(user.NickName, "name_1") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") @@ -1218,7 +1218,7 @@ func Test_Model_Scan(t *testing.T) { CreateTime *gtime.Time } user := new(User) - err := db.Table(table).Where("id=1").Scan(user) + err := db.Model(table).Where("id=1").Scan(user) t.AssertNil(err) t.Assert(user.NickName, "name_1") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") @@ -1232,9 +1232,9 @@ func Test_Model_Scan(t *testing.T) { CreateTime gtime.Time } var users []User - err := db.Table(table).Order("id asc").Scan(&users) + err := db.Model(table).Order("id asc").Scan(&users) t.AssertNil(err) - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -1252,9 +1252,9 @@ func Test_Model_Scan(t *testing.T) { CreateTime *gtime.Time } var users []*User - err := db.Table(table).Order("id asc").Scan(&users) + err := db.Model(table).Order("id asc").Scan(&users) t.AssertNil(err) - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -1276,8 +1276,8 @@ func Test_Model_Scan(t *testing.T) { user = new(User) users = new([]*User) ) - err1 := db.Table(table).Where("id < 0").Scan(user) - err2 := db.Table(table).Where("id < 0").Scan(users) + err1 := db.Model(table).Where("id < 0").Scan(user) + err2 := db.Model(table).Where("id < 0").Scan(users) t.Assert(err1, sql.ErrNoRows) t.Assert(err2, nil) }) @@ -1288,10 +1288,10 @@ func Test_Model_OrderBy(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Order("id DESC").Select() + result, err := db.Model(table).Order("id DESC").Select() t.AssertNil(err) - t.Assert(len(result), SIZE) - t.Assert(result[0]["nickname"].String(), fmt.Sprintf("name_%d", SIZE)) + t.Assert(len(result), TableSize) + t.Assert(result[0]["nickname"].String(), fmt.Sprintf("name_%d", TableSize)) }) } @@ -1300,9 +1300,9 @@ func Test_Model_GroupBy(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).GroupBy("id").Select() + result, err := db.Model(table).GroupBy("id").Select() t.AssertNil(err) - t.Assert(len(result), SIZE) + t.Assert(len(result), TableSize) t.Assert(result[0]["nickname"].String(), "name_1") }) } @@ -1311,7 +1311,7 @@ func Test_Model_Data(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createInitTable() defer dropTable(table) - result, err := db.Table(table).Data("nickname=?", "test").Where("id=?", 3).Update() + result, err := db.Model(table).Data("nickname=?", "test").Where("id=?", 3).Update() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 1) @@ -1328,7 +1328,7 @@ func Test_Model_Data(t *testing.T) { "nickname": fmt.Sprintf(`nickname_%d`, i), }) } - result, err := db.Table(table).Data(users).Batch(2).Insert() + result, err := db.Model(table).Data(users).Batch(2).Insert() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 10) @@ -1345,7 +1345,7 @@ func Test_Model_Data(t *testing.T) { "nickname": fmt.Sprintf(`nickname_%d`, i), }) } - result, err := db.Table(table).Data(users).Batch(2).Insert() + result, err := db.Model(table).Data(users).Batch(2).Insert() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 10) @@ -1358,7 +1358,7 @@ func Test_Model_Where(t *testing.T) { // string gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id=? and nickname=?", 3, "name_3").One() + result, err := db.Model(table).Where("id=? and nickname=?", 3, "name_3").One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) @@ -1366,13 +1366,13 @@ func Test_Model_Where(t *testing.T) { // slice gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(g.Slice{"id", 3}).One() + result, err := db.Model(table).Where(g.Slice{"id", 3}).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(g.Slice{"id", 3, "nickname", "name_3"}).One() + result, err := db.Model(table).Where(g.Slice{"id", 3, "nickname", "name_3"}).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) @@ -1380,14 +1380,14 @@ func Test_Model_Where(t *testing.T) { // slice parameter gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id=? and nickname=?", g.Slice{3, "name_3"}).One() + result, err := db.Model(table).Where("id=? and nickname=?", g.Slice{3, "name_3"}).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) // map like gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(g.Map{ + result, err := db.Model(table).Where(g.Map{ "passport like": "user_1%", }).Order("id asc").All() t.AssertNil(err) @@ -1397,7 +1397,7 @@ func Test_Model_Where(t *testing.T) { }) // map + slice parameter gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(g.Map{ + result, err := db.Model(table).Where(g.Map{ "id": g.Slice{1, 2, 3}, "passport": g.Slice{"user_2", "user_3"}, }).And("id=? and nickname=?", g.Slice{3, "name_3"}).One() @@ -1406,112 +1406,112 @@ func Test_Model_Where(t *testing.T) { t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id=3", g.Slice{}).One() + result, err := db.Model(table).Where("id=3", g.Slice{}).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id=?", g.Slice{3}).One() + result, err := db.Model(table).Where("id=?", g.Slice{3}).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id", 3).One() + result, err := db.Model(table).Where("id", 3).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id", 3).Where("nickname", "name_3").One() + result, err := db.Model(table).Where("id", 3).Where("nickname", "name_3").One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id", 3).And("nickname", "name_3").One() + result, err := db.Model(table).Where("id", 3).And("nickname", "name_3").One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id", 30).Or("nickname", "name_3").One() + result, err := db.Model(table).Where("id", 30).Or("nickname", "name_3").One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id", 30).Or("nickname", "name_3").And("id>?", 1).One() + result, err := db.Model(table).Where("id", 30).Or("nickname", "name_3").And("id>?", 1).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id", 30).Or("nickname", "name_3").And("id>", 1).One() + result, err := db.Model(table).Where("id", 30).Or("nickname", "name_3").And("id>", 1).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // slice gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id=? AND nickname=?", g.Slice{3, "name_3"}...).One() + result, err := db.Model(table).Where("id=? AND nickname=?", g.Slice{3, "name_3"}...).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id=? AND nickname=?", g.Slice{3, "name_3"}).One() + result, err := db.Model(table).Where("id=? AND nickname=?", g.Slice{3, "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("passport like ? and nickname like ?", g.Slice{"user_3", "name_3"}).One() + result, err := db.Model(table).Where("passport like ? and nickname like ?", g.Slice{"user_3", "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(g.Map{"id": 3, "nickname": "name_3"}).One() + result, err := db.Model(table).Where(g.Map{"id": 3, "nickname": "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // map key operator gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(g.Map{"id>": 1, "id<": 3}).One() + result, err := db.Model(table).Where(g.Map{"id>": 1, "id<": 3}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 2) }) // gmap.Map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(gmap.NewFrom(g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() + result, err := db.Model(table).Where(gmap.NewFrom(g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // gmap.Map key operator gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(gmap.NewFrom(g.MapAnyAny{"id>": 1, "id<": 3})).One() + result, err := db.Model(table).Where(gmap.NewFrom(g.MapAnyAny{"id>": 1, "id<": 3})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 2) }) // list map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(gmap.NewListMapFrom(g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() + result, err := db.Model(table).Where(gmap.NewListMapFrom(g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // list map key operator gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(gmap.NewListMapFrom(g.MapAnyAny{"id>": 1, "id<": 3})).One() + result, err := db.Model(table).Where(gmap.NewListMapFrom(g.MapAnyAny{"id>": 1, "id<": 3})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 2) }) // tree map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(gmap.NewTreeMapFrom(gutil.ComparatorString, g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() + result, err := db.Model(table).Where(gmap.NewTreeMapFrom(gutil.ComparatorString, g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // tree map key operator gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(gmap.NewTreeMapFrom(gutil.ComparatorString, g.MapAnyAny{"id>": 1, "id<": 3})).One() + result, err := db.Model(table).Where(gmap.NewTreeMapFrom(gutil.ComparatorString, g.MapAnyAny{"id>": 1, "id<": 3})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 2) }) @@ -1526,7 +1526,7 @@ func Test_Model_Where(t *testing.T) { "create_time > 0": nil, "id": g.Slice{1, 2, 3}, } - result, err := db.Table(table).Where(conditions).Order("id asc").All() + result, err := db.Model(table).Where(conditions).Order("id asc").All() t.AssertNil(err) t.Assert(len(result), 3) t.Assert(result[0]["id"].Int(), 1) @@ -1541,7 +1541,7 @@ func Test_Model_Where(t *testing.T) { "create_time > ?": 0, "id in(?)": g.Slice{1, 2, 3}, } - result, err := db.Table(table).Where(conditions).Order("id asc").All() + result, err := db.Model(table).Where(conditions).Order("id asc").All() t.AssertNil(err) t.Assert(len(result), 3) t.Assert(result[0]["id"].Int(), 1) @@ -1552,17 +1552,17 @@ func Test_Model_Where(t *testing.T) { Id int `json:"id"` Nickname string `gconv:"nickname"` } - result, err := db.Table(table).Where(User{3, "name_3"}).One() + result, err := db.Model(table).Where(User{3, "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) - result, err = db.Table(table).Where(&User{3, "name_3"}).One() + result, err = db.Model(table).Where(&User{3, "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // slice single gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("id IN(?)", g.Slice{1, 3}).Order("id ASC").All() + result, err := db.Model(table).Where("id IN(?)", g.Slice{1, 3}).Order("id ASC").All() t.AssertNil(err) t.Assert(len(result), 2) t.Assert(result[0]["id"].Int(), 1) @@ -1570,14 +1570,14 @@ func Test_Model_Where(t *testing.T) { }) // slice + string gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("nickname=? AND id IN(?)", "name_3", g.Slice{1, 3}).Order("id ASC").All() + result, err := db.Model(table).Where("nickname=? AND id IN(?)", "name_3", g.Slice{1, 3}).Order("id ASC").All() t.AssertNil(err) t.Assert(len(result), 1) t.Assert(result[0]["id"].Int(), 3) }) // slice + map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(g.Map{ + result, err := db.Model(table).Where(g.Map{ "id": g.Slice{1, 3}, "nickname": "name_3", }).Order("id ASC").All() @@ -1591,7 +1591,7 @@ func Test_Model_Where(t *testing.T) { Ids []int `json:"id"` Nickname string `gconv:"nickname"` } - result, err := db.Table(table).Where(User{ + result, err := db.Model(table).Where(User{ Ids: []int{1, 3}, Nickname: "name_3", }).Order("id ASC").All() @@ -1607,12 +1607,12 @@ func Test_Model_Where_ISNULL_1(t *testing.T) { gtest.C(t, func(t *gtest.T) { //db.SetDebug(true) - result, err := db.Table(table).Data("nickname", nil).Where("id", 2).Update() + result, err := db.Model(table).Data("nickname", nil).Where("id", 2).Update() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).Where("nickname", nil).One() + one, err := db.Model(table).Where("nickname", nil).One() t.AssertNil(err) t.Assert(one.IsEmpty(), false) t.Assert(one["id"], 2) @@ -1633,7 +1633,7 @@ func Test_Model_Where_ISNULL_2(t *testing.T) { "create_time > 0": nil, "id": g.Slice{1, 2, 3}, } - result, err := db.Table(table).WherePri(conditions).Order("id asc").All() + result, err := db.Model(table).WherePri(conditions).Order("id asc").All() t.AssertNil(err) t.Assert(len(result), 3) t.Assert(result[0]["id"].Int(), 1) @@ -1647,7 +1647,7 @@ func Test_Model_Where_OmitEmpty(t *testing.T) { conditions := g.Map{ "id < 4": "", } - result, err := db.Table(table).WherePri(conditions).Order("id asc").All() + result, err := db.Model(table).WherePri(conditions).Order("id asc").All() t.AssertNil(err) t.Assert(len(result), 3) t.Assert(result[0]["id"].Int(), 1) @@ -1656,7 +1656,7 @@ func Test_Model_Where_OmitEmpty(t *testing.T) { conditions := g.Map{ "id < 4": "", } - result, err := db.Table(table).WherePri(conditions).OmitEmpty().Order("id asc").All() + result, err := db.Model(table).WherePri(conditions).OmitEmpty().Order("id asc").All() t.AssertNil(err) t.Assert(len(result), 3) t.Assert(result[0]["id"].Int(), 1) @@ -1668,12 +1668,12 @@ func Test_Model_Where_GTime(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("create_time>?", gtime.NewFromStr("2010-09-01")).All() + result, err := db.Model(table).Where("create_time>?", gtime.NewFromStr("2010-09-01")).All() t.AssertNil(err) t.Assert(len(result), 10) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where("create_time>?", *gtime.NewFromStr("2010-09-01")).All() + result, err := db.Model(table).Where("create_time>?", *gtime.NewFromStr("2010-09-01")).All() t.AssertNil(err) t.Assert(len(result), 10) }) @@ -1685,13 +1685,13 @@ func Test_Model_WherePri(t *testing.T) { // primary key gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).WherePri(3).One() + one, err := db.Model(table).WherePri(3).One() t.AssertNil(err) t.AssertNE(one, nil) t.Assert(one["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).WherePri(g.Slice{3, 9}).Order("id asc").All() + all, err := db.Model(table).WherePri(g.Slice{3, 9}).Order("id asc").All() t.AssertNil(err) t.Assert(len(all), 2) t.Assert(all[0]["id"].Int(), 3) @@ -1700,21 +1700,21 @@ func Test_Model_WherePri(t *testing.T) { // string gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id=? and nickname=?", 3, "name_3").One() + result, err := db.Model(table).WherePri("id=? and nickname=?", 3, "name_3").One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) // slice parameter gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id=? and nickname=?", g.Slice{3, "name_3"}).One() + result, err := db.Model(table).WherePri("id=? and nickname=?", g.Slice{3, "name_3"}).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) // map like gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(g.Map{ + result, err := db.Model(table).WherePri(g.Map{ "passport like": "user_1%", }).Order("id asc").All() t.AssertNil(err) @@ -1724,7 +1724,7 @@ func Test_Model_WherePri(t *testing.T) { }) // map + slice parameter gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(g.Map{ + result, err := db.Model(table).WherePri(g.Map{ "id": g.Slice{1, 2, 3}, "passport": g.Slice{"user_2", "user_3"}, }).And("id=? and nickname=?", g.Slice{3, "name_3"}).One() @@ -1733,7 +1733,7 @@ func Test_Model_WherePri(t *testing.T) { t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(g.Map{ + result, err := db.Model(table).WherePri(g.Map{ "id": g.Slice{1, 2, 3}, "passport": g.Slice{"user_2", "user_3"}, }).Or("nickname=?", g.Slice{"name_4"}).And("id", 3).One() @@ -1742,112 +1742,112 @@ func Test_Model_WherePri(t *testing.T) { t.Assert(result["id"].Int(), 2) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id=3", g.Slice{}).One() + result, err := db.Model(table).WherePri("id=3", g.Slice{}).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id=?", g.Slice{3}).One() + result, err := db.Model(table).WherePri("id=?", g.Slice{3}).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id", 3).One() + result, err := db.Model(table).WherePri("id", 3).One() t.AssertNil(err) t.AssertGT(len(result), 0) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id", 3).WherePri("nickname", "name_3").One() + result, err := db.Model(table).WherePri("id", 3).WherePri("nickname", "name_3").One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id", 3).And("nickname", "name_3").One() + result, err := db.Model(table).WherePri("id", 3).And("nickname", "name_3").One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id", 30).Or("nickname", "name_3").One() + result, err := db.Model(table).WherePri("id", 30).Or("nickname", "name_3").One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id", 30).Or("nickname", "name_3").And("id>?", 1).One() + result, err := db.Model(table).WherePri("id", 30).Or("nickname", "name_3").And("id>?", 1).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id", 30).Or("nickname", "name_3").And("id>", 1).One() + result, err := db.Model(table).WherePri("id", 30).Or("nickname", "name_3").And("id>", 1).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // slice gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id=? AND nickname=?", g.Slice{3, "name_3"}...).One() + result, err := db.Model(table).WherePri("id=? AND nickname=?", g.Slice{3, "name_3"}...).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id=? AND nickname=?", g.Slice{3, "name_3"}).One() + result, err := db.Model(table).WherePri("id=? AND nickname=?", g.Slice{3, "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("passport like ? and nickname like ?", g.Slice{"user_3", "name_3"}).One() + result, err := db.Model(table).WherePri("passport like ? and nickname like ?", g.Slice{"user_3", "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(g.Map{"id": 3, "nickname": "name_3"}).One() + result, err := db.Model(table).WherePri(g.Map{"id": 3, "nickname": "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // map key operator gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(g.Map{"id>": 1, "id<": 3}).One() + result, err := db.Model(table).WherePri(g.Map{"id>": 1, "id<": 3}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 2) }) // gmap.Map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(gmap.NewFrom(g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() + result, err := db.Model(table).WherePri(gmap.NewFrom(g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // gmap.Map key operator gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(gmap.NewFrom(g.MapAnyAny{"id>": 1, "id<": 3})).One() + result, err := db.Model(table).WherePri(gmap.NewFrom(g.MapAnyAny{"id>": 1, "id<": 3})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 2) }) // list map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(gmap.NewListMapFrom(g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() + result, err := db.Model(table).WherePri(gmap.NewListMapFrom(g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // list map key operator gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(gmap.NewListMapFrom(g.MapAnyAny{"id>": 1, "id<": 3})).One() + result, err := db.Model(table).WherePri(gmap.NewListMapFrom(g.MapAnyAny{"id>": 1, "id<": 3})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 2) }) // tree map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(gmap.NewTreeMapFrom(gutil.ComparatorString, g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() + result, err := db.Model(table).WherePri(gmap.NewTreeMapFrom(gutil.ComparatorString, g.MapAnyAny{"id": 3, "nickname": "name_3"})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // tree map key operator gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(gmap.NewTreeMapFrom(gutil.ComparatorString, g.MapAnyAny{"id>": 1, "id<": 3})).One() + result, err := db.Model(table).WherePri(gmap.NewTreeMapFrom(gutil.ComparatorString, g.MapAnyAny{"id>": 1, "id<": 3})).One() t.AssertNil(err) t.Assert(result["id"].Int(), 2) }) @@ -1862,7 +1862,7 @@ func Test_Model_WherePri(t *testing.T) { "create_time > 0": nil, "id": g.Slice{1, 2, 3}, } - result, err := db.Table(table).WherePri(conditions).Order("id asc").All() + result, err := db.Model(table).WherePri(conditions).Order("id asc").All() t.AssertNil(err) t.Assert(len(result), 3) t.Assert(result[0]["id"].Int(), 1) @@ -1877,7 +1877,7 @@ func Test_Model_WherePri(t *testing.T) { "create_time > ?": 0, "id in(?)": g.Slice{1, 2, 3}, } - result, err := db.Table(table).WherePri(conditions).Order("id asc").All() + result, err := db.Model(table).WherePri(conditions).Order("id asc").All() t.AssertNil(err) t.Assert(len(result), 3) t.Assert(result[0]["id"].Int(), 1) @@ -1888,17 +1888,17 @@ func Test_Model_WherePri(t *testing.T) { Id int `json:"id"` Nickname string `gconv:"nickname"` } - result, err := db.Table(table).WherePri(User{3, "name_3"}).One() + result, err := db.Model(table).WherePri(User{3, "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) - result, err = db.Table(table).WherePri(&User{3, "name_3"}).One() + result, err = db.Model(table).WherePri(&User{3, "name_3"}).One() t.AssertNil(err) t.Assert(result["id"].Int(), 3) }) // slice single gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("id IN(?)", g.Slice{1, 3}).Order("id ASC").All() + result, err := db.Model(table).WherePri("id IN(?)", g.Slice{1, 3}).Order("id ASC").All() t.AssertNil(err) t.Assert(len(result), 2) t.Assert(result[0]["id"].Int(), 1) @@ -1906,14 +1906,14 @@ func Test_Model_WherePri(t *testing.T) { }) // slice + string gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri("nickname=? AND id IN(?)", "name_3", g.Slice{1, 3}).Order("id ASC").All() + result, err := db.Model(table).WherePri("nickname=? AND id IN(?)", "name_3", g.Slice{1, 3}).Order("id ASC").All() t.AssertNil(err) t.Assert(len(result), 1) t.Assert(result[0]["id"].Int(), 3) }) // slice + map gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).WherePri(g.Map{ + result, err := db.Model(table).WherePri(g.Map{ "id": g.Slice{1, 3}, "nickname": "name_3", }).Order("id ASC").All() @@ -1927,7 +1927,7 @@ func Test_Model_WherePri(t *testing.T) { Ids []int `json:"id"` Nickname string `gconv:"nickname"` } - result, err := db.Table(table).WherePri(User{ + result, err := db.Model(table).WherePri(User{ Ids: []int{1, 3}, Nickname: "name_3", }).Order("id ASC").All() @@ -1943,17 +1943,17 @@ func Test_Model_Delete(t *testing.T) { // DELETE...LIMIT gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(1).Limit(2).Delete() + result, err := db.Model(table).Where(1).Limit(2).Delete() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 2) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(1).Delete() + result, err := db.Model(table).Where(1).Delete() t.AssertNil(err) n, _ := result.RowsAffected() - t.Assert(n, SIZE-2) + t.Assert(n, TableSize-2) }) } @@ -1961,7 +1961,7 @@ func Test_Model_Offset(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Limit(2).Offset(5).Order("id").Select() + result, err := db.Model(table).Limit(2).Offset(5).Order("id").Select() t.AssertNil(err) t.Assert(len(result), 2) t.Assert(result[0]["id"], 6) @@ -1973,20 +1973,20 @@ func Test_Model_Page(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Page(3, 3).Order("id").All() + result, err := db.Model(table).Page(3, 3).Order("id").All() t.AssertNil(err) t.Assert(len(result), 3) t.Assert(result[0]["id"], 7) t.Assert(result[1]["id"], 8) }) gtest.C(t, func(t *gtest.T) { - model := db.Table(table).Safe().Order("id") + model := db.Model(table).Safe().Order("id") all, err := model.Page(3, 3).All() count, err := model.Count() t.AssertNil(err) t.Assert(len(all), 3) t.Assert(all[0]["id"], "7") - t.Assert(count, SIZE) + t.Assert(count, TableSize) }) } @@ -1995,7 +1995,7 @@ func Test_Model_Option_Map(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createTable() defer dropTable(table) - r, err := db.Table(table).Fields("id, passport").Data(g.Map{ + r, err := db.Model(table).Fields("id, passport").Data(g.Map{ "id": 1, "passport": "1", "password": "1", @@ -2004,7 +2004,7 @@ func Test_Model_Option_Map(t *testing.T) { t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).Where("id", 1).One() + one, err := db.Model(table).Where("id", 1).One() t.AssertNil(err) t.AssertNE(one["password"].String(), "1") t.AssertNE(one["nickname"].String(), "1") @@ -2013,7 +2013,7 @@ func Test_Model_Option_Map(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createTable() defer dropTable(table) - r, err := db.Table(table).Option(gdb.OptionOmitEmpty).Data(g.Map{ + r, err := db.Model(table).Option(gdb.OptionOmitEmpty).Data(g.Map{ "id": 1, "passport": 0, "password": 0, @@ -2022,7 +2022,7 @@ func Test_Model_Option_Map(t *testing.T) { t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).Where("id", 1).One() + one, err := db.Model(table).Where("id", 1).One() t.AssertNil(err) t.AssertNE(one["passport"].String(), "0") t.AssertNE(one["password"].String(), "0") @@ -2033,14 +2033,14 @@ func Test_Model_Option_Map(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createInitTable() defer dropTable(table) - _, err := db.Table(table).Option(gdb.OptionOmitEmpty).Data(g.Map{ + _, err := db.Model(table).Option(gdb.OptionOmitEmpty).Data(g.Map{ "id": 1, "passport": 0, "password": 0, "nickname": "1", }).Replace() t.AssertNil(err) - one, err := db.Table(table).Where("id", 1).One() + one, err := db.Model(table).Where("id", 1).One() t.AssertNil(err) t.AssertNE(one["passport"].String(), "0") t.AssertNE(one["password"].String(), "0") @@ -2051,7 +2051,7 @@ func Test_Model_Option_Map(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createTable() defer dropTable(table) - r, err := db.Table(table).Fields("id, passport").Data(g.Map{ + r, err := db.Model(table).Fields("id, passport").Data(g.Map{ "id": 1, "passport": "1", "password": "1", @@ -2060,7 +2060,7 @@ func Test_Model_Option_Map(t *testing.T) { t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).Where("id", 1).One() + one, err := db.Model(table).Where("id", 1).One() t.AssertNil(err) t.AssertNE(one["password"].String(), "1") t.AssertNE(one["nickname"].String(), "1") @@ -2069,27 +2069,27 @@ func Test_Model_Option_Map(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createTable() defer dropTable(table) - _, err := db.Table(table).Option(gdb.OptionOmitEmpty).Data(g.Map{ + _, err := db.Model(table).Option(gdb.OptionOmitEmpty).Data(g.Map{ "id": 1, "passport": 0, "password": 0, "nickname": "1", }).Save() t.AssertNil(err) - one, err := db.Table(table).Where("id", 1).One() + one, err := db.Model(table).Where("id", 1).One() t.AssertNil(err) t.AssertNE(one["passport"].String(), "0") t.AssertNE(one["password"].String(), "0") t.Assert(one["nickname"].String(), "1") - _, err = db.Table(table).Data(g.Map{ + _, err = db.Model(table).Data(g.Map{ "id": 1, "passport": 0, "password": 0, "nickname": "1", }).Save() t.AssertNil(err) - one, err = db.Table(table).Where("id", 1).One() + one, err = db.Model(table).Where("id", 1).One() t.AssertNil(err) t.Assert(one["passport"].String(), "0") t.Assert(one["password"].String(), "0") @@ -2101,23 +2101,23 @@ func Test_Model_Option_Map(t *testing.T) { table := createInitTable() defer dropTable(table) - r, err := db.Table(table).Data(g.Map{"nickname": ""}).Where("id", 1).Update() + r, err := db.Model(table).Data(g.Map{"nickname": ""}).Where("id", 1).Update() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - _, err = db.Table(table).Option(gdb.OptionOmitEmpty).Data(g.Map{"nickname": ""}).Where("id", 2).Update() + _, err = db.Model(table).Option(gdb.OptionOmitEmpty).Data(g.Map{"nickname": ""}).Where("id", 2).Update() t.AssertNE(err, nil) - r, err = db.Table(table).OmitEmpty().Data(g.Map{"nickname": "", "password": "123"}).Where("id", 3).Update() + r, err = db.Model(table).OmitEmpty().Data(g.Map{"nickname": "", "password": "123"}).Where("id", 3).Update() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - _, err = db.Table(table).OmitEmpty().Fields("nickname").Data(g.Map{"nickname": "", "password": "123"}).Where("id", 4).Update() + _, err = db.Model(table).OmitEmpty().Fields("nickname").Data(g.Map{"nickname": "", "password": "123"}).Where("id", 4).Update() t.AssertNE(err, nil) - r, err = db.Table(table).OmitEmpty(). + r, err = db.Model(table).OmitEmpty(). Fields("password").Data(g.Map{ "nickname": "", "passport": "123", @@ -2127,7 +2127,7 @@ func Test_Model_Option_Map(t *testing.T) { n, _ = r.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).Where("id", 5).One() + one, err := db.Model(table).Where("id", 5).One() t.AssertNil(err) t.Assert(one["password"], "456") t.AssertNE(one["passport"].String(), "") @@ -2139,7 +2139,7 @@ func Test_Model_Option_List(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createTable() defer dropTable(table) - r, err := db.Table(table).Fields("id, password").Data(g.List{ + r, err := db.Model(table).Fields("id, password").Data(g.List{ g.Map{ "id": 1, "passport": "1", @@ -2156,7 +2156,7 @@ func Test_Model_Option_List(t *testing.T) { t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 2) - list, err := db.Table(table).Order("id asc").All() + list, err := db.Model(table).Order("id asc").All() t.AssertNil(err) t.Assert(len(list), 2) t.Assert(list[0]["id"].String(), "1") @@ -2173,7 +2173,7 @@ func Test_Model_Option_List(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createTable() defer dropTable(table) - r, err := db.Table(table).OmitEmpty().Fields("id, password").Data(g.List{ + r, err := db.Model(table).OmitEmpty().Fields("id, password").Data(g.List{ g.Map{ "id": 1, "passport": "1", @@ -2190,7 +2190,7 @@ func Test_Model_Option_List(t *testing.T) { t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 2) - list, err := db.Table(table).Order("id asc").All() + list, err := db.Model(table).Order("id asc").All() t.AssertNil(err) t.Assert(len(list), 2) t.Assert(list[0]["id"].String(), "1") @@ -2219,7 +2219,7 @@ func Test_Model_OmitEmpty(t *testing.T) { gtest.Error(err) } defer dropTable(table) - _, err := db.Table(table).OmitEmpty().Data(g.Map{ + _, err := db.Model(table).OmitEmpty().Data(g.Map{ "id": 1, "name": "", }).Save() @@ -2231,20 +2231,20 @@ func Test_Model_Option_Where(t *testing.T) { gtest.C(t, func(t *gtest.T) { table := createInitTable() defer dropTable(table) - r, err := db.Table(table).OmitEmpty().Data("nickname", 1).Where(g.Map{"id": 0, "passport": ""}).And(1).Update() + r, err := db.Model(table).OmitEmpty().Data("nickname", 1).Where(g.Map{"id": 0, "passport": ""}).And(1).Update() t.AssertNil(err) n, _ := r.RowsAffected() - t.Assert(n, SIZE) + t.Assert(n, TableSize) }) gtest.C(t, func(t *gtest.T) { table := createInitTable() defer dropTable(table) - r, err := db.Table(table).OmitEmpty().Data("nickname", 1).Where(g.Map{"id": 1, "passport": ""}).Update() + r, err := db.Model(table).OmitEmpty().Data("nickname", 1).Where(g.Map{"id": 1, "passport": ""}).Update() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - v, err := db.Table(table).Where("id", 1).Fields("nickname").Value() + v, err := db.Model(table).Where("id", 1).Fields("nickname").Value() t.AssertNil(err) t.Assert(v.String(), "1") }) @@ -2254,7 +2254,7 @@ func Test_Model_Where_MultiSliceArguments(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table).Where(g.Map{ + r, err := db.Model(table).Where(g.Map{ "id": g.Slice{1, 2, 3, 4}, "passport": g.Slice{"user_2", "user_3", "user_4"}, "nickname": g.Slice{"name_2", "name_4"}, @@ -2266,7 +2266,7 @@ func Test_Model_Where_MultiSliceArguments(t *testing.T) { }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).Where(g.Map{ + result, err := db.Model(table).Where(g.Map{ "id": g.Slice{1, 2, 3}, "passport": g.Slice{"user_2", "user_3"}, }).Or("nickname=?", g.Slice{"name_4"}).And("id", 3).One() @@ -2281,7 +2281,7 @@ func Test_Model_FieldsEx(t *testing.T) { defer dropTable(table) // Select. gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table).FieldsEx("create_time, id").Where("id in (?)", g.Slice{1, 2}).Order("id asc").All() + r, err := db.Model(table).FieldsEx("create_time, id").Where("id in (?)", g.Slice{1, 2}).Order("id asc").All() t.AssertNil(err) t.Assert(len(r), 2) t.Assert(len(r[0]), 3) @@ -2298,12 +2298,12 @@ func Test_Model_FieldsEx(t *testing.T) { }) // Update. gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table).FieldsEx("password").Data(g.Map{"nickname": "123", "password": "456"}).Where("id", 3).Update() + r, err := db.Model(table).FieldsEx("password").Data(g.Map{"nickname": "123", "password": "456"}).Where("id", 3).Update() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).Where("id", 3).One() + one, err := db.Model(table).Where("id", 3).One() t.AssertNil(err) t.Assert(one["nickname"], "123") t.AssertNE(one["password"], "456") @@ -2318,7 +2318,7 @@ func Test_Model_FieldsEx_WithReservedWords(t *testing.T) { } defer dropTable(table) gtest.C(t, func(t *gtest.T) { - _, err := db.Table(table).FieldsEx("content").One() + _, err := db.Model(table).FieldsEx("content").One() t.AssertNil(err) }) } @@ -2328,8 +2328,8 @@ func Test_Model_FieldsStr(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - t.Assert(db.Table(table).FieldsStr(), "`id`,`passport`,`password`,`nickname`,`create_time`") - t.Assert(db.Table(table).FieldsStr("a."), "`a`.`id`,`a`.`passport`,`a`.`password`,`a`.`nickname`,`a`.`create_time`") + t.Assert(db.Model(table).FieldsStr(), "`id`,`passport`,`password`,`nickname`,`create_time`") + t.Assert(db.Model(table).FieldsStr("a."), "`a`.`id`,`a`.`passport`,`a`.`password`,`a`.`nickname`,`a`.`create_time`") }) } @@ -2338,19 +2338,19 @@ func Test_Model_FieldsExStr(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - t.Assert(db.Table(table).FieldsExStr("create_time,nickname"), "`id`,`passport`,`password`") - t.Assert(db.Table(table).FieldsExStr("create_time,nickname", "a."), "`a`.`id`,`a`.`passport`,`a`.`password`") + t.Assert(db.Model(table).FieldsExStr("create_time,nickname"), "`id`,`passport`,`password`") + t.Assert(db.Model(table).FieldsExStr("create_time,nickname", "a."), "`a`.`id`,`a`.`passport`,`a`.`password`") }) } func Test_Model_Prefix(t *testing.T) { db := dbPrefix - table := fmt.Sprintf(`%s_%d`, TABLE, gtime.TimestampNano()) - createInitTableWithDb(db, PREFIX1+table) - defer dropTable(PREFIX1 + table) + table := fmt.Sprintf(`%s_%d`, TableName, gtime.TimestampNano()) + createInitTableWithDb(db, TableNamePrefix1+table) + defer dropTable(TableNamePrefix1 + table) // Select. gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table).Where("id in (?)", g.Slice{1, 2}).Order("id asc").All() + r, err := db.Model(table).Where("id in (?)", g.Slice{1, 2}).Order("id asc").All() t.AssertNil(err) t.Assert(len(r), 2) t.Assert(r[0]["id"], "1") @@ -2358,7 +2358,7 @@ func Test_Model_Prefix(t *testing.T) { }) // Select with alias. gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table+" as u").Where("u.id in (?)", g.Slice{1, 2}).Order("u.id asc").All() + r, err := db.Model(table+" as u").Where("u.id in (?)", g.Slice{1, 2}).Order("u.id asc").All() t.AssertNil(err) t.Assert(len(r), 2) t.Assert(r[0]["id"], "1") @@ -2366,14 +2366,14 @@ func Test_Model_Prefix(t *testing.T) { }) // Select with alias and join statement. gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table+" as u1").LeftJoin(table+" as u2", "u2.id=u1.id").Where("u1.id in (?)", g.Slice{1, 2}).Order("u1.id asc").All() + r, err := db.Model(table+" as u1").LeftJoin(table+" as u2", "u2.id=u1.id").Where("u1.id in (?)", g.Slice{1, 2}).Order("u1.id asc").All() t.AssertNil(err) t.Assert(len(r), 2) t.Assert(r[0]["id"], "1") t.Assert(r[1]["id"], "2") }) gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table).As("u1").LeftJoin(table+" as u2", "u2.id=u1.id").Where("u1.id in (?)", g.Slice{1, 2}).Order("u1.id asc").All() + r, err := db.Model(table).As("u1").LeftJoin(table+" as u2", "u2.id=u1.id").Where("u1.id in (?)", g.Slice{1, 2}).Order("u1.id asc").All() t.AssertNil(err) t.Assert(len(r), 2) t.Assert(r[0]["id"], "1") @@ -2384,63 +2384,63 @@ func Test_Model_Prefix(t *testing.T) { func Test_Model_Schema1(t *testing.T) { //db.SetDebug(true) - db.SetSchema(SCHEMA1) - table := fmt.Sprintf(`%s_%s`, TABLE, gtime.TimestampNanoStr()) + db.SetSchema(TestSchema1) + table := fmt.Sprintf(`%s_%s`, TableName, gtime.TimestampNanoStr()) createInitTableWithDb(db, table) - db.SetSchema(SCHEMA2) + db.SetSchema(TestSchema2) createInitTableWithDb(db, table) defer func() { - db.SetSchema(SCHEMA1) + db.SetSchema(TestSchema1) dropTableWithDb(db, table) - db.SetSchema(SCHEMA2) + db.SetSchema(TestSchema2) dropTableWithDb(db, table) - db.SetSchema(SCHEMA1) + db.SetSchema(TestSchema1) }() // Method. gtest.C(t, func(t *gtest.T) { - db.SetSchema(SCHEMA1) - r, err := db.Table(table).Update(g.Map{"nickname": "name_100"}, "id=1") + db.SetSchema(TestSchema1) + r, err := db.Model(table).Update(g.Map{"nickname": "name_100"}, "id=1") t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - v, err := db.Table(table).Value("nickname", "id=1") + v, err := db.Model(table).Value("nickname", "id=1") t.AssertNil(err) t.Assert(v.String(), "name_100") - db.SetSchema(SCHEMA2) - v, err = db.Table(table).Value("nickname", "id=1") + db.SetSchema(TestSchema2) + v, err = db.Model(table).Value("nickname", "id=1") t.AssertNil(err) t.Assert(v.String(), "name_1") }) // Model. gtest.C(t, func(t *gtest.T) { - v, err := db.Table(table).Schema(SCHEMA1).Value("nickname", "id=2") + v, err := db.Model(table).Schema(TestSchema1).Value("nickname", "id=2") t.AssertNil(err) t.Assert(v.String(), "name_2") - r, err := db.Table(table).Schema(SCHEMA1).Update(g.Map{"nickname": "name_200"}, "id=2") + r, err := db.Model(table).Schema(TestSchema1).Update(g.Map{"nickname": "name_200"}, "id=2") t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - v, err = db.Table(table).Schema(SCHEMA1).Value("nickname", "id=2") + v, err = db.Model(table).Schema(TestSchema1).Value("nickname", "id=2") t.AssertNil(err) t.Assert(v.String(), "name_200") - v, err = db.Table(table).Schema(SCHEMA2).Value("nickname", "id=2") + v, err = db.Model(table).Schema(TestSchema2).Value("nickname", "id=2") t.AssertNil(err) t.Assert(v.String(), "name_2") - v, err = db.Table(table).Schema(SCHEMA1).Value("nickname", "id=2") + v, err = db.Model(table).Schema(TestSchema1).Value("nickname", "id=2") t.AssertNil(err) t.Assert(v.String(), "name_200") }) // Model. gtest.C(t, func(t *gtest.T) { i := 1000 - _, err := db.Table(table).Schema(SCHEMA1).Filter().Insert(g.Map{ + _, err := db.Model(table).Schema(TestSchema1).Filter().Insert(g.Map{ "id": i, "passport": fmt.Sprintf(`user_%d`, i), "password": fmt.Sprintf(`pass_%d`, i), @@ -2450,11 +2450,11 @@ func Test_Model_Schema1(t *testing.T) { }) t.AssertNil(err) - v, err := db.Table(table).Schema(SCHEMA1).Value("nickname", "id=?", i) + v, err := db.Model(table).Schema(TestSchema1).Value("nickname", "id=?", i) t.AssertNil(err) t.Assert(v.String(), "name_1000") - v, err = db.Table(table).Schema(SCHEMA2).Value("nickname", "id=?", i) + v, err = db.Model(table).Schema(TestSchema2).Value("nickname", "id=?", i) t.AssertNil(err) t.Assert(v.String(), "") }) @@ -2463,46 +2463,46 @@ func Test_Model_Schema1(t *testing.T) { func Test_Model_Schema2(t *testing.T) { //db.SetDebug(true) - db.SetSchema(SCHEMA1) - table := fmt.Sprintf(`%s_%s`, TABLE, gtime.TimestampNanoStr()) + db.SetSchema(TestSchema1) + table := fmt.Sprintf(`%s_%s`, TableName, gtime.TimestampNanoStr()) createInitTableWithDb(db, table) - db.SetSchema(SCHEMA2) + db.SetSchema(TestSchema2) createInitTableWithDb(db, table) defer func() { - db.SetSchema(SCHEMA1) + db.SetSchema(TestSchema1) dropTableWithDb(db, table) - db.SetSchema(SCHEMA2) + db.SetSchema(TestSchema2) dropTableWithDb(db, table) - db.SetSchema(SCHEMA1) + db.SetSchema(TestSchema1) }() // Schema. gtest.C(t, func(t *gtest.T) { - v, err := db.Schema(SCHEMA1).Table(table).Value("nickname", "id=2") + v, err := db.Schema(TestSchema1).Table(table).Value("nickname", "id=2") t.AssertNil(err) t.Assert(v.String(), "name_2") - r, err := db.Schema(SCHEMA1).Table(table).Update(g.Map{"nickname": "name_200"}, "id=2") + r, err := db.Schema(TestSchema1).Table(table).Update(g.Map{"nickname": "name_200"}, "id=2") t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - v, err = db.Schema(SCHEMA1).Table(table).Value("nickname", "id=2") + v, err = db.Schema(TestSchema1).Table(table).Value("nickname", "id=2") t.AssertNil(err) t.Assert(v.String(), "name_200") - v, err = db.Schema(SCHEMA2).Table(table).Value("nickname", "id=2") + v, err = db.Schema(TestSchema2).Table(table).Value("nickname", "id=2") t.AssertNil(err) t.Assert(v.String(), "name_2") - v, err = db.Schema(SCHEMA1).Table(table).Value("nickname", "id=2") + v, err = db.Schema(TestSchema1).Table(table).Value("nickname", "id=2") t.AssertNil(err) t.Assert(v.String(), "name_200") }) // Schema. gtest.C(t, func(t *gtest.T) { i := 1000 - _, err := db.Schema(SCHEMA1).Table(table).Filter().Insert(g.Map{ + _, err := db.Schema(TestSchema1).Table(table).Filter().Insert(g.Map{ "id": i, "passport": fmt.Sprintf(`user_%d`, i), "password": fmt.Sprintf(`pass_%d`, i), @@ -2512,11 +2512,11 @@ func Test_Model_Schema2(t *testing.T) { }) t.AssertNil(err) - v, err := db.Schema(SCHEMA1).Table(table).Value("nickname", "id=?", i) + v, err := db.Schema(TestSchema1).Table(table).Value("nickname", "id=?", i) t.AssertNil(err) t.Assert(v.String(), "name_1000") - v, err = db.Schema(SCHEMA2).Table(table).Value("nickname", "id=?", i) + v, err = db.Schema(TestSchema2).Table(table).Value("nickname", "id=?", i) t.AssertNil(err) t.Assert(v.String(), "") }) @@ -2538,7 +2538,7 @@ func Test_Model_FieldsExStruct(t *testing.T) { Password: "222", NickName: "333", } - r, err := db.Table(table).FieldsEx("create_time, password").OmitEmpty().Data(user).Insert() + r, err := db.Model(table).FieldsEx("create_time, password").OmitEmpty().Data(user).Insert() t.AssertNil(err) n, err := r.RowsAffected() t.AssertNil(err) @@ -2560,7 +2560,7 @@ func Test_Model_FieldsExStruct(t *testing.T) { NickName: fmt.Sprintf(`nickname_%d`, i), }) } - r, err := db.Table(table).FieldsEx("create_time, password"). + r, err := db.Model(table).FieldsEx("create_time, password"). OmitEmpty(). Batch(2). Data(users). @@ -2588,7 +2588,7 @@ func Test_Model_OmitEmpty_Time(t *testing.T) { Password: "222", Time: time.Time{}, } - r, err := db.Table(table).OmitEmpty().Data(user).WherePri(1).Update() + r, err := db.Model(table).OmitEmpty().Data(user).WherePri(1).Update() t.AssertNil(err) n, err := r.RowsAffected() t.AssertNil(err) @@ -2600,7 +2600,7 @@ func Test_Result_Chunk(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table).Order("id asc").All() + r, err := db.Model(table).Order("id asc").All() t.AssertNil(err) chunks := r.Chunk(3) t.Assert(len(chunks), 4) @@ -2618,12 +2618,12 @@ func Test_Model_DryRun(t *testing.T) { defer db.SetDryRun(false) gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).FindOne(1) + one, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(one["id"], 1) }) gtest.C(t, func(t *gtest.T) { - r, err := db.Table(table).Data("passport", "port_1").WherePri(1).Update() + r, err := db.Model(table).Data("passport", "port_1").WherePri(1).Update() t.AssertNil(err) n, err := r.RowsAffected() t.AssertNil(err) @@ -2636,11 +2636,11 @@ func Test_Model_Join_SubQuery(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { subQuery := fmt.Sprintf("select * from `%s`", table) - r, err := db.Table(table, "t1").Fields("t2.id").LeftJoin(subQuery, "t2", "t2.id=t1.id").Array() + r, err := db.Model(table, "t1").Fields("t2.id").LeftJoin(subQuery, "t2", "t2.id=t1.id").Array() t.AssertNil(err) - t.Assert(len(r), SIZE) + t.Assert(len(r), TableSize) t.Assert(r[0], "1") - t.Assert(r[SIZE-1], SIZE) + t.Assert(r[TableSize-1], TableSize) }) } @@ -2649,49 +2649,49 @@ func Test_Model_Cache(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).Cache(time.Second, "test1").FindOne(1) + one, err := db.Model(table).Cache(time.Second, "test1").FindOne(1) t.AssertNil(err) t.Assert(one["passport"], "user_1") - r, err := db.Table(table).Data("passport", "user_100").WherePri(1).Update() + r, err := db.Model(table).Data("passport", "user_100").WherePri(1).Update() t.AssertNil(err) n, err := r.RowsAffected() t.AssertNil(err) t.Assert(n, 1) - one, err = db.Table(table).Cache(time.Second, "test1").FindOne(1) + one, err = db.Model(table).Cache(time.Second, "test1").FindOne(1) t.AssertNil(err) t.Assert(one["passport"], "user_1") time.Sleep(time.Second * 2) - one, err = db.Table(table).Cache(time.Second, "test1").FindOne(1) + one, err = db.Model(table).Cache(time.Second, "test1").FindOne(1) t.AssertNil(err) t.Assert(one["passport"], "user_100") }) gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).Cache(time.Second, "test2").FindOne(2) + one, err := db.Model(table).Cache(time.Second, "test2").FindOne(2) t.AssertNil(err) t.Assert(one["passport"], "user_2") - r, err := db.Table(table).Data("passport", "user_200").Cache(-1, "test2").WherePri(2).Update() + r, err := db.Model(table).Data("passport", "user_200").Cache(-1, "test2").WherePri(2).Update() t.AssertNil(err) n, err := r.RowsAffected() t.AssertNil(err) t.Assert(n, 1) - one, err = db.Table(table).Cache(time.Second, "test2").FindOne(2) + one, err = db.Model(table).Cache(time.Second, "test2").FindOne(2) t.AssertNil(err) t.Assert(one["passport"], "user_200") }) // transaction. gtest.C(t, func(t *gtest.T) { // make cache for id 3 - one, err := db.Table(table).Cache(time.Second, "test3").FindOne(3) + one, err := db.Model(table).Cache(time.Second, "test3").FindOne(3) t.AssertNil(err) t.Assert(one["passport"], "user_3") - r, err := db.Table(table).Data("passport", "user_300").Cache(time.Second, "test3").WherePri(3).Update() + r, err := db.Model(table).Data("passport", "user_300").Cache(time.Second, "test3").WherePri(3).Update() t.AssertNil(err) n, err := r.RowsAffected() t.AssertNil(err) @@ -2705,17 +2705,17 @@ func Test_Model_Cache(t *testing.T) { }) t.AssertNil(err) - one, err = db.Table(table).Cache(time.Second, "test3").FindOne(3) + one, err = db.Model(table).Cache(time.Second, "test3").FindOne(3) t.AssertNil(err) t.Assert(one["passport"], "user_3") }) gtest.C(t, func(t *gtest.T) { // make cache for id 4 - one, err := db.Table(table).Cache(time.Second, "test4").FindOne(4) + one, err := db.Model(table).Cache(time.Second, "test4").FindOne(4) t.AssertNil(err) t.Assert(one["passport"], "user_4") - r, err := db.Table(table).Data("passport", "user_400").Cache(time.Second, "test3").WherePri(4).Update() + r, err := db.Model(table).Data("passport", "user_400").Cache(time.Second, "test3").WherePri(4).Update() t.AssertNil(err) n, err := r.RowsAffected() t.AssertNil(err) @@ -2737,7 +2737,7 @@ func Test_Model_Cache(t *testing.T) { }) t.AssertNil(err) // Read from db. - one, err = db.Table(table).Cache(time.Second, "test4").FindOne(4) + one, err = db.Model(table).Cache(time.Second, "test4").FindOne(4) t.AssertNil(err) t.Assert(one["passport"], "user_4000") }) @@ -2748,22 +2748,22 @@ func Test_Model_Having(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id > 1").Having("id > 8").All() + all, err := db.Model(table).Where("id > 1").Having("id > 8").All() t.AssertNil(err) t.Assert(len(all), 2) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id > 1").Having("id > ?", 8).All() + all, err := db.Model(table).Where("id > 1").Having("id > ?", 8).All() t.AssertNil(err) t.Assert(len(all), 2) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id > ?", 1).Having("id > ?", 8).All() + all, err := db.Model(table).Where("id > ?", 1).Having("id > ?", 8).All() t.AssertNil(err) t.Assert(len(all), 2) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id > ?", 1).Having("id", 8).All() + all, err := db.Model(table).Where("id > ?", 1).Having("id", 8).All() t.AssertNil(err) t.Assert(len(all), 1) }) @@ -2774,7 +2774,7 @@ func Test_Model_Distinct(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table, "t").Fields("distinct t.id").Where("id > 1").Having("id > 8").All() + all, err := db.Model(table, "t").Fields("distinct t.id").Where("id > 1").Having("id > 8").All() t.AssertNil(err) t.Assert(len(all), 2) }) @@ -2785,12 +2785,12 @@ func Test_Model_Min_Max(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table, "t").Fields("min(t.id)").Where("id > 1").Value() + value, err := db.Model(table, "t").Fields("min(t.id)").Where("id > 1").Value() t.AssertNil(err) t.Assert(value.Int(), 2) }) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table, "t").Fields("max(t.id)").Where("id > 1").Value() + value, err := db.Model(table, "t").Fields("max(t.id)").Where("id > 1").Value() t.AssertNil(err) t.Assert(value.Int(), 10) }) @@ -2801,19 +2801,19 @@ func Test_Model_Fields_AutoMapping(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).Fields("ID").Where("id", 2).Value() + value, err := db.Model(table).Fields("ID").Where("id", 2).Value() t.AssertNil(err) t.Assert(value.Int(), 2) }) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).Fields("NICK_NAME").Where("id", 2).Value() + value, err := db.Model(table).Fields("NICK_NAME").Where("id", 2).Value() t.AssertNil(err) t.Assert(value.String(), "name_2") }) // Map gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).Fields(g.Map{ + one, err := db.Model(table).Fields(g.Map{ "ID": 1, "NICK_NAME": 1, }).Where("id", 2).One() @@ -2828,7 +2828,7 @@ func Test_Model_Fields_AutoMapping(t *testing.T) { ID int NICKNAME int } - one, err := db.Table(table).Fields(&T{ + one, err := db.Model(table).Fields(&T{ ID: 0, NICKNAME: 0, }).Where("id", 2).One() @@ -2850,19 +2850,19 @@ func Test_Model_FieldsEx_AutoMapping(t *testing.T) { // "create_time": gtime.NewFromStr("2018-10-24 10:00:00").String(), gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).FieldsEx("Passport, Password, NickName, CreateTime").Where("id", 2).Value() + value, err := db.Model(table).FieldsEx("Passport, Password, NickName, CreateTime").Where("id", 2).Value() t.AssertNil(err) t.Assert(value.Int(), 2) }) gtest.C(t, func(t *gtest.T) { - value, err := db.Table(table).FieldsEx("ID, Passport, Password, CreateTime").Where("id", 2).Value() + value, err := db.Model(table).FieldsEx("ID, Passport, Password, CreateTime").Where("id", 2).Value() t.AssertNil(err) t.Assert(value.String(), "name_2") }) // Map gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).FieldsEx(g.Map{ + one, err := db.Model(table).FieldsEx(g.Map{ "Passport": 1, "Password": 1, "CreateTime": 1, @@ -2879,7 +2879,7 @@ func Test_Model_FieldsEx_AutoMapping(t *testing.T) { Password int CreateTime int } - one, err := db.Table(table).FieldsEx(&T{ + one, err := db.Model(table).FieldsEx(&T{ Passport: 0, Password: 0, CreateTime: 0, @@ -2904,21 +2904,21 @@ func Test_Model_Fields_Struct(t *testing.T) { NickName string } gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).Fields(A{}).Where("id", 2).One() + one, err := db.Model(table).Fields(A{}).Where("id", 2).One() t.AssertNil(err) t.Assert(len(one), 2) t.Assert(one["passport"], "user_2") t.Assert(one["password"], "pass_2") }) gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).Fields(&A{}).Where("id", 2).One() + one, err := db.Model(table).Fields(&A{}).Where("id", 2).One() t.AssertNil(err) t.Assert(len(one), 2) t.Assert(one["passport"], "user_2") t.Assert(one["password"], "pass_2") }) gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).Fields(B{}).Where("id", 2).One() + one, err := db.Model(table).Fields(B{}).Where("id", 2).One() t.AssertNil(err) t.Assert(len(one), 3) t.Assert(one["passport"], "user_2") @@ -2926,7 +2926,7 @@ func Test_Model_Fields_Struct(t *testing.T) { t.Assert(one["nickname"], "name_2") }) gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).Fields(&B{}).Where("id", 2).One() + one, err := db.Model(table).Fields(&B{}).Where("id", 2).One() t.AssertNil(err) t.Assert(len(one), 3) t.Assert(one["passport"], "user_2") @@ -2947,11 +2947,11 @@ func Test_Model_NullField(t *testing.T) { "id": 1, "passport": nil, } - result, err := db.Table(table).Data(data).Insert() + result, err := db.Model(table).Data(data).Insert() t.AssertNil(err) n, _ := result.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table).FindOne(1) + one, err := db.Model(table).FindOne(1) t.AssertNil(err) var user *User @@ -2999,13 +2999,13 @@ func Test_Model_HasField(t *testing.T) { defer dropTable(table) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).HasField("id") + result, err := db.Model(table).HasField("id") t.Assert(result, true) t.AssertNil(err) }) gtest.C(t, func(t *gtest.T) { - result, err := db.Table(table).HasField("id123") + result, err := db.Model(table).HasField("id123") t.Assert(result, false) t.AssertNil(err) }) @@ -3016,7 +3016,7 @@ func Test_Model_Issue1002(t *testing.T) { table := createTable() defer dropTable(table) - result, err := db.Table(table).Data(g.Map{ + result, err := db.Model(table).Data(g.Map{ "id": 1, "passport": "port_1", "password": "pass_1", @@ -3029,49 +3029,49 @@ func Test_Model_Issue1002(t *testing.T) { // where + string. gtest.C(t, func(t *gtest.T) { - v, err := db.Table(table).Fields("id").Where("create_time>'2020-10-27 19:03:32' and create_time<'2020-10-27 19:03:34'").Value() + v, err := db.Model(table).Fields("id").Where("create_time>'2020-10-27 19:03:32' and create_time<'2020-10-27 19:03:34'").Value() t.AssertNil(err) t.Assert(v.Int(), 1) }) gtest.C(t, func(t *gtest.T) { - v, err := db.Table(table).Fields("id").Where("create_time>'2020-10-27 19:03:32' and create_time<'2020-10-27 19:03:34'").FindValue() + v, err := db.Model(table).Fields("id").Where("create_time>'2020-10-27 19:03:32' and create_time<'2020-10-27 19:03:34'").FindValue() t.AssertNil(err) t.Assert(v.Int(), 1) }) gtest.C(t, func(t *gtest.T) { - v, err := db.Table(table).Where("create_time>'2020-10-27 19:03:32' and create_time<'2020-10-27 19:03:34'").FindValue("id") + v, err := db.Model(table).Where("create_time>'2020-10-27 19:03:32' and create_time<'2020-10-27 19:03:34'").FindValue("id") t.AssertNil(err) t.Assert(v.Int(), 1) }) // where + string arguments. gtest.C(t, func(t *gtest.T) { - v, err := db.Table(table).Fields("id").Where("create_time>? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time? and create_time100").All() + all, err := db.Model(table).Where("id>100").All() t.AssertNil(err) users := make([]User, 0) t.Assert(all.Structs(&users), nil) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id>100").All() + all, err := db.Model(table).Where("id>100").All() t.AssertNil(err) users := make([]User, 10) t.Assert(all.Structs(&users), nil) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id>100").All() + all, err := db.Model(table).Where("id>100").All() t.AssertNil(err) var users []User t.Assert(all.Structs(&users), nil) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id>100").All() + all, err := db.Model(table).Where("id>100").All() t.AssertNil(err) users := make([]*User, 0) t.Assert(all.Structs(&users), nil) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id>100").All() + all, err := db.Model(table).Where("id>100").All() t.AssertNil(err) users := make([]*User, 10) t.Assert(all.Structs(&users), nil) }) gtest.C(t, func(t *gtest.T) { - all, err := db.Table(table).Where("id>100").All() + all, err := db.Model(table).Where("id>100").All() t.AssertNil(err) var users []*User t.Assert(all.Structs(&users), nil) @@ -343,21 +344,65 @@ func (st *MyTimeSt) UnmarshalValue(v interface{}) error { return nil } -func Test_Model_Scan_CustomType(t *testing.T) { +func Test_Model_Scan_CustomType_Time(t *testing.T) { table := createInitTable() defer dropTable(table) gtest.C(t, func(t *gtest.T) { st := new(MyTimeSt) - err := db.Table(table).Fields("create_time").Scan(st) + err := db.Model(table).Fields("create_time").Scan(st) t.AssertNil(err) t.Assert(st.CreateTime.String(), "2018-10-24 10:00:00") }) gtest.C(t, func(t *gtest.T) { var stSlice []*MyTimeSt - err := db.Table(table).Fields("create_time").Scan(&stSlice) + err := db.Model(table).Fields("create_time").Scan(&stSlice) t.AssertNil(err) - t.Assert(len(stSlice), SIZE) + t.Assert(len(stSlice), TableSize) t.Assert(stSlice[0].CreateTime.String(), "2018-10-24 10:00:00") t.Assert(stSlice[9].CreateTime.String(), "2018-10-24 10:00:00") }) } + +type User struct { + Id int + Passport string + Password string + Nickname string + CreateTime *gtime.Time +} + +func (user *User) UnmarshalValue(value interface{}) error { + switch result := value.(type) { + case map[string]interface{}: + user.Id = result["id"].(gdb.Value).Int() + user.Passport = result["passport"].(gdb.Value).String() + user.Password = "" + user.Nickname = result["nickname"].(gdb.Value).String() + user.CreateTime = result["create_time"].(gdb.Value).GTime() + return nil + default: + return gconv.Struct(value, user) + } +} + +func Test_Model_Scan_UnmarshalValue(t *testing.T) { + table := createInitTable() + defer dropTable(table) + gtest.C(t, func(t *gtest.T) { + var users []*User + err := db.Model(table).Order("id asc").Scan(&users) + t.AssertNil(err) + t.Assert(len(users), TableSize) + t.Assert(users[0].Id, 1) + t.Assert(users[0].Passport, "user_1") + t.Assert(users[0].Password, "") + t.Assert(users[0].Nickname, "name_1") + t.Assert(users[0].CreateTime.String(), CreateTime) + + t.Assert(users[9].Id, 10) + t.Assert(users[9].Passport, "user_10") + t.Assert(users[9].Password, "") + t.Assert(users[9].Nickname, "name_10") + t.Assert(users[9].CreateTime.String(), CreateTime) + }) +} diff --git a/database/gdb/gdb_z_mysql_time_maintain_test.go b/database/gdb/gdb_z_mysql_time_maintain_test.go index 3133b4c1d..120a4cd55 100644 --- a/database/gdb/gdb_z_mysql_time_maintain_test.go +++ b/database/gdb/gdb_z_mysql_time_maintain_test.go @@ -40,12 +40,12 @@ CREATE TABLE %s ( "id": 1, "name": "name_1", } - r, err := db.Table(table).Data(dataInsert).Insert() + r, err := db.Model(table).Data(dataInsert).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - oneInsert, err := db.Table(table).FindOne(1) + oneInsert, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneInsert["id"].Int(), 1) t.Assert(oneInsert["name"].String(), "name_1") @@ -61,12 +61,12 @@ CREATE TABLE %s ( "id": 1, "name": "name_10", } - r, err = db.Table(table).Data(dataSave).Save() + r, err = db.Model(table).Data(dataSave).Save() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 2) - oneSave, err := db.Table(table).FindOne(1) + oneSave, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneSave["id"].Int(), 1) t.Assert(oneSave["name"].String(), "name_10") @@ -82,12 +82,12 @@ CREATE TABLE %s ( dataUpdate := g.Map{ "name": "name_1000", } - r, err = db.Table(table).Data(dataUpdate).WherePri(1).Update() + r, err = db.Model(table).Data(dataUpdate).WherePri(1).Update() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - oneUpdate, err := db.Table(table).FindOne(1) + oneUpdate, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneUpdate["id"].Int(), 1) t.Assert(oneUpdate["name"].String(), "name_1000") @@ -100,12 +100,12 @@ CREATE TABLE %s ( "id": 1, "name": "name_100", } - r, err = db.Table(table).Data(dataReplace).Replace() + r, err = db.Model(table).Data(dataReplace).Replace() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 2) - oneReplace, err := db.Table(table).FindOne(1) + oneReplace, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneReplace["id"].Int(), 1) t.Assert(oneReplace["name"].String(), "name_100") @@ -117,35 +117,35 @@ CREATE TABLE %s ( time.Sleep(2 * time.Second) // Delete - r, err = db.Table(table).Delete("id", 1) + r, err = db.Model(table).Delete("id", 1) t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) // Delete Select - one4, err := db.Table(table).FindOne(1) + one4, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(len(one4), 0) - one5, err := db.Table(table).Unscoped().FindOne(1) + one5, err := db.Model(table).Unscoped().FindOne(1) t.AssertNil(err) t.Assert(one5["id"].Int(), 1) t.AssertGE(one5["delete_at"].GTime().Timestamp(), gtime.Timestamp()-2) // Delete Count - i, err := db.Table(table).FindCount() + i, err := db.Model(table).FindCount() t.AssertNil(err) t.Assert(i, 0) - i, err = db.Table(table).Unscoped().FindCount() + i, err = db.Model(table).Unscoped().FindCount() t.AssertNil(err) t.Assert(i, 1) // Delete Unscoped - r, err = db.Table(table).Unscoped().Delete("id", 1) + r, err = db.Model(table).Unscoped().Delete("id", 1) t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - one6, err := db.Table(table).Unscoped().FindOne(1) + one6, err := db.Model(table).Unscoped().FindOne(1) t.AssertNil(err) t.Assert(len(one6), 0) - i, err = db.Table(table).Unscoped().FindCount() + i, err = db.Model(table).Unscoped().FindCount() t.AssertNil(err) t.Assert(i, 0) }) @@ -174,12 +174,12 @@ CREATE TABLE %s ( "id": 1, "name": "name_1", } - r, err := db.Table(table).Data(dataInsert).Insert() + r, err := db.Model(table).Data(dataInsert).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - oneInsert, err := db.Table(table).FindOne(1) + oneInsert, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneInsert["id"].Int(), 1) t.Assert(oneInsert["name"].String(), "name_1") @@ -195,12 +195,12 @@ CREATE TABLE %s ( "id": 1, "name": "name_10", } - r, err = db.Table(table).Data(dataSave).Save() + r, err = db.Model(table).Data(dataSave).Save() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 2) - oneSave, err := db.Table(table).FindOne(1) + oneSave, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneSave["id"].Int(), 1) t.Assert(oneSave["name"].String(), "name_10") @@ -216,12 +216,12 @@ CREATE TABLE %s ( dataUpdate := g.Map{ "name": "name_1000", } - r, err = db.Table(table).Data(dataUpdate).WherePri(1).Update() + r, err = db.Model(table).Data(dataUpdate).WherePri(1).Update() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - oneUpdate, err := db.Table(table).FindOne(1) + oneUpdate, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneUpdate["id"].Int(), 1) t.Assert(oneUpdate["name"].String(), "name_1000") @@ -234,12 +234,12 @@ CREATE TABLE %s ( "id": 1, "name": "name_100", } - r, err = db.Table(table).Data(dataReplace).Replace() + r, err = db.Model(table).Data(dataReplace).Replace() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 2) - oneReplace, err := db.Table(table).FindOne(1) + oneReplace, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneReplace["id"].Int(), 1) t.Assert(oneReplace["name"].String(), "name_100") @@ -251,35 +251,35 @@ CREATE TABLE %s ( time.Sleep(2 * time.Second) // Delete - r, err = db.Table(table).Delete("id", 1) + r, err = db.Model(table).Delete("id", 1) t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) // Delete Select - one4, err := db.Table(table).FindOne(1) + one4, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(len(one4), 0) - one5, err := db.Table(table).Unscoped().FindOne(1) + one5, err := db.Model(table).Unscoped().FindOne(1) t.AssertNil(err) t.Assert(one5["id"].Int(), 1) t.AssertGE(one5["deleted_at"].GTime().Timestamp(), gtime.Timestamp()-2) // Delete Count - i, err := db.Table(table).FindCount() + i, err := db.Model(table).FindCount() t.AssertNil(err) t.Assert(i, 0) - i, err = db.Table(table).Unscoped().FindCount() + i, err = db.Model(table).Unscoped().FindCount() t.AssertNil(err) t.Assert(i, 1) // Delete Unscoped - r, err = db.Table(table).Unscoped().Delete("id", 1) + r, err = db.Model(table).Unscoped().Delete("id", 1) t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - one6, err := db.Table(table).Unscoped().FindOne(1) + one6, err := db.Model(table).Unscoped().FindOne(1) t.AssertNil(err) t.Assert(len(one6), 0) - i, err = db.Table(table).Unscoped().FindCount() + i, err = db.Model(table).Unscoped().FindCount() t.AssertNil(err) t.Assert(i, 0) }) @@ -315,12 +315,12 @@ CREATE TABLE %s ( Id: 1, Name: "name_1", } - r, err := db.Table(table).Data(dataInsert).Insert() + r, err := db.Model(table).Data(dataInsert).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - oneInsert, err := db.Table(table).FindOne(1) + oneInsert, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneInsert["id"].Int(), 1) t.Assert(oneInsert["name"].String(), "name_1") @@ -336,12 +336,12 @@ CREATE TABLE %s ( Id: 1, Name: "name_10", } - r, err = db.Table(table).Data(dataSave).OmitEmpty().Save() + r, err = db.Model(table).Data(dataSave).OmitEmpty().Save() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 2) - oneSave, err := db.Table(table).FindOne(1) + oneSave, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneSave["id"].Int(), 1) t.Assert(oneSave["name"].String(), "name_10") @@ -357,12 +357,12 @@ CREATE TABLE %s ( dataUpdate := User{ Name: "name_1000", } - r, err = db.Table(table).Data(dataUpdate).OmitEmpty().WherePri(1).Update() + r, err = db.Model(table).Data(dataUpdate).OmitEmpty().WherePri(1).Update() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - oneUpdate, err := db.Table(table).FindOne(1) + oneUpdate, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneUpdate["id"].Int(), 1) t.Assert(oneUpdate["name"].String(), "name_1000") @@ -375,12 +375,12 @@ CREATE TABLE %s ( Id: 1, Name: "name_100", } - r, err = db.Table(table).Data(dataReplace).OmitEmpty().Replace() + r, err = db.Model(table).Data(dataReplace).OmitEmpty().Replace() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 2) - oneReplace, err := db.Table(table).FindOne(1) + oneReplace, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneReplace["id"].Int(), 1) t.Assert(oneReplace["name"].String(), "name_100") @@ -392,35 +392,35 @@ CREATE TABLE %s ( time.Sleep(2 * time.Second) // Delete - r, err = db.Table(table).Delete("id", 1) + r, err = db.Model(table).Delete("id", 1) t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) // Delete Select - one4, err := db.Table(table).FindOne(1) + one4, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(len(one4), 0) - one5, err := db.Table(table).Unscoped().FindOne(1) + one5, err := db.Model(table).Unscoped().FindOne(1) t.AssertNil(err) t.Assert(one5["id"].Int(), 1) t.AssertGE(one5["deleted_at"].GTime().Timestamp(), gtime.Timestamp()-2) // Delete Count - i, err := db.Table(table).FindCount() + i, err := db.Model(table).FindCount() t.AssertNil(err) t.Assert(i, 0) - i, err = db.Table(table).Unscoped().FindCount() + i, err = db.Model(table).Unscoped().FindCount() t.AssertNil(err) t.Assert(i, 1) // Delete Unscoped - r, err = db.Table(table).Unscoped().Delete("id", 1) + r, err = db.Model(table).Unscoped().Delete("id", 1) t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - one6, err := db.Table(table).Unscoped().FindOne(1) + one6, err := db.Model(table).Unscoped().FindOne(1) t.AssertNil(err) t.Assert(len(one6), 0) - i, err = db.Table(table).Unscoped().FindCount() + i, err = db.Model(table).Unscoped().FindCount() t.AssertNil(err) t.Assert(i, 0) }) @@ -448,18 +448,18 @@ CREATE TABLE %s ( "id": 1, "num": 10, } - r, err := db.Table(table).Data(dataInsert).Insert() + r, err := db.Model(table).Data(dataInsert).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - oneInsert, err := db.Table(table).FindOne(1) + oneInsert, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneInsert["id"].Int(), 1) t.Assert(oneInsert["num"].Int(), 10) // Update. - r, err = db.Table(table).Data("num=num+1").Where("id=?", 1).Update() + r, err = db.Model(table).Data("num=num+1").Where("id=?", 1).Update() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) @@ -488,21 +488,21 @@ CREATE TABLE %s ( "id": i, "name": fmt.Sprintf("name_%d", i), } - r, err := db.Table(table).Data(data).Insert() + r, err := db.Model(table).Data(data).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) } }) gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).FindOne(1) + one, err := db.Model(table).FindOne(1) t.AssertNil(err) t.AssertNE(one["create_at"].String(), "") t.AssertNE(one["update_at"].String(), "") t.Assert(one["delete_at"].String(), "") }) gtest.C(t, func(t *gtest.T) { - one, err := db.Table(table).FindOne(10) + one, err := db.Model(table).FindOne(10) t.AssertNil(err) t.AssertNE(one["create_at"].String(), "") t.AssertNE(one["update_at"].String(), "") @@ -510,16 +510,16 @@ CREATE TABLE %s ( }) gtest.C(t, func(t *gtest.T) { ids := g.SliceInt{1, 3, 5} - r, err := db.Table(table).Where("id", ids).Delete() + r, err := db.Model(table).Where("id", ids).Delete() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 3) - count, err := db.Table(table).FindCount(ids) + count, err := db.Model(table).FindCount(ids) t.AssertNil(err) t.Assert(count, 0) - all, err := db.Table(table).Unscoped().FindAll(ids) + all, err := db.Model(table).Unscoped().FindAll(ids) t.AssertNil(err) t.Assert(len(all), 3) t.AssertNE(all[0]["create_at"].String(), "") @@ -571,7 +571,7 @@ CREATE TABLE %s ( "id": 1, "name": "name_1", } - r, err := db.Table(table1).Data(dataInsert1).Insert() + r, err := db.Model(table1).Data(dataInsert1).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) @@ -580,26 +580,26 @@ CREATE TABLE %s ( "id": 1, "name": "name_2", } - r, err = db.Table(table2).Data(dataInsert2).Insert() + r, err = db.Model(table2).Data(dataInsert2).Insert() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - one, err := db.Table(table1, "t1").LeftJoin(table2, "t2", "t2.id=t1.id").Fields("t1.name").FindOne() + one, err := db.Model(table1, "t1").LeftJoin(table2, "t2", "t2.id=t1.id").Fields("t1.name").FindOne() t.AssertNil(err) t.Assert(one["name"], "name_1") // Soft deleting. - r, err = db.Table(table1).Delete() + r, err = db.Model(table1).Delete() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - one, err = db.Table(table1, "t1").LeftJoin(table2, "t2", "t2.id=t1.id").Fields("t1.name").FindOne() + one, err = db.Model(table1, "t1").LeftJoin(table2, "t2", "t2.id=t1.id").Fields("t1.name").FindOne() t.AssertNil(err) t.Assert(one.IsEmpty(), true) - one, err = db.Table(table2, "t2").LeftJoin(table1, "t1", "t2.id=t1.id").Fields("t2.name").FindOne() + one, err = db.Model(table2, "t2").LeftJoin(table1, "t1", "t2.id=t1.id").Fields("t2.name").FindOne() t.AssertNil(err) t.Assert(one.IsEmpty(), true) }) @@ -628,7 +628,7 @@ CREATE TABLE %s ( "id": i, "name": fmt.Sprintf("name_%d", i), } - r, err := db.Table(table).Data(data).Insert() + r, err := db.Model(table).Data(data).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) @@ -636,12 +636,12 @@ CREATE TABLE %s ( }) gtest.C(t, func(t *gtest.T) { ids := g.SliceInt{1, 3, 5} - r, err := db.Table(table).Where("id", ids).Delete() + r, err := db.Model(table).Where("id", ids).Delete() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 3) - count, err := db.Table(table).Where("id", 1).Or("id", 3).Count() + count, err := db.Model(table).Where("id", 1).Or("id", 3).Count() t.AssertNil(err) t.Assert(count, 0) }) @@ -679,12 +679,12 @@ CREATE TABLE %s ( UpdateAt: nil, DeleteAt: nil, } - r, err := db.Table(table).Data(dataInsert).Insert() + r, err := db.Model(table).Data(dataInsert).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - oneInsert, err := db.Table(table).FindOne(1) + oneInsert, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneInsert["id"].Int(), 1) t.Assert(oneInsert["name"].String(), "name_1") @@ -702,12 +702,12 @@ CREATE TABLE %s ( UpdateAt: nil, DeleteAt: nil, } - r, err = db.Table(table).Data(dataSave).Save() + r, err = db.Model(table).Data(dataSave).Save() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 2) - oneSave, err := db.Table(table).FindOne(1) + oneSave, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneSave["id"].Int(), 1) t.Assert(oneSave["name"].String(), "name_10") @@ -726,12 +726,12 @@ CREATE TABLE %s ( UpdateAt: nil, DeleteAt: nil, } - r, err = db.Table(table).Data(dataUpdate).WherePri(1).Update() + r, err = db.Model(table).Data(dataUpdate).WherePri(1).Update() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - oneUpdate, err := db.Table(table).FindOne(1) + oneUpdate, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneUpdate["id"].Int(), 1) t.Assert(oneUpdate["name"].String(), "name_1000") @@ -747,12 +747,12 @@ CREATE TABLE %s ( UpdateAt: nil, DeleteAt: nil, } - r, err = db.Table(table).Data(dataReplace).Replace() + r, err = db.Model(table).Data(dataReplace).Replace() t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 2) - oneReplace, err := db.Table(table).FindOne(1) + oneReplace, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(oneReplace["id"].Int(), 1) t.Assert(oneReplace["name"].String(), "name_100") @@ -763,35 +763,35 @@ CREATE TABLE %s ( time.Sleep(2 * time.Second) // Delete - r, err = db.Table(table).Delete("id", 1) + r, err = db.Model(table).Delete("id", 1) t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) // Delete Select - one4, err := db.Table(table).FindOne(1) + one4, err := db.Model(table).FindOne(1) t.AssertNil(err) t.Assert(len(one4), 0) - one5, err := db.Table(table).Unscoped().FindOne(1) + one5, err := db.Model(table).Unscoped().FindOne(1) t.AssertNil(err) t.Assert(one5["id"].Int(), 1) t.AssertGE(one5["delete_at"].GTime().Timestamp(), gtime.Timestamp()-2) // Delete Count - i, err := db.Table(table).FindCount() + i, err := db.Model(table).FindCount() t.AssertNil(err) t.Assert(i, 0) - i, err = db.Table(table).Unscoped().FindCount() + i, err = db.Model(table).Unscoped().FindCount() t.AssertNil(err) t.Assert(i, 1) // Delete Unscoped - r, err = db.Table(table).Unscoped().Delete("id", 1) + r, err = db.Model(table).Unscoped().Delete("id", 1) t.AssertNil(err) n, _ = r.RowsAffected() t.Assert(n, 1) - one6, err := db.Table(table).Unscoped().FindOne(1) + one6, err := db.Model(table).Unscoped().FindOne(1) t.AssertNil(err) t.Assert(len(one6), 0) - i, err = db.Table(table).Unscoped().FindCount() + i, err = db.Model(table).Unscoped().FindCount() t.AssertNil(err) t.Assert(i, 0) }) diff --git a/database/gdb/gdb_z_mysql_transaction_test.go b/database/gdb/gdb_z_mysql_transaction_test.go index 38ea6f4a3..96b3dd978 100644 --- a/database/gdb/gdb_z_mysql_transaction_test.go +++ b/database/gdb/gdb_z_mysql_transaction_test.go @@ -183,7 +183,7 @@ func Test_TX_BatchInsert(t *testing.T) { if err := tx.Commit(); err != nil { gtest.Error(err) } - if n, err := db.Table(table).Count(); err != nil { + if n, err := db.Model(table).Count(); err != nil { gtest.Error(err) } else { t.Assert(n, 2) @@ -221,12 +221,12 @@ func Test_TX_BatchReplace(t *testing.T) { if err := tx.Commit(); err != nil { gtest.Error(err) } - if n, err := db.Table(table).Count(); err != nil { + if n, err := db.Model(table).Count(); err != nil { gtest.Error(err) } else { - t.Assert(n, SIZE) + t.Assert(n, TableSize) } - if value, err := db.Table(table).Fields("password").Where("id", 2).Value(); err != nil { + if value, err := db.Model(table).Fields("password").Where("id", 2).Value(); err != nil { gtest.Error(err) } else { t.Assert(value.String(), "PASS_2") @@ -258,13 +258,13 @@ func Test_TX_BatchSave(t *testing.T) { gtest.Error(err) } - if n, err := db.Table(table).Count(); err != nil { + if n, err := db.Model(table).Count(); err != nil { gtest.Error(err) } else { - t.Assert(n, SIZE) + t.Assert(n, TableSize) } - if value, err := db.Table(table).Fields("password").Where("id", 4).Value(); err != nil { + if value, err := db.Model(table).Fields("password").Where("id", 4).Value(); err != nil { gtest.Error(err) } else { t.Assert(value.String(), "PASS_4") @@ -293,7 +293,7 @@ func Test_TX_Replace(t *testing.T) { if err := tx.Rollback(); err != nil { gtest.Error(err) } - if value, err := db.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil { + if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { gtest.Error(err) } else { t.Assert(value.String(), "name_1") @@ -322,7 +322,7 @@ func Test_TX_Save(t *testing.T) { if err := tx.Commit(); err != nil { gtest.Error(err) } - if value, err := db.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil { + if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { gtest.Error(err) } else { t.Assert(value.String(), "NAME_1") @@ -351,7 +351,7 @@ func Test_TX_Update(t *testing.T) { _, err = tx.Table(table).Fields("create_time").Where("id", 3).Value() t.AssertNE(err, nil) - if value, err := db.Table(table).Fields("create_time").Where("id", 3).Value(); err != nil { + if value, err := db.Model(table).Fields("create_time").Where("id", 3).Value(); err != nil { gtest.Error(err) } else { t.Assert(value.String(), "2019-10-24 10:00:00") @@ -435,7 +435,7 @@ func Test_TX_GetCount(t *testing.T) { if count, err := tx.GetCount("SELECT * FROM " + table); err != nil { gtest.Error(err) } else { - t.Assert(count, SIZE) + t.Assert(count, TableSize) } if err := tx.Commit(); err != nil { gtest.Error(err) @@ -513,7 +513,7 @@ func Test_TX_GetStructs(t *testing.T) { if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil { gtest.Error(err) } - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -542,7 +542,7 @@ func Test_TX_GetStructs(t *testing.T) { if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil { gtest.Error(err) } - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -621,7 +621,7 @@ func Test_TX_GetScan(t *testing.T) { if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil { gtest.Error(err) } - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -650,7 +650,7 @@ func Test_TX_GetScan(t *testing.T) { if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil { gtest.Error(err) } - t.Assert(len(users), SIZE) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) t.Assert(users[2].Id, 3) @@ -679,7 +679,7 @@ func Test_TX_Delete(t *testing.T) { if err := tx.Commit(); err != nil { gtest.Error(err) } - if n, err := db.Table(table).Count(); err != nil { + if n, err := db.Model(table).Count(); err != nil { gtest.Error(err) } else { t.Assert(n, 0) @@ -704,10 +704,10 @@ func Test_TX_Delete(t *testing.T) { if err := tx.Rollback(); err != nil { gtest.Error(err) } - if n, err := db.Table(table).Count(); err != nil { + if n, err := db.Model(table).Count(); err != nil { gtest.Error(err) } else { - t.Assert(n, SIZE) + t.Assert(n, TableSize) t.AssertNE(n, 0) } }) @@ -732,7 +732,7 @@ func Test_Transaction(t *testing.T) { }) t.AssertNE(err, nil) - if value, err := db.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil { + if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { gtest.Error(err) } else { t.Assert(value.String(), "name_1") @@ -754,7 +754,7 @@ func Test_Transaction(t *testing.T) { }) t.AssertNil(err) - if value, err := db.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil { + if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { gtest.Error(err) } else { t.Assert(value.String(), "NAME_1") @@ -782,7 +782,7 @@ func Test_Transaction_Panic(t *testing.T) { }) t.AssertNE(err, nil) - if value, err := db.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil { + if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { gtest.Error(err) } else { t.Assert(value.String(), "name_1") diff --git a/database/gdb/gdb_z_mysql_types_test.go b/database/gdb/gdb_z_mysql_types_test.go index bf0b1efb4..e26d763b9 100644 --- a/database/gdb/gdb_z_mysql_types_test.go +++ b/database/gdb/gdb_z_mysql_types_test.go @@ -58,12 +58,12 @@ func Test_Types(t *testing.T) { "tinyint": true, "bool": false, } - r, err := db.Table("types").Data(data).Insert() + r, err := db.Model("types").Data(data).Insert() t.AssertNil(err) n, _ := r.RowsAffected() t.Assert(n, 1) - one, err := db.Table("types").One() + one, err := db.Model("types").One() t.AssertNil(err) t.Assert(one["id"].Int(), 1) t.Assert(one["blob"].String(), data["blob"]) @@ -87,7 +87,7 @@ func Test_Types(t *testing.T) { TinyInt bool } var obj *T - err = db.Table("types").Struct(&obj) + err = db.Model("types").Struct(&obj) t.AssertNil(err) t.Assert(obj.Id, 1) t.Assert(obj.Blob, data["blob"])