package/aorm
1
0
Fork 0
mirror of https://github.com/tangpanqing/aorm.git synced 2025-10-16 12:51:23 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
tangpanqing
2023-01-11 23:33:20 +08:00
parent b8f0296b95
commit 75cba1fa48
12 changed files with 438 additions and 480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

470
test/aorm_test.go
View File

@@ -1,7 +1,6 @@
package test
import (
"database/sql"
"fmt"
_ "github.com/denisenkom/go-mssqldb"
_ "github.com/go-sql-driver/mysql"
@@ -96,134 +95,136 @@ func TestAll(t *testing.T) {
aorm.Store(&articleVO)
aorm.Store(&personAge, &personWithArticleCount)
//var dbList = []*aorm.DbContent{
// testMysqlConnect(),
// testSqlite3Connect(),
// testPostgresConnect(),
// testMssqlConnect(),
//}
//
//for i := 0; i < len(dbList); i++ {
// dbItem := dbList[i]
//
// testMigrate(dbItem.DriverName, dbItem.DbLink)
//
// testShowCreateTable(dbItem.DriverName, dbItem.DbLink)
//
// id := testInsert(dbItem.DriverName, dbItem.DbLink)
// testInsertBatch(dbItem.DriverName, dbItem.DbLink)
// testGetOne(dbItem.DriverName, dbItem.DbLink, id)
// testGetMany(dbItem.DriverName, dbItem.DbLink)
// testUpdate(dbItem.DriverName, dbItem.DbLink, id)
//
// isExists := testExists(dbItem.DriverName, dbItem.DbLink, id)
// if isExists != true {
// panic("应该存在，但是数据库不存在")
// }
//
// testDelete(dbItem.DriverName, dbItem.DbLink, id)
// isExists2 := testExists(dbItem.DriverName, dbItem.DbLink, id)
// if isExists2 == true {
// panic("应该不存在，但是数据库存在")
// }
//
// id2 := testInsert(dbItem.DriverName, dbItem.DbLink)
// testTable(dbItem.DriverName, dbItem.DbLink)
// testSelect(dbItem.DriverName, dbItem.DbLink)
// testSelectWithSub(dbItem.DriverName, dbItem.DbLink)
// testWhereWithSub(dbItem.DriverName, dbItem.DbLink)
// testWhere(dbItem.DriverName, dbItem.DbLink)
// testJoin(dbItem.DriverName, dbItem.DbLink)
// testJoinWithAlias(dbItem.DriverName, dbItem.DbLink)
//
// testGroupBy(dbItem.DriverName, dbItem.DbLink)
// testHaving(dbItem.DriverName, dbItem.DbLink)
// testOrderBy(dbItem.DriverName, dbItem.DbLink)
// testLimit(dbItem.DriverName, dbItem.DbLink)
// testLock(dbItem.DriverName, dbItem.DbLink, id2)
//
// testIncrement(dbItem.DriverName, dbItem.DbLink, id2)
// testDecrement(dbItem.DriverName, dbItem.DbLink, id2)
//
// testValue(dbItem.DriverName, dbItem.DbLink, id2)
// testPluck(dbItem.DriverName, dbItem.DbLink)
//
// testCount(dbItem.DriverName, dbItem.DbLink)
// testSum(dbItem.DriverName, dbItem.DbLink)
// testAvg(dbItem.DriverName, dbItem.DbLink)
// testMin(dbItem.DriverName, dbItem.DbLink)
// testMax(dbItem.DriverName, dbItem.DbLink)
//
// testDistinct(dbItem.DriverName, dbItem.DbLink)
//
// testRawSql(dbItem.DriverName, dbItem.DbLink, id2)
//
// testTransaction(dbItem.DriverName, dbItem.DbLink)
// testTruncate(dbItem.DriverName, dbItem.DbLink)
//}
//
//testPreview()
var dbList = []*model.AormDB{
testMysqlConnect(),
testSqlite3Connect(),
testPostgresConnect(),
testMssqlConnect(),
}
for i := 0; i < len(dbList); i++ {
dbItem := dbList[i]
testMigrate(dbItem)
testShowCreateTable(dbItem)
id := testInsert(dbItem)
testInsertBatch(dbItem)
testGetOne(dbItem, id)
testGetMany(dbItem)
testUpdate(dbItem, id)
isExists := testExists(dbItem, id)
if isExists != true {
panic("应该存在，但是数据库不存在")
}
testDelete(dbItem, id)
isExists2 := testExists(dbItem, id)
if isExists2 == true {
panic("应该不存在，但是数据库存在")
}
id2 := testInsert(dbItem)
testTable(dbItem)
testSelect(dbItem)
testSelectWithSub(dbItem)
testWhereWithSub(dbItem)
testWhere(dbItem)
testJoin(dbItem)
testJoinWithAlias(dbItem)
testGroupBy(dbItem)
testHaving(dbItem)
testOrderBy(dbItem)
testLimit(dbItem)
testLock(dbItem, id2)
testIncrement(dbItem, id2)
testDecrement(dbItem, id2)
testValue(dbItem, id2)
testPluck(dbItem)
testCount(dbItem)
testSum(dbItem)
testAvg(dbItem)
testMin(dbItem)
testMax(dbItem)
testDistinct(dbItem)
testRawSql(dbItem, id2)
testTransaction(dbItem)
testTruncate(dbItem)
}
testPreview()
testDbContent()
}
func testSqlite3Connect() *aorm.DbContent {
sqlite3Content, sqlite3Err := aorm.Open("sqlite3", "test.db")
func testSqlite3Connect() *model.AormDB {
sqlite3Content, sqlite3Err := aorm.Open(model.Sqlite3, "test.db")
if sqlite3Err != nil {
panic(sqlite3Err)
}
sqlite3Content.SetDebugMode(false)
return sqlite3Content
}
func testMysqlConnect() *aorm.DbContent {
func testMysqlConnect() *model.AormDB {
username := "root"
password := "root"
hostname := "localhost"
port := "3306"
dbname := "database_name"
mysqlContent, mysqlErr := aorm.Open("mysql", username+":"+password+"@tcp("+hostname+":"+port+")/"+dbname+"?charset=utf8mb4&parseTime=True&loc=Local")
mysqlContent, mysqlErr := aorm.Open(model.Mysql, username+":"+password+"@tcp("+hostname+":"+port+")/"+dbname+"?charset=utf8mb4&parseTime=True&loc=Local")
if mysqlErr != nil {
panic(mysqlErr)
}
mysqlContent.SetDebugMode(false)
return mysqlContent
}
func testPostgresConnect() *aorm.DbContent {
func testPostgresConnect() *model.AormDB {
psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", "localhost", 5432, "postgres", "root", "postgres")
postgresContent, postgresErr := aorm.Open("postgres", psqlInfo)
postgresContent, postgresErr := aorm.Open(model.Postgres, psqlInfo)
if postgresErr != nil {
panic(postgresErr)
}
postgresContent.SetDebugMode(false)
return postgresContent
}
func testMssqlConnect() *aorm.DbContent {
func testMssqlConnect() *model.AormDB {
mssqlInfo := fmt.Sprintf("server=%s;database=%s;user id=%s;password=%s;port=%d;encrypt=disable", "localhost", "database_name", "sa", "root", 1433)
mssqlContent, mssqlErr := aorm.Open("mssql", mssqlInfo)
mssqlContent, mssqlErr := aorm.Open(model.Mssql, mssqlInfo)
if mssqlErr != nil {
panic(mssqlErr)
}
mssqlContent.SetDebugMode(false)
return mssqlContent
}
func testMigrate(driver string, db *sql.DB) {
aorm.Migrator(db).Driver(driver).AutoMigrate(&person, &article, &student)
func testMigrate(db *model.AormDB) {
aorm.Migrator(db).AutoMigrate(&person, &article, &student)
aorm.Migrator(db).Driver(driver).Migrate("person_1", &person)
aorm.Migrator(db).Migrate("person_1", &person)
}
func testShowCreateTable(driver string, db *sql.DB) {
aorm.Migrator(db).Driver(driver).ShowCreateTable("person")
func testShowCreateTable(db *model.AormDB) {
aorm.Migrator(db).ShowCreateTable("person")
}
func testInsert(driver string, db *sql.DB) int64 {
func testInsert(db *model.AormDB) int64 {
obj := Person{
Name: null.StringFrom("Alice"),
Sex: null.BoolFrom(true),
@@ -234,55 +235,55 @@ func testInsert(driver string, db *sql.DB) int64 {
Test: null.FloatFrom(2),
}
id, errInsert := aorm.Db(db).Debug(false).Driver(driver).Insert(&obj)
id, errInsert := aorm.Db(db).Insert(&obj)
if errInsert != nil {
panic(driver + " testInsert " + "found err: " + errInsert.Error())
panic(db.DriverName() + " testInsert " + "found err: " + errInsert.Error())
}
aorm.Db(db).Debug(false).Driver(driver).Insert(&Article{
aorm.Db(db).Insert(&Article{
Type: null.IntFrom(0),
PersonId: null.IntFrom(id),
ArticleBody: null.StringFrom("文章内容"),
})
var personItem Person
err := aorm.Db(db).Table(&person).Debug(false).Driver(driver).WhereEq(&person.Id, id).OrderBy(&person.Id, builder.Desc).GetOne(&personItem)
err := aorm.Db(db).Table(&person).WhereEq(&person.Id, id).OrderBy(&person.Id, builder.Desc).GetOne(&personItem)
if err != nil {
fmt.Println(err.Error())
}
if obj.Name.String != personItem.Name.String {
fmt.Println(driver + ",Name not match, expected: " + obj.Name.String + " ,but real is : " + personItem.Name.String)
fmt.Println(db.DriverName() + ",Name not match, expected: " + obj.Name.String + " ,but real is : " + personItem.Name.String)
}
if obj.Sex.Bool != personItem.Sex.Bool {
fmt.Println(driver + ",Sex not match, expected: " + fmt.Sprintf("%v", obj.Sex.Bool) + " ,but real is : " + fmt.Sprintf("%v", personItem.Sex.Bool))
fmt.Println(db.DriverName() + ",Sex not match, expected: " + fmt.Sprintf("%v", obj.Sex.Bool) + " ,but real is : " + fmt.Sprintf("%v", personItem.Sex.Bool))
}
if obj.Age.Int64 != personItem.Age.Int64 {
fmt.Println(driver + ",Age not match, expected: " + fmt.Sprintf("%v", obj.Age.Int64) + " ,but real is : " + fmt.Sprintf("%v", personItem.Age.Int64))
fmt.Println(db.DriverName() + ",Age not match, expected: " + fmt.Sprintf("%v", obj.Age.Int64) + " ,but real is : " + fmt.Sprintf("%v", personItem.Age.Int64))
}
if obj.Type.Int64 != personItem.Type.Int64 {
fmt.Println(driver + ",Type not match, expected: " + fmt.Sprintf("%v", obj.Type.Int64) + " ,but real is : " + fmt.Sprintf("%v", personItem.Type.Int64))
fmt.Println(db.DriverName() + ",Type not match, expected: " + fmt.Sprintf("%v", obj.Type.Int64) + " ,but real is : " + fmt.Sprintf("%v", personItem.Type.Int64))
}
if obj.Money.Float64 != personItem.Money.Float64 {
fmt.Println(driver + ",Money not match, expected: " + fmt.Sprintf("%v", obj.Money.Float64) + " ,but real is : " + fmt.Sprintf("%v", personItem.Money.Float64))
fmt.Println(db.DriverName() + ",Money not match, expected: " + fmt.Sprintf("%v", obj.Money.Float64) + " ,but real is : " + fmt.Sprintf("%v", personItem.Money.Float64))
}
if obj.Test.Float64 != personItem.Test.Float64 {
fmt.Println(driver + ",Test not match, expected: " + fmt.Sprintf("%v", obj.Test.Float64) + " ,but real is : " + fmt.Sprintf("%v", personItem.Test.Float64))
fmt.Println(db.DriverName() + ",Test not match, expected: " + fmt.Sprintf("%v", obj.Test.Float64) + " ,but real is : " + fmt.Sprintf("%v", personItem.Test.Float64))
}
//测试非id主键
aorm.Db(db).Debug(false).Driver(driver).Insert(&Student{
aorm.Db(db).Insert(&Student{
Name: null.StringFrom("new student"),
})
return id
}
func testInsertBatch(driver string, db *sql.DB) int64 {
func testInsertBatch(db *model.AormDB) int64 {
var batch []*Person
batch = append(batch, &Person{
Name: null.StringFrom("Alice"),
@@ -304,85 +305,84 @@ func testInsertBatch(driver string, db *sql.DB) int64 {
Test: null.FloatFrom(200.15987654321987654321),
})
count, err := aorm.Db(db).Debug(false).Driver(driver).InsertBatch(&batch)
count, err := aorm.Db(db).InsertBatch(&batch)
if err != nil {
panic(driver + " testInsertBatch " + "found err:" + err.Error())
panic(db.DriverName() + " testInsertBatch " + "found err:" + err.Error())
}
return count
}
func testGetOne(driver string, db *sql.DB, id int64) {
func testGetOne(db *model.AormDB, id int64) {
var personItem Person
errFind := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).GetOne(&personItem)
errFind := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).GetOne(&personItem)
if errFind != nil {
panic(driver + "testGetOne" + "found err")
panic(db.DriverName() + "testGetOne" + "found err")
}
}
func testGetMany(driver string, db *sql.DB) {
func testGetMany(db *model.AormDB) {
var list []Person
errSelect := aorm.Db(db).Driver(driver).Debug(false).Table(&person).WhereEq(&person.Type, 0).GetMany(&list)
errSelect := aorm.Db(db).Table(&person).WhereEq(&person.Type, 0).GetMany(&list)
if errSelect != nil {
panic(driver + " testGetMany " + "found err:" + errSelect.Error())
panic(db.DriverName() + " testGetMany " + "found err:" + errSelect.Error())
}
}
func testUpdate(driver string, db *sql.DB, id int64) {
_, errUpdate := aorm.Db(db).Debug(false).Driver(driver).WhereEq(&person.Id, id).Update(&Person{Name: null.StringFrom("Bob")})
func testUpdate(db *model.AormDB, id int64) {
_, errUpdate := aorm.Db(db).WhereEq(&person.Id, id).Update(&Person{Name: null.StringFrom("Bob")})
if errUpdate != nil {
panic(driver + "testUpdate" + "found err")
panic(db.DriverName() + "testUpdate" + "found err")
}
}
func testDelete(driver string, db *sql.DB, id int64) {
_, errDelete := aorm.Db(db).Driver(driver).Debug(false).Table(&person).WhereEq(&person.Id, id).Delete()
func testDelete(db *model.AormDB, id int64) {
_, errDelete := aorm.Db(db).Table(&person).WhereEq(&person.Id, id).Delete()
if errDelete != nil {
panic(driver + "testDelete" + "found err")
panic(db.DriverName() + "testDelete" + "found err")
}
_, errDelete2 := aorm.Db(db).Driver(driver).Debug(false).Delete(&Person{
_, errDelete2 := aorm.Db(db).Delete(&Person{
Id: null.IntFrom(id),
})
if errDelete2 != nil {
panic(driver + "testDelete" + "found err")
panic(db.DriverName() + "testDelete" + "found err")
}
}
func testExists(driver string, db *sql.DB, id int64) bool {
exists, err := aorm.Db(db).Driver(driver).Debug(false).Table(&person).WhereEq(&person.Id, id).OrderBy(&person.Id, builder.Desc).Exists()
func testExists(db *model.AormDB, id int64) bool {
exists, err := aorm.Db(db).Table(&person).WhereEq(&person.Id, id).OrderBy(&person.Id, builder.Desc).Exists()
if err != nil {
panic(driver + " testExists " + "found err:" + err.Error())
panic(db.DriverName() + " testExists " + "found err:" + err.Error())
}
return exists
}
func testTable(driver string, db *sql.DB) {
_, err := aorm.Db(db).Debug(false).Driver(driver).Table("person_1").Insert(&Person{Name: null.StringFrom("Cherry")})
func testTable(db *model.AormDB) {
_, err := aorm.Db(db).Table("person_1").Insert(&Person{Name: null.StringFrom("Cherry")})
if err != nil {
panic(driver + " testTable " + "found err:" + err.Error())
panic(db.DriverName() + " testTable " + "found err:" + err.Error())
}
_, err2 := aorm.Db(db).Debug(false).Driver(driver).Table(&person).Insert(&Person{Name: null.StringFrom("Cherry")})
_, err2 := aorm.Db(db).Table(&person).Insert(&Person{Name: null.StringFrom("Cherry")})
if err2 != nil {
panic(driver + " testTable " + "found err:" + err2.Error())
panic(db.DriverName() + " testTable " + "found err:" + err2.Error())
}
}
func testSelect(driver string, db *sql.DB) {
func testSelect(db *model.AormDB) {
var listByFiled []Person
err := aorm.Db(db).Debug(false).Driver(driver).Table(&person).Select(&person.Name).Select(&person.Age).WhereEq(&person.Age, 18).GetMany(&listByFiled)
err := aorm.Db(db).Table(&person).Select(&person.Name).Select(&person.Age).WhereEq(&person.Age, 18).GetMany(&listByFiled)
if err != nil {
panic(driver + " testSelect " + "found err:" + err.Error())
panic(db.DriverName() + " testSelect " + "found err:" + err.Error())
}
}
func testSelectWithSub(driver string, db *sql.DB) {
func testSelectWithSub(db *model.AormDB) {
var listByFiled []PersonWithArticleCount
sub := aorm.Db().Table(&article).SelectCount(&article.Id, "article_count_tem").WhereRawEq(&article.PersonId, &person.Id)
err := aorm.Db(db).Debug(false).
Driver(driver).
sub := aorm.Db(db).Table(&article).SelectCount(&article.Id, "article_count_tem").WhereRawEq(&article.PersonId, &person.Id)
err := aorm.Db(db).
SelectExp(&sub, &personWithArticleCount.ArticleCount).
SelectAll(&person).
Table(&person).
@@ -390,26 +390,25 @@ func testSelectWithSub(driver string, db *sql.DB) {
GetMany(&listByFiled)
if err != nil {
panic(driver + " testSelectWithSub " + "found err:" + err.Error())
panic(db.DriverName() + " testSelectWithSub " + "found err:" + err.Error())
}
}
func testWhereWithSub(driver string, db *sql.DB) {
func testWhereWithSub(db *model.AormDB) {
var listByFiled []Person
sub := aorm.Db().Table(&article).Driver(driver).SelectCount(&article.PersonId, "count_person_id").GroupBy(&article.PersonId).HavingGt("count_person_id", 0)
err := aorm.Db(db).Debug(false).
sub := aorm.Db(db).Table(&article).SelectCount(&article.PersonId, "count_person_id").GroupBy(&article.PersonId).HavingGt("count_person_id", 0)
err := aorm.Db(db).
Table(&person).
Driver(driver).
WhereIn(&person.Id, &sub).
GetMany(&listByFiled)
if err != nil {
panic(driver + " testWhereWithSub " + "found err:" + err.Error())
panic(db.DriverName() + " testWhereWithSub " + "found err:" + err.Error())
}
}
func testWhere(driver string, db *sql.DB) {
func testWhere(db *model.AormDB) {
var listByWhere []Person
err := aorm.Db(db).Debug(false).Driver(driver).Table(&person).WhereArr([]builder.WhereItem{
err := aorm.Db(db).Table(&person).WhereArr([]builder.WhereItem{
builder.GenWhereItem(&person.Type, builder.Eq, 0),
builder.GenWhereItem(&person.Age, builder.In, []int{18, 20}),
builder.GenWhereItem(&person.Money, builder.Between, []float64{100.1, 200.9}),
@@ -417,13 +416,13 @@ func testWhere(driver string, db *sql.DB) {
builder.GenWhereItem(&person.Name, builder.Like, []string{"%", "li", "%"}),
}).GetMany(&listByWhere)
if err != nil {
panic(driver + "testWhere" + "found err")
panic(db.DriverName() + "testWhere" + "found err")
}
}
func testJoin(driver string, db *sql.DB) {
func testJoin(db *model.AormDB) {
var list2 []ArticleVO
err := aorm.Db(db).Debug(false).Driver(driver).
err := aorm.Db(db).
Table(&article).
LeftJoin(
&person,
@@ -437,13 +436,13 @@ func testJoin(driver string, db *sql.DB) {
WhereIn(&person.Age, []int{18, 20}).
GetMany(&list2)
if err != nil {
panic(driver + " testWhere " + "found err " + err.Error())
panic(db.DriverName() + " testWhere " + "found err " + err.Error())
}
}
func testJoinWithAlias(driver string, db *sql.DB) {
func testJoinWithAlias(db *model.AormDB) {
var list2 []ArticleVO
err := aorm.Db(db).Debug(false).Driver(driver).
err := aorm.Db(db).
Table(&article, "o").
LeftJoin(
&person,
@@ -458,30 +457,29 @@ func testJoinWithAlias(driver string, db *sql.DB) {
WhereIn(&person.Age, []int{18, 20}, "p").
GetMany(&list2)
if err != nil {
panic(driver + " testWhere " + "found err " + err.Error())
panic(db.DriverName() + " testWhere " + "found err " + err.Error())
}
}
func testGroupBy(driver string, db *sql.DB) {
func testGroupBy(db *model.AormDB) {
var personAgeItem PersonAge
err := aorm.Db(db).Debug(false).
err := aorm.Db(db).
Table(&person).
Select(&person.Age).
SelectCount(&person.Age, &personAge.AgeCount).
GroupBy(&person.Age).
WhereEq(&person.Type, 0).
Driver(driver).
OrderBy(&person.Age, builder.Desc).
GetOne(&personAgeItem)
if err != nil {
panic(driver + "testGroupBy" + "found err")
panic(db.DriverName() + "testGroupBy" + "found err")
}
}
func testHaving(driver string, db *sql.DB) {
func testHaving(db *model.AormDB) {
var listByHaving []PersonAge
err := aorm.Db(db).Debug(false).Driver(driver).
err := aorm.Db(db).
Table(&person).
Select(&person.Age).
SelectCount(&person.Age, &personAge.AgeCount).
@@ -491,229 +489,225 @@ func testHaving(driver string, db *sql.DB) {
HavingGt(&personAge.AgeCount, 4).
GetMany(&listByHaving)
if err != nil {
panic(driver + " testHaving " + "found err")
panic(db.DriverName() + " testHaving " + "found err")
}
}
func testOrderBy(driver string, db *sql.DB) {
func testOrderBy(db *model.AormDB) {
var listByOrder []Person
err := aorm.Db(db).Debug(false).Driver(driver).
err := aorm.Db(db).
Table(&person).
WhereEq(&person.Type, 0).
OrderBy(&person.Age, builder.Desc).
GetMany(&listByOrder)
if err != nil {
panic(driver + "testOrderBy" + "found err")
panic(db.DriverName() + "testOrderBy" + "found err")
}
var listByOrder2 []Person
err2 := aorm.Db(db).Debug(false).Driver(driver).
err2 := aorm.Db(db).
Table(&person, "o").
WhereEq(&person.Type, 0, "o").
OrderBy(&person.Age, builder.Desc, "o").
GetMany(&listByOrder2)
if err2 != nil {
panic(driver + "testOrderBy" + "found err")
panic(db.DriverName() + "testOrderBy" + "found err")
}
}
func testLimit(driver string, db *sql.DB) {
func testLimit(db *model.AormDB) {
var list3 []Person
err1 := aorm.Db(db).Debug(false).
err1 := aorm.Db(db).
Table(&person).
WhereEq(&person.Type, 0).
Limit(50, 10).
Driver(driver).
OrderBy(&person.Id, builder.Desc).
GetMany(&list3)
if err1 != nil {
panic(driver + "testLimit" + "found err")
panic(db.DriverName() + "testLimit" + "found err")
}
var list4 []Person
err := aorm.Db(db).Debug(false).
Driver(driver).
err := aorm.Db(db).
Table(&person).
WhereEq(&person.Type, 0).
Page(3, 10).
OrderBy(&person.Id, builder.Desc).
GetMany(&list4)
if err != nil {
panic(driver + "testPage" + "found err")
panic(db.DriverName() + "testPage" + "found err")
}
}
func testLock(driver string, db *sql.DB, id int64) {
if driver == model.Sqlite3 || driver == model.Mssql {
func testLock(db *model.AormDB, id int64) {
if db.DriverName() == model.Sqlite3 || db.DriverName() == model.Mssql {
return
}
var itemByLock Person
err := aorm.Db(db).
Debug(false).
LockForUpdate(true).
Table(&person).
WhereEq(&person.Id, id).
Driver(driver).
OrderBy(&person.Id, builder.Desc).
GetOne(&itemByLock)
if err != nil {
panic(driver + "testLock" + "found err")
panic(db.DriverName() + "testLock" + "found err")
}
}
func testIncrement(driver string, db *sql.DB, id int64) {
_, err := aorm.Db(db).Debug(false).Driver(driver).Table(&person).WhereEq(&person.Id, id).Increment(&person.Age, 1)
func testIncrement(db *model.AormDB, id int64) {
_, err := aorm.Db(db).Table(&person).WhereEq(&person.Id, id).Increment(&person.Age, 1)
if err != nil {
panic(driver + " testIncrement " + "found err:" + err.Error())
panic(db.DriverName() + " testIncrement " + "found err:" + err.Error())
}
}
func testDecrement(driver string, db *sql.DB, id int64) {
_, err := aorm.Db(db).Debug(false).Driver(driver).Table(&person).WhereEq(&person.Id, id).Decrement(&person.Age, 2)
func testDecrement(db *model.AormDB, id int64) {
_, err := aorm.Db(db).Table(&person).WhereEq(&person.Id, id).Decrement(&person.Age, 2)
if err != nil {
panic(driver + "testDecrement" + "found err")
panic(db.DriverName() + "testDecrement" + "found err")
}
}
func testValue(driver string, db *sql.DB, id int64) {
func testValue(db *model.AormDB, id int64) {
var name string
errName := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).Value(&person.Name, &name)
errName := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).Value(&person.Name, &name)
if errName != nil {
panic(driver + "testValue" + "found err")
panic(db.DriverName() + "testValue" + "found err")
}
var age int64
errAge := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).Value(&person.Age, &age)
errAge := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).Value(&person.Age, &age)
if errAge != nil {
panic(driver + "testValue" + "found err")
panic(db.DriverName() + "testValue" + "found err")
}
var money float32
errMoney := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).Value(&person.Money, &money)
errMoney := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).Value(&person.Money, &money)
if errMoney != nil {
panic(driver + "testValue" + "found err")
panic(db.DriverName() + "testValue" + "found err")
}
var test float64
errTest := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).Value(&person.Test, &test)
errTest := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).Value(&person.Test, &test)
if errTest != nil {
panic(driver + "testValue" + "found err")
panic(db.DriverName() + "testValue" + "found err")
}
}
func testPluck(driver string, db *sql.DB) {
func testPluck(db *model.AormDB) {
var nameList []string
errNameList := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Type, 0).Limit(0, 3).Pluck(&person.Name, &nameList)
errNameList := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Type, 0).Limit(0, 3).Pluck(&person.Name, &nameList)
if errNameList != nil {
panic(driver + "testPluck" + "found err")
panic(db.DriverName() + "testPluck" + "found err")
}
var ageList []int64
errAgeList := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Type, 0).Limit(0, 3).Pluck(&person.Age, &ageList)
errAgeList := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Type, 0).Limit(0, 3).Pluck(&person.Age, &ageList)
if errAgeList != nil {
panic(driver + "testPluck" + "found err:" + errAgeList.Error())
panic(db.DriverName() + "testPluck" + "found err:" + errAgeList.Error())
}
var moneyList []float32
errMoneyList := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Type, 0).Limit(0, 3).Pluck(&person.Money, &moneyList)
errMoneyList := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Type, 0).Limit(0, 3).Pluck(&person.Money, &moneyList)
if errMoneyList != nil {
panic(driver + "testPluck" + "found err")
panic(db.DriverName() + "testPluck" + "found err")
}
var testList []float64
errTestList := aorm.Db(db).Debug(false).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Type, 0).Limit(0, 3).Pluck(&person.Test, &testList)
errTestList := aorm.Db(db).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Type, 0).Limit(0, 3).Pluck(&person.Test, &testList)
if errTestList != nil {
panic(driver + "testPluck" + "found err")
panic(db.DriverName() + "testPluck" + "found err")
}
}
func testCount(driver string, db *sql.DB) {
_, err := aorm.Db(db).Debug(false).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Count("*")
func testCount(db *model.AormDB) {
_, err := aorm.Db(db).Table(&person).WhereEq(&person.Age, 18).Count("*")
if err != nil {
panic(driver + "testCount" + "found err")
panic(db.DriverName() + "testCount" + "found err")
}
}
func testSum(driver string, db *sql.DB) {
_, err := aorm.Db(db).Debug(false).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Sum(&person.Age)
func testSum(db *model.AormDB) {
_, err := aorm.Db(db).Table(&person).WhereEq(&person.Age, 18).Sum(&person.Age)
if err != nil {
panic(driver + "testSum" + "found err")
panic(db.DriverName() + "testSum" + "found err")
}
}
func testAvg(driver string, db *sql.DB) {
_, err := aorm.Db(db).Debug(false).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Avg(&person.Age)
func testAvg(db *model.AormDB) {
_, err := aorm.Db(db).Table(&person).WhereEq(&person.Age, 18).Avg(&person.Age)
if err != nil {
panic(driver + "testAvg" + "found err")
panic(db.DriverName() + "testAvg" + "found err")
}
}
func testMin(driver string, db *sql.DB) {
_, err := aorm.Db(db).Debug(false).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Min(&person.Age)
func testMin(db *model.AormDB) {
_, err := aorm.Db(db).Table(&person).WhereEq(&person.Age, 18).Min(&person.Age)
if err != nil {
panic(driver + "testMin" + "found err")
panic(db.DriverName() + "testMin" + "found err")
}
}
func testMax(driver string, db *sql.DB) {
_, err := aorm.Db(db).Debug(false).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Max(&person.Age)
func testMax(db *model.AormDB) {
_, err := aorm.Db(db).Table(&person).WhereEq(&person.Age, 18).Max(&person.Age)
if err != nil {
panic(driver + "testMax" + "found err")
panic(db.DriverName() + "testMax" + "found err")
}
}
func testDistinct(driver string, db *sql.DB) {
func testDistinct(db *model.AormDB) {
var listByFiled []Person
err := aorm.Db(db).Debug(false).Driver(driver).Distinct(true).Table(&person).Select(&person.Name).Select(&person.Age).WhereEq(&person.Age, 18).GetMany(&listByFiled)
err := aorm.Db(db).Distinct(true).Table(&person).Select(&person.Name).Select(&person.Age).WhereEq(&person.Age, 18).GetMany(&listByFiled)
if err != nil {
panic(driver + " testSelect " + "found err:" + err.Error())
panic(db.DriverName() + " testSelect " + "found err:" + err.Error())
}
}
func testRawSql(driver string, db *sql.DB, id2 int64) {
func testRawSql(db *model.AormDB, id2 int64) {
var list []Person
err1 := aorm.Db(db).Debug(false).Driver(driver).RawSql("SELECT * FROM person WHERE id=? AND type=?", id2, 0).GetMany(&list)
err1 := aorm.Db(db).RawSql("SELECT * FROM person WHERE id=? AND type=?", id2, 0).GetMany(&list)
if err1 != nil {
panic(err1)
}
_, err := aorm.Db(db).Debug(false).Driver(driver).RawSql("UPDATE person SET name = ? WHERE id=?", "Bob2", id2).Exec()
_, err := aorm.Db(db).RawSql("UPDATE person SET name = ? WHERE id=?", "Bob2", id2).Exec()
if err != nil {
panic(driver + "testRawSql" + "found err")
panic(db.DriverName() + "testRawSql" + "found err")
}
}
func testTransaction(driver string, db *sql.DB) {
tx, _ := db.Begin()
func testTransaction(db *model.AormDB) {
tx := db.Begin()
id, errInsert := aorm.Db(tx).Debug(false).Driver(driver).Insert(&Person{
id, errInsert := aorm.Db(tx).Insert(&Person{
Name: null.StringFrom("Alice"),
})
if errInsert != nil {
tx.Rollback()
panic(driver + " testTransaction " + "found err:" + errInsert.Error())
panic(db.DriverName() + " testTransaction " + "found err:" + errInsert.Error())
return
}
_, errCount := aorm.Db(tx).Debug(false).Driver(driver).Table(&person).WhereEq(&person.Id, id).Count("*")
_, errCount := aorm.Db(tx).Table(&person).WhereEq(&person.Id, id).Count("*")
if errCount != nil {
tx.Rollback()
panic(driver + "testTransaction" + "found err")
panic(db.DriverName() + "testTransaction" + "found err")
return
}
var personItem Person
errPerson := aorm.Db(tx).Debug(false).Driver(driver).Table(&person).WhereEq(&person.Id, id).OrderBy(&person.Id, builder.Desc).GetOne(&personItem)
errPerson := aorm.Db(tx).Table(&person).WhereEq(&person.Id, id).OrderBy(&person.Id, builder.Desc).GetOne(&personItem)
if errPerson != nil {
tx.Rollback()
panic(driver + "testTransaction" + "found err")
panic(db.DriverName() + "testTransaction" + "found err")
return
}
_, errUpdate := aorm.Db(tx).Debug(false).Driver(driver).Where(&Person{
_, errUpdate := aorm.Db(tx).Where(&Person{
Id: null.IntFrom(id),
}).Update(&Person{
Name: null.StringFrom("Bob"),
@@ -721,24 +715,24 @@ func testTransaction(driver string, db *sql.DB) {
if errUpdate != nil {
tx.Rollback()
panic(driver + "testTransaction" + "found err")
panic(db.DriverName() + "testTransaction" + "found err")
return
}
tx.Commit()
}
func testTruncate(driver string, db *sql.DB) {
_, err := aorm.Db(db).Debug(false).Driver(driver).Table(&person).Truncate()
func testTruncate(db *model.AormDB) {
_, err := aorm.Db(db).Table(&person).Truncate()
if err != nil {
panic(driver + " testTruncate " + "found err")
panic(db.DriverName() + " testTruncate " + "found err")
}
}
func testPreview() {
//Content Mysql
db, _ := sql.Open("mysql", "root:root@tcp(localhost:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local")
db, _ := aorm.Open("mysql", "root:root@tcp(localhost:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local")
//Insert a Person
personId, _ := aorm.Db(db).Insert(&Person{
@@ -760,7 +754,7 @@ func testPreview() {
//GetOne
var personItem Person
err := aorm.Db(db).Table(&person).Table(&person).WhereEq(&person.Id, personId).OrderBy(&person.Id, builder.Desc).GetOne(&personItem)
err := aorm.Db(db).Table(&person).WhereEq(&person.Id, personId).OrderBy(&person.Id, builder.Desc).GetOne(&personItem)
if err != nil {
fmt.Println(err.Error())
}
@@ -791,17 +785,19 @@ func testPreview() {
}
func testDbContent() {
dbContent, _ := aorm.Open("mysql", "root:root@tcp(localhost:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local")
fmt.Println(dbContent)
db, err := aorm.Open("mysql", "root:root@tcp(localhost:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local")
if err != nil {
panic(err)
}
//aorm.Db(dbContent).Insert(&Person{
// Name: null.StringFrom("test name"),
//})
//
//tx := dbContent.Begin()
//aorm.Db(tx).Insert(&Person{
// Name: null.StringFrom("test name"),
//})
//
//tx.Commit()
aorm.Db(db).Insert(&Person{
Name: null.StringFrom("test name"),
})
tx := db.Begin()
aorm.Db(tx).Insert(&Person{
Name: null.StringFrom("test name"),
})
tx.Commit()
}