mirror of
https://github.com/tobycroft/gorose-pro.git
synced 2025-09-26 12:41:16 +08:00
359 lines
7.2 KiB
Go
359 lines
7.2 KiB
Go
package gorose
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestOrm_BuildSql2(t *testing.T) {
|
|
db := DB()
|
|
var u = "age=age+1,num=num+1"
|
|
var wheres interface{}
|
|
wheres = [][]interface{}{{"a", ">", "b"}, {"a", "b"}, {"a is null"}}
|
|
sqlstr, a, b := db.Force().Table("users").Data(u).Where(wheres).BuildSql("update")
|
|
|
|
t.Log(sqlstr, a, b)
|
|
}
|
|
|
|
func TestOrm_BuildSql3(t *testing.T) {
|
|
db := DB()
|
|
var u = "age=age+1,num=num+1"
|
|
var wheres interface{}
|
|
wheres = [][]interface{}{{"a", ">", "b"}, {"a", "b"}}
|
|
sqlstr, a, b := db.Force().Table(Users{}).Data(u).Where(wheres).BuildSql("update")
|
|
|
|
t.Log(sqlstr, a, b)
|
|
}
|
|
|
|
func TestOrm_BuildSql4(t *testing.T) {
|
|
db := DB()
|
|
//var wheres interface{}
|
|
//wheres = [][]interface{}{{"a", ">", "b"},{"lock",1}}
|
|
wheres := Data{"lock": 1, "`date`": 1}
|
|
obj := db.Table(Users{}).Where(wheres).Where(func() {
|
|
db.Where("c", 2).OrWhere("lock", ">", 4)
|
|
}).Data(wheres)
|
|
|
|
sqlstr, a, b := obj.BuildSql()
|
|
t.Log(sqlstr, a, b)
|
|
|
|
sqlstr, a, b = obj.BuildSql("update")
|
|
t.Log(sqlstr, a, b)
|
|
|
|
sqlstr, a, b = obj.BuildSql("insert")
|
|
t.Log(sqlstr, a, b)
|
|
}
|
|
|
|
func TestOrm_BuildSql5(t *testing.T) {
|
|
//ticker := time.NewTicker(100*time.Millisecond)
|
|
go func(t *testing.T) {
|
|
for {
|
|
//<-ticker.C
|
|
db := DB()
|
|
sqlstr, a, b := db.Table("users").Where("uid", ">", 1).BuildSql()
|
|
//c,d := db.Table("users").Get()
|
|
//t.Log(db.LastSql())
|
|
count, d := db.First()
|
|
|
|
t.Log(sqlstr, a, b)
|
|
t.Log(count, d)
|
|
t.Log(db.LastSql())
|
|
}
|
|
}(t)
|
|
time.Sleep(500 * time.Millisecond)
|
|
}
|
|
|
|
func TestOrm_BuildSql6(t *testing.T) {
|
|
var db = DB()
|
|
sqlstr, a, b := db.Table("users3").Limit(2).Offset(2).BuildSql()
|
|
t.Log(sqlstr, a, b)
|
|
|
|
sqlstr, a, b = db.Table("users2").Limit(2).Offset(2).BuildSql()
|
|
t.Log(sqlstr, a, b)
|
|
|
|
var u = Users{
|
|
Uid: 1111,
|
|
Name: "2",
|
|
Age: 3,
|
|
}
|
|
res, err := db.Table("xxx").Where("xx", "xx").Update(&u)
|
|
t.Log(db.LastSql(), res, err)
|
|
}
|
|
|
|
func TestOrm_First(t *testing.T) {
|
|
res, err := DB().Table(Users{}).Where("uid", 1).First()
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(res)
|
|
}
|
|
|
|
func TestOrm_Select(t *testing.T) {
|
|
db := DB()
|
|
var err error
|
|
|
|
var u = []Users{}
|
|
err = db.Table(&u).Select()
|
|
t.Log(err, u, db.LastSql())
|
|
|
|
var u2 = Users{}
|
|
err = db.Table(&u2).Select()
|
|
t.Log(err, u2, db.LastSql())
|
|
|
|
var u3 Users
|
|
err = db.Table(&u3).Select()
|
|
t.Log(err, u3, db.LastSql())
|
|
|
|
var u4 []Users
|
|
err = db.Table(&u4).Limit(2).Select()
|
|
t.Log(err, u4, db.LastSql())
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(u, u2, u3, u4)
|
|
}
|
|
|
|
func TestOrm_Select2(t *testing.T) {
|
|
db := DB()
|
|
var err error
|
|
|
|
var u = []UsersMap{}
|
|
err = db.Table(&u).Limit(2).Select()
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(u)
|
|
|
|
var u3 = UsersMap{}
|
|
err = db.Table(&u3).Limit(1).Select()
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(u)
|
|
}
|
|
|
|
type Users2 struct {
|
|
Name string `orm:"name"`
|
|
Age int `orm:"age"`
|
|
Uid int `orm:"uid"`
|
|
Fi string `orm:"ignore"`
|
|
}
|
|
|
|
func (u *Users2) TableName() string {
|
|
return "users"
|
|
}
|
|
func TestOrm_Get2(t *testing.T) {
|
|
db := DB()
|
|
var err error
|
|
var u []Users2
|
|
|
|
res, err := db.Table("users").Where("uid", ">", 2).
|
|
//Where("1","=","1").
|
|
Where("1 = 1").
|
|
Limit(2).Get()
|
|
//res, err := db.Table(&u).Where("uid", ">", 0).Limit(2).Get()
|
|
fmt.Println(db.LastSql())
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(res, u)
|
|
}
|
|
|
|
func TestOrm_Get(t *testing.T) {
|
|
orm := DB()
|
|
|
|
var u = UsersMap{}
|
|
ormObj := orm.Table(&u).Join("b", "a.id", "=", "b.id").
|
|
RightJoin("userinfo d on a.id=d.id").
|
|
Fields("a.uid,a.age").
|
|
Order("uid desc").
|
|
Where("a", 1).
|
|
WhereNull("bb").
|
|
WhereNotNull("cc").
|
|
WhereIn("dd", []interface{}{1, 2}).
|
|
OrWhereNotIn("ee", []interface{}{1, 2}).
|
|
WhereBetween("ff", []interface{}{11, 21}).
|
|
WhereNotBetween("ff", []interface{}{1, 2}).
|
|
Where("a", "like", "%3%").
|
|
OrWhere(func() {
|
|
orm.Where("c", 3).OrWhere(func() {
|
|
orm.Where("d", ">", 4)
|
|
})
|
|
}).Where("e", 5).Limit(5).Offset(2)
|
|
s, a, err := ormObj.BuildSql()
|
|
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(s, a, u)
|
|
}
|
|
|
|
func TestOrm_Pluck(t *testing.T) {
|
|
orm := DB()
|
|
|
|
//var u = UsersMapSlice{}
|
|
//var u []Users
|
|
ormObj := orm.Table("users")
|
|
//res,err := ormObj.Pluck("name", "uid")
|
|
res, err := ormObj.Limit(5).Pluck("name", "uid")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(res, orm.LastSql())
|
|
}
|
|
|
|
func TestOrm_Value(t *testing.T) {
|
|
db := DB()
|
|
|
|
//var u = UsersMap{}
|
|
//var u = UsersMapSlice{}
|
|
//var u Users
|
|
//var u []Users
|
|
//ormObj := db.Table(&u)
|
|
//ormObj := db.Table("users")
|
|
ormObj := db.Table(Users{})
|
|
res, err := ormObj.Limit(5).Value("uid")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(res, db.LastSql())
|
|
}
|
|
|
|
func TestOrm_Count(t *testing.T) {
|
|
db := DB()
|
|
|
|
//var u = UsersMap{}
|
|
//ormObj := db.Table(&u)
|
|
ormObj := db.Table("users")
|
|
|
|
res, err := ormObj.Count()
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(res, db.LastSql())
|
|
}
|
|
|
|
func TestOrm_Count2(t *testing.T) {
|
|
var u Users
|
|
var count int64
|
|
count, err := DB().Table(&u).Count()
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(count)
|
|
}
|
|
|
|
func TestOrm_Chunk(t *testing.T) {
|
|
orm := DB()
|
|
|
|
var u = []UsersMap{}
|
|
err := orm.Table(&u).Chunk(1, func(data []Data) error {
|
|
for _, item := range data {
|
|
t.Log(item["name"])
|
|
}
|
|
return errors.New("故意停止,防止数据过多,浪费时间")
|
|
//return nil
|
|
})
|
|
if err != nil && err.Error() != "故意停止,防止数据过多,浪费时间" {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log("Chunk() success")
|
|
}
|
|
|
|
func TestOrm_Chunk2(t *testing.T) {
|
|
orm := DB()
|
|
|
|
var u []Users
|
|
var i int
|
|
err := orm.Table(&u).ChunkStruct(2, func() error {
|
|
//for _, item := range u {
|
|
t.Log(u)
|
|
//}
|
|
if i == 2 {
|
|
return errors.New("故意停止,防止数据过多,浪费时间")
|
|
}
|
|
i++
|
|
return nil
|
|
})
|
|
if err != nil && err.Error() != "故意停止,防止数据过多,浪费时间" {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log("ChunkStruct() success")
|
|
}
|
|
|
|
func TestOrm_Loop(t *testing.T) {
|
|
db := DB()
|
|
|
|
var u = []UsersMap{}
|
|
//aff,err := db.Table(&u).Force().Data(Data{"age": 18}).Update()
|
|
//fmt.Println(aff,err)
|
|
err := db.Table(&u).Where("age", 18).Loop(2, func(data []Data) error {
|
|
for _, item := range data {
|
|
_, err := DB().Table(&u).Data(Data{"age": 19}).Where("uid", item["uid"]).Update()
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
}
|
|
return errors.New("故意停止,防止数据过多,浪费时间")
|
|
//return nil
|
|
})
|
|
if err != nil && err.Error() != "故意停止,防止数据过多,浪费时间" {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log("Loop() success")
|
|
}
|
|
|
|
func TestOrm_Paginate(t *testing.T) {
|
|
db := DB()
|
|
|
|
var u []Users
|
|
res, err := db.Table(&u).Limit(2).Paginate()
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(res, u)
|
|
t.Log(db.LastSql())
|
|
}
|
|
|
|
func TestOrm_Paginate2(t *testing.T) {
|
|
db := DB()
|
|
|
|
var u []Users
|
|
res, err := db.Table(&u).Where("uid", ">", 1).Limit(2).Paginate(3)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
t.Log(res, u)
|
|
t.Log(db.LastSql())
|
|
}
|
|
|
|
func TestOrm_Sum(t *testing.T) {
|
|
db := DB()
|
|
|
|
var u Users
|
|
//res, err := db.Table(Users{}).First()
|
|
res, err := db.Table(&u).Where(Data{"uid": 1}).Sum("age")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
//fmt.Printf("%#v\n",res)
|
|
t.Log(res, u)
|
|
t.Log(db.LastSql())
|
|
}
|
|
|
|
func BenchmarkNewOrm(b *testing.B) {
|
|
engin := initDB()
|
|
for i := 0; i < b.N; i++ {
|
|
engin.NewOrm().Table("users").First()
|
|
}
|
|
}
|
|
|
|
func BenchmarkNewOrm2(b *testing.B) {
|
|
engin := initDB()
|
|
for i := 0; i < b.N; i++ {
|
|
engin.NewOrm().Table("users").First()
|
|
}
|
|
}
|