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

new test

Browse Source
This commit is contained in:
tangpanqing
2023-01-05 17:43:29 +08:00
parent 4e7c71a910
commit 2bc08359b8
8 changed files with 851 additions and 603 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
aorm.go
View File

@@ -13,6 +13,10 @@ type DbContent struct {
DbLink *sql.DB
}
func Store(destList ...interface{}) {
builder.Store(destList...)
}
//Open 开始一个数据库连接
func Open(driverName string, dataSourceName string) (DbContent, error) {
db, err := sql.Open(driverName, dataSourceName)

237
builder/builder.go Normal file
View File

@@ -0,0 +1,237 @@
package builder
import (
"fmt"
"reflect"
"strings"
"unicode"
)
var RawEq = "rawEq"
var TableMap = make(map[uintptr]string)
var FieldMap = make(map[uintptr]FieldInfo)
type FieldInfo struct {
TablePointer uintptr
Name string
}
type WhereItem struct {
Prefix string
Field interface{}
Opt string
Val interface{}
}
type SelectItem struct {
FuncName string
Prefix string
Field interface{}
FieldNew interface{}
}
type JoinItem struct {
joinType string
table interface{}
tableAlias string
condition []JoinCondition
}
type JoinCondition struct {
FieldOfCurrentTable interface{}
Opt string
FieldOfOtherTable interface{}
AliasOfOtherTable string
}
func Store(destList ...interface{}) {
for i := 0; i < len(destList); i++ {
dest := destList[i]
valueOf := reflect.ValueOf(dest)
typeof := reflect.TypeOf(dest)
tablePointer := valueOf.Pointer()
TableMap[tablePointer] = typeof.String()
for j := 0; j < valueOf.Elem().NumField(); j++ {
addr := valueOf.Elem().Field(j).Addr().Pointer()
name := typeof.Elem().Field(j).Name
FieldMap[addr] = FieldInfo{
TablePointer: tablePointer,
Name: name,
}
}
}
}
func GenJoinCondition(fieldOfCurrentTable interface{}, opt string, fieldOfOtherTable interface{}, aliasOfOtherTable ...string) JoinCondition {
alias := ""
if len(aliasOfOtherTable) > 0 {
alias = aliasOfOtherTable[0]
}
return JoinCondition{
FieldOfCurrentTable: fieldOfCurrentTable,
Opt: opt,
FieldOfOtherTable: fieldOfOtherTable,
AliasOfOtherTable: alias,
}
}
//func (b *Builder) GetOne(dest interface{}) {
// var paramList []interface{}
//
// table := getTableName(b.table)
// selectStr, paramList := b.handleSelect(paramList)
// joinStr, paramList := b.handleJoin(paramList)
// whereStr, paramList := b.handleWhere(paramList)
//
// var sql = "SELECT " + selectStr + " FROM " + table + " " + b.tableAlias + joinStr + whereStr
//
// fmt.Println(sql)
// //fmt.Println(paramList)
//}
func (b *Builder) handleSelect(paramList []interface{}) (string, []interface{}) {
if len(b.selectList) == 0 {
return "*", paramList
}
var sqlList []string
for i := 0; i < len(b.selectList); i++ {
nameOfField := ""
typeOfField := reflect.TypeOf(b.selectList[i].Field)
valueOfField := reflect.ValueOf(b.selectList[i].Field)
if reflect.String == typeOfField.Kind() {
nameOfField = fmt.Sprintf("%v", b.selectList[i].Field)
} else if reflect.Ptr == typeOfField.Kind() {
nameOfField = UnderLine(FieldMap[valueOfField.Pointer()].Name)
} else {
panic("其他类型")
}
nameOfFieldNew := ""
if b.selectList[i].FieldNew != nil {
typeOfFieldNew := reflect.TypeOf(b.selectList[i].FieldNew)
valueOfFieldNew := reflect.ValueOf(b.selectList[i].FieldNew)
if reflect.String == typeOfFieldNew.Kind() {
nameOfFieldNew = fmt.Sprintf("%v", b.selectList[i].FieldNew)
} else if reflect.Ptr == typeOfFieldNew.Kind() {
nameOfFieldNew = UnderLine(FieldMap[valueOfFieldNew.Pointer()].Name)
} else {
panic("其他类型")
}
if nameOfFieldNew != "" {
nameOfFieldNew = " AS " + nameOfFieldNew
}
}
sqlList = append(sqlList, b.selectList[i].Prefix+"."+nameOfField+nameOfFieldNew)
}
return strings.Join(sqlList, ","), paramList
}
//func (b *Builder) handleWhere(paramList []interface{}) (string, []interface{}) {
// if len(b.whereList) == 0 {
// return "", paramList
// }
//
// str, paramList := getWhereStr(b.whereList, paramList)
//
// return " WHERE " + str, paramList
//}
func getPrefixByField(field interface{}, alias ...string) string {
str := ""
if len(alias) > 0 {
str = alias[0]
} else {
str = getTableNameByField(field)
}
return str
}
func UnderLine(s string) string {
var output []rune
for i, r := range s {
if i == 0 {
output = append(output, unicode.ToLower(r))
continue
}
if unicode.IsUpper(r) {
output = append(output, '_')
}
output = append(output, unicode.ToLower(r))
}
return string(output)
}
func getTableNameByTable(table interface{}) string {
if table == nil {
panic("当前table不能是nil")
}
tableName := TableMap[reflect.ValueOf(table).Pointer()]
strArr := strings.Split(tableName, ".")
return UnderLine(strArr[len(strArr)-1])
}
func getTableNameByField(field interface{}) string {
valueOf := reflect.ValueOf(field)
if reflect.Ptr == valueOf.Kind() {
tablePointer := FieldMap[reflect.ValueOf(field).Pointer()].TablePointer
tableName := TableMap[tablePointer]
strArr := strings.Split(tableName, ".")
return UnderLine(strArr[len(strArr)-1])
} else {
return fmt.Sprintf("%v", field)
}
}
func getWhereStrForJoin(aliasOfCurrentTable string, joinCondition []JoinCondition, paramList []interface{}) (string, []interface{}) {
var sqlList []string
for i := 0; i < len(joinCondition); i++ {
fieldNameOfCurrentTable := getFieldName(joinCondition[i].FieldOfCurrentTable)
if joinCondition[i].Opt == RawEq {
if aliasOfCurrentTable == "" {
aliasOfCurrentTable = getPrefixByField(joinCondition[i].FieldOfCurrentTable)
}
aliasOfOtherTable := joinCondition[i].AliasOfOtherTable
if aliasOfOtherTable == "" {
aliasOfOtherTable = getPrefixByField(joinCondition[i].FieldOfOtherTable)
}
fieldNameOfOtherTable := getFieldName(joinCondition[i].FieldOfOtherTable)
sqlList = append(sqlList, aliasOfCurrentTable+"."+fieldNameOfCurrentTable+"="+aliasOfOtherTable+"."+fieldNameOfOtherTable)
}
}
return strings.Join(sqlList, " AND "), paramList
}
func getFieldName(field interface{}) string {
return UnderLine(FieldMap[reflect.ValueOf(field).Pointer()].Name)
}
func getWhereStr(whereList []WhereItem, paramList []interface{}) (string, []interface{}) {
var sqlList []string
for i := 0; i < len(whereList); i++ {
prefix := whereList[i].Prefix
field := getFieldName(whereList[i].Field)
if whereList[i].Opt == "=" {
sqlList = append(sqlList, prefix+"."+field+"="+"?")
paramList = append(paramList, whereList[i].Val)
}
if whereList[i].Opt == "rawEq" {
value := getFieldName(whereList[i].Val)
sqlList = append(sqlList, prefix+"."+field+"="+value)
}
}
return strings.Join(sqlList, " AND "), paramList
}

69
builder/crud.go
View File

@@ -32,23 +32,26 @@ const NotBetween = "NOT BETWEEN"
const Raw = "Raw"
// SelectItem 将某子语句重命名为某字段
type SelectItem struct {
Executor **Builder
FieldName string
}
//type SelectItem struct {
// Executor **Builder
// FieldName string
//}
// Builder 查询记录所需要的条件
type Builder struct {
//数据库操作连接
LinkCommon model.LinkCommon
table interface{}
tableAlias string
//查询参数
tableName string
selectList []string
selectList []SelectItem
selectExpList []*SelectItem
groupList []string
whereList []WhereItem
joinList []string
joinList []JoinItem
havingList []WhereItem
orderList []string
offset int
@@ -64,11 +67,11 @@ type Builder struct {
driverName string
}
type WhereItem struct {
Field string
Opt string
Val any
}
//type WhereItem struct {
// Field string
// Opt string
// Val any
//}
func (ex *Builder) Driver(driverName string) *Builder {
ex.driverName = driverName
@@ -313,17 +316,18 @@ func (ex *Builder) GetSqlAndParams() (string, []interface{}) {
}
var paramList []interface{}
tableName := getTableNameByTable(ex.table)
fieldStr, paramList := handleField(ex.selectList, ex.selectExpList, paramList)
whereStr, paramList := ex.handleWhere(ex.whereList, paramList)
joinStr := handleJoin(ex.joinList)
joinStr, paramList := ex.handleJoin(paramList)
groupStr := handleGroup(ex.groupList)
havingStr, paramList := ex.handleHaving(ex.havingList, paramList)
orderStr := handleOrder(ex.orderList)
limitStr, paramList := ex.handleLimit(ex.offset, ex.pageSize, paramList)
lockStr := handleLockForUpdate(ex.isLockForUpdate)
sqlStr := "SELECT " + fieldStr + " FROM " + ex.tableName + joinStr + whereStr + groupStr + havingStr + orderStr + limitStr + lockStr
sqlStr := "SELECT " + fieldStr + " FROM " + tableName + " " + ex.tableAlias + joinStr + whereStr + groupStr + havingStr + orderStr + limitStr + lockStr
if ex.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr)
@@ -377,7 +381,10 @@ func (ex *Builder) Truncate() (int64, error) {
// Exists 存在某记录
func (ex *Builder) Exists() (bool, error) {
var obj IntStruct
err := ex.Select("1 as c").Limit(0, 1).GetOne(&obj)
ex.selectCommon("", "1 as c", nil)
err := ex.Limit(0, 1).GetOne(&obj)
if err != nil {
return false, err
}
@@ -551,9 +558,12 @@ func (ex *Builder) Debug(isDebug bool) *Builder {
}
// Table 链式操作-从哪个表查询,允许直接写别名,例如 person p
func (ex *Builder) Table(tableName string) *Builder {
ex.tableName = tableName
return ex
func (b *Builder) Table(table interface{}, alias ...string) *Builder {
b.table = table
if len(alias) > 0 {
b.tableAlias = alias[0]
}
return b
}
// GroupBy 链式操作,以某字段进行分组
@@ -563,8 +573,8 @@ func (ex *Builder) GroupBy(fieldName string) *Builder {
}
// OrderBy 链式操作,以某字段进行排序
func (ex *Builder) OrderBy(field string, orderType string) *Builder {
ex.orderList = append(ex.orderList, field+" "+orderType)
func (ex *Builder) OrderBy(field interface{}, orderType string) *Builder {
//ex.orderList = append(ex.orderList, field+" "+orderType)
return ex
}
@@ -592,12 +602,15 @@ func (ex *Builder) LockForUpdate(isLockForUpdate bool) *Builder {
func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string, []any) {
var whereList []string
for i := 0; i < len(where); i++ {
prefix := where[i].Prefix
fieldName := getFieldName(where[i].Field)
if "**builder.Builder" == reflect.TypeOf(where[i].Val).String() {
executor := *(**Builder)(unsafe.Pointer(reflect.ValueOf(where[i].Val).Pointer()))
subSql, subParams := executor.GetSqlAndParams()
if where[i].Opt != Raw {
whereList = append(whereList, where[i].Field+" "+where[i].Opt+" "+"("+subSql+")")
whereList = append(whereList, prefix+"."+fieldName+" "+where[i].Opt+" "+"("+subSql+")")
paramList = append(paramList, subParams...)
} else {
@@ -605,15 +618,15 @@ func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string,
} else {
if where[i].Opt == Eq || where[i].Opt == Ne || where[i].Opt == Gt || where[i].Opt == Ge || where[i].Opt == Lt || where[i].Opt == Le {
if ex.driverName == model.Sqlite3 {
whereList = append(whereList, where[i].Field+" "+where[i].Opt+" "+"?")
whereList = append(whereList, prefix+"."+fieldName+" "+where[i].Opt+" "+"?")
} else {
switch where[i].Val.(type) {
case float32:
whereList = append(whereList, ex.getConcatForFloat(where[i].Field, "''")+" "+where[i].Opt+" "+"?")
whereList = append(whereList, ex.getConcatForFloat(prefix+"."+fieldName, "''")+" "+where[i].Opt+" "+"?")
case float64:
whereList = append(whereList, ex.getConcatForFloat(where[i].Field, "''")+" "+where[i].Opt+" "+"?")
whereList = append(whereList, ex.getConcatForFloat(prefix+"."+fieldName, "''")+" "+where[i].Opt+" "+"?")
default:
whereList = append(whereList, where[i].Field+" "+where[i].Opt+" "+"?")
whereList = append(whereList, prefix+"."+fieldName+" "+where[i].Opt+" "+"?")
}
}
@@ -622,7 +635,7 @@ func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string,
if where[i].Opt == Between || where[i].Opt == NotBetween {
values := toAnyArr(where[i].Val)
whereList = append(whereList, where[i].Field+" "+where[i].Opt+" "+"(?) AND (?)")
whereList = append(whereList, prefix+"."+fieldName+" "+where[i].Opt+" "+"(?) AND (?)")
paramList = append(paramList, values...)
}
@@ -640,7 +653,7 @@ func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string,
}
}
whereList = append(whereList, where[i].Field+" "+where[i].Opt+" "+ex.getConcatForLike(valueStr...))
whereList = append(whereList, prefix+"."+fieldName+" "+where[i].Opt+" "+ex.getConcatForLike(valueStr...))
}
if where[i].Opt == In || where[i].Opt == NotIn {
@@ -650,12 +663,12 @@ func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string,
placeholder = append(placeholder, "?")
}
whereList = append(whereList, where[i].Field+" "+where[i].Opt+" "+"("+strings.Join(placeholder, ",")+")")
whereList = append(whereList, prefix+"."+fieldName+" "+where[i].Opt+" "+"("+strings.Join(placeholder, ",")+")")
paramList = append(paramList, values...)
}
if where[i].Opt == Raw {
whereList = append(whereList, where[i].Field+fmt.Sprintf("%v", where[i].Val))
whereList = append(whereList, prefix+"."+fieldName+fmt.Sprintf("%v", where[i].Val))
}
}
}

36
builder/handle.go
View File

@@ -8,20 +8,21 @@ import (
)
//拼接SQL,字段相关
func handleField(selectList []string, selectExpList []*SelectItem, paramList []any) (string, []any) {
func handleField(selectList []SelectItem, selectExpList []*SelectItem, paramList []any) (string, []any) {
if len(selectList) == 0 && len(selectExpList) == 0 {
return "*", paramList
}
//处理子语句
for i := 0; i < len(selectExpList); i++ {
executor := *(selectExpList[i].Executor)
subSql, subParamList := executor.GetSqlAndParams()
selectList = append(selectList, "("+subSql+") AS "+selectExpList[i].FieldName)
paramList = append(paramList, subParamList...)
}
//for i := 0; i < len(selectExpList); i++ {
// executor := *(selectExpList[i].Executor)
// subSql, subParamList := executor.GetSqlAndParams()
// selectList = append(selectList, "("+subSql+") AS "+selectExpList[i].FieldName)
// paramList = append(paramList, subParamList...)
//}
var strList []string
return strings.Join(selectList, ","), paramList
return strings.Join(strList, ","), paramList
}
//拼接SQL,查询条件
@@ -61,12 +62,23 @@ func (ex *Builder) handleSet(dest interface{}, paramList []any) (string, []any)
}
//拼接SQL,关联查询
func handleJoin(joinList []string) string {
if len(joinList) == 0 {
return ""
func (b *Builder) handleJoin(paramList []interface{}) (string, []interface{}) {
if len(b.joinList) == 0 {
return "", paramList
}
return " " + strings.Join(joinList, " ")
var sqlList []string
for i := 0; i < len(b.joinList); i++ {
joinItem := b.joinList[i]
str, paramList2 := getWhereStrForJoin(joinItem.tableAlias, joinItem.condition, paramList)
paramList = append(paramList, paramList2...)
sqlItem := joinItem.joinType + " " + getTableNameByTable(joinItem.table) + " " + joinItem.tableAlias + " ON " + str
sqlList = append(sqlList, sqlItem)
}
return " " + strings.Join(sqlList, " "), paramList
}
//拼接SQL,结果分组

32
builder/join.go
View File

@@ -1,19 +1,33 @@
package builder
// LeftJoin 链式操作,左联查询,例如 LeftJoin("project p", "p.project_id=o.project_id")
func (ex *Builder) LeftJoin(tableName string, condition string) *Builder {
ex.joinList = append(ex.joinList, "LEFT JOIN "+tableName+" ON "+condition)
return ex
func (b *Builder) LeftJoin(table interface{}, condition []JoinCondition, alias ...string) *Builder {
b.join("LEFT JOIN", table, condition, alias...)
return b
}
// RightJoin 链式操作,右联查询,例如 RightJoin("project p", "p.project_id=o.project_id")
func (ex *Builder) RightJoin(tableName string, condition string) *Builder {
ex.joinList = append(ex.joinList, "RIGHT JOIN "+tableName+" ON "+condition)
return ex
func (b *Builder) RightJoin(table interface{}, condition []JoinCondition, alias ...string) *Builder {
b.join("RIGHT JOIN", table, condition, alias...)
return b
}
// Join 链式操作,内联查询,例如 Join("project p", "p.project_id=o.project_id")
func (ex *Builder) Join(tableName string, condition string) *Builder {
ex.joinList = append(ex.joinList, "INNER JOIN "+tableName+" ON "+condition)
return ex
func (b *Builder) Join(table interface{}, condition []JoinCondition, alias ...string) *Builder {
b.join("INNER JOIN", table, condition, alias...)
return b
}
func (b *Builder) join(joinType string, table interface{}, condition []JoinCondition, alias ...string) {
joinTableAlias := ""
if len(alias) > 0 {
joinTableAlias = alias[0]
}
b.joinList = append(b.joinList, JoinItem{
joinType: joinType,
table: table,
tableAlias: joinTableAlias,
condition: condition,
})
}

61
builder/select.go
View File

@@ -1,46 +1,59 @@
package builder
func (b *Builder) SelectAll(prefix ...string) *Builder {
return b.selectCommon("", "*", nil, prefix...)
}
// Select 链式操作-查询哪些字段,默认 *
func (ex *Builder) Select(fields ...string) *Builder {
ex.selectList = append(ex.selectList, fields...)
return ex
func (b *Builder) Select(field interface{}, prefix ...string) *Builder {
return b.selectCommon("", field, nil, prefix...)
}
func (b *Builder) SelectAs(field interface{}, fieldNew interface{}, prefix ...string) *Builder {
return b.selectCommon("", field, fieldNew, prefix...)
}
// SelectCount 链式操作-count(field) as field_new
func (ex *Builder) SelectCount(field string, fieldNew string) *Builder {
ex.selectList = append(ex.selectList, "count("+field+") AS "+fieldNew)
return ex
func (b *Builder) SelectCount(field interface{}, fieldNew interface{}, prefix ...string) *Builder {
return b.selectCommon("count", field, fieldNew, prefix...)
}
// SelectSum 链式操作-sum(field) as field_new
func (ex *Builder) SelectSum(field string, fieldNew string) *Builder {
ex.selectList = append(ex.selectList, "sum("+field+") AS "+fieldNew)
return ex
func (b *Builder) SelectSum(field interface{}, fieldNew interface{}, prefix ...string) *Builder {
return b.selectCommon("sum", field, fieldNew, prefix...)
}
// SelectMin 链式操作-min(field) as field_new
func (ex *Builder) SelectMin(field string, fieldNew string) *Builder {
ex.selectList = append(ex.selectList, "min("+field+") AS "+fieldNew)
return ex
func (b *Builder) SelectMin(field interface{}, fieldNew interface{}, prefix ...string) *Builder {
return b.selectCommon("min", field, fieldNew, prefix...)
}
// SelectMax 链式操作-max(field) as field_new
func (ex *Builder) SelectMax(field string, fieldNew string) *Builder {
ex.selectList = append(ex.selectList, "max("+field+") AS "+fieldNew)
return ex
func (b *Builder) SelectMax(field interface{}, fieldNew interface{}, prefix ...string) *Builder {
return b.selectCommon("max", field, fieldNew, prefix...)
}
// SelectAvg 链式操作-avg(field) as field_new
func (ex *Builder) SelectAvg(field string, fieldNew string) *Builder {
ex.selectList = append(ex.selectList, "avg("+field+") AS "+fieldNew)
return ex
func (b *Builder) SelectAvg(field interface{}, fieldNew interface{}, prefix ...string) *Builder {
return b.selectCommon("avg", field, fieldNew, prefix...)
}
func (b *Builder) selectCommon(funcName string, field interface{}, fieldNew interface{}, prefix ...string) *Builder {
b.selectList = append(b.selectList, SelectItem{
funcName,
getPrefixByField(field, prefix...),
field,
fieldNew,
})
return b
}
// SelectExp 链式操作-表达式
func (ex *Builder) SelectExp(dbSub **Builder, fieldName string) *Builder {
ex.selectExpList = append(ex.selectExpList, &SelectItem{
Executor: dbSub,
FieldName: fieldName,
})
return ex
func (b *Builder) SelectExp(dbSub **Builder, fieldName string) *Builder {
//ex.selectExpList = append(ex.selectExpList, &SelectItem{
// Executor: dbSub,
// FieldName: fieldName,
//})
return b
}

146
builder/where.go
View File

@@ -6,13 +6,13 @@ import (
)
// Where 链式操作,以对象作为查询条件
func (ex *Builder) Where(dest interface{}) *Builder {
func (b *Builder) Where(dest interface{}) *Builder {
typeOf := reflect.TypeOf(dest)
valueOf := reflect.ValueOf(dest)
//如果没有设置表名
if ex.tableName == "" {
ex.tableName = getTableName(typeOf, valueOf)
if b.tableName == "" {
b.tableName = getTableName(typeOf, valueOf)
}
for i := 0; i < typeOf.Elem().NumField(); i++ {
@@ -20,132 +20,80 @@ func (ex *Builder) Where(dest interface{}) *Builder {
if isNotNull {
key := helper.UnderLine(typeOf.Elem().Field(i).Name)
val := valueOf.Elem().Field(i).Field(0).Field(0).Interface()
ex.whereList = append(ex.whereList, WhereItem{Field: key, Opt: Eq, Val: val})
b.whereList = append(b.whereList, WhereItem{Field: key, Opt: Eq, Val: val})
}
}
return ex
return b
}
// WhereArr 链式操作,以数组作为查询条件
func (ex *Builder) WhereArr(whereList []WhereItem) *Builder {
ex.whereList = append(ex.whereList, whereList...)
return ex
func (b *Builder) WhereArr(whereList []WhereItem) *Builder {
b.whereList = append(b.whereList, whereList...)
return b
}
func (ex *Builder) WhereEq(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Eq,
Val: val,
})
return ex
func (b *Builder) WhereEq(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Eq, val})
return b
}
func (ex *Builder) WhereNe(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Ne,
Val: val,
})
return ex
func (b *Builder) WhereNe(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Ne, val})
return b
}
func (ex *Builder) WhereGt(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Gt,
Val: val,
})
return ex
func (b *Builder) WhereGt(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Gt, val})
return b
}
func (ex *Builder) WhereGe(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Ge,
Val: val,
})
return ex
func (b *Builder) WhereGe(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Ge, val})
return b
}
func (ex *Builder) WhereLt(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Lt,
Val: val,
})
return ex
func (b *Builder) WhereLt(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Lt, val})
return b
}
func (ex *Builder) WhereLe(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Le,
Val: val,
})
return ex
func (b *Builder) WhereLe(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Le, val})
return b
}
func (ex *Builder) WhereIn(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: In,
Val: val,
})
return ex
func (b *Builder) WhereIn(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, In, val})
return b
}
func (ex *Builder) WhereNotIn(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: NotIn,
Val: val,
})
return ex
func (b *Builder) WhereNotIn(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, NotIn, val})
return b
}
func (ex *Builder) WhereBetween(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Between,
Val: val,
})
return ex
func (b *Builder) WhereBetween(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Between, val})
return b
}
func (ex *Builder) WhereNotBetween(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: NotBetween,
Val: val,
})
return ex
func (b *Builder) WhereNotBetween(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, NotBetween, val})
return b
}
func (ex *Builder) WhereLike(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Like,
Val: val,
})
return ex
func (b *Builder) WhereLike(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Like, val})
return b
}
func (ex *Builder) WhereNotLike(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: NotLike,
Val: val,
})
return ex
func (b *Builder) WhereNotLike(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, NotLike, val})
return b
}
func (ex *Builder) WhereRaw(field string, val interface{}) *Builder {
ex.whereList = append(ex.whereList, WhereItem{
Field: field,
Opt: Raw,
Val: val,
})
return ex
func (b *Builder) WhereRaw(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Raw, val})
return b
}

869
test/aorm_test.go
View File

@@ -9,8 +9,6 @@ import (
_ "github.com/mattn/go-sqlite3"
"github.com/tangpanqing/aorm"
"github.com/tangpanqing/aorm/builder"
"github.com/tangpanqing/aorm/helper"
"github.com/tangpanqing/aorm/model"
"github.com/tangpanqing/aorm/null"
"testing"
"time"
@@ -59,21 +57,29 @@ type PersonWithArticleCount struct {
ArticleCount null.Int `aorm:"comment:文章数量" json:"articleCount"`
}
var person = Person{}
var article = Article{}
var articleVO = ArticleVO{}
func TestAll(t *testing.T) {
aorm.Store(&person, &article)
aorm.Store(&articleVO)
dbList := make([]aorm.DbContent, 0)
dbList = append(dbList, testSqlite3Connect())
//dbList = append(dbList, testSqlite3Connect())
dbList = append(dbList, testMysqlConnect())
dbList = append(dbList, testPostgresConnect())
dbList = append(dbList, testMssqlConnect())
//dbList = append(dbList, testPostgresConnect())
//dbList = append(dbList, testMssqlConnect())
for i := 0; i < len(dbList); i++ {
dbItem := dbList[i]
testMigrate(dbItem.DriverName, dbItem.DbLink)
//testMigrate(dbItem.DriverName, dbItem.DbLink)
testShowCreateTable(dbItem.DriverName, dbItem.DbLink)
//testShowCreateTable(dbItem.DriverName, dbItem.DbLink)
id := testInsert(dbItem.DriverName, dbItem.DbLink)
fmt.Println(id)
testInsertBatch(dbItem.DriverName, dbItem.DbLink)
testGetOne(dbItem.DriverName, dbItem.DbLink, id)
@@ -83,44 +89,44 @@ func TestAll(t *testing.T) {
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)
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)
testExec(dbItem.DriverName, dbItem.DbLink)
testTransaction(dbItem.DriverName, dbItem.DbLink)
//
//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)
//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)
//
//testExec(dbItem.DriverName, dbItem.DbLink)
//
//testTransaction(dbItem.DriverName, dbItem.DbLink)
//testTruncate(dbItem.DriverName, dbItem.DbLink)
testHelper(dbItem.DriverName, dbItem.DbLink)
//testHelper(dbItem.DriverName, dbItem.DbLink)
}
}
@@ -199,7 +205,7 @@ func testShowCreateTable(driver string, db *sql.DB) {
func testInsert(driver string, db *sql.DB) int64 {
obj := Person{
Name: null.StringFrom("Alice"),
Sex: null.BoolFrom(false),
Sex: null.BoolFrom(true),
Age: null.IntFrom(18),
Type: null.IntFrom(0),
CreateTime: null.TimeFrom(time.Now()),
@@ -207,7 +213,7 @@ func testInsert(driver string, db *sql.DB) int64 {
Test: null.FloatFrom(2),
}
id, errInsert := aorm.Use(db).Debug(false).Driver(driver).Insert(&obj)
id, errInsert := aorm.Use(db).Debug(true).Driver(driver).Insert(&obj)
if errInsert != nil {
panic(driver + " testInsert " + "found err: " + errInsert.Error())
}
@@ -217,34 +223,34 @@ func testInsert(driver string, db *sql.DB) int64 {
ArticleBody: null.StringFrom("文章内容"),
})
var person Person
err := aorm.Use(db).Table("person").Debug(false).Driver(driver).WhereEq("id", id).OrderBy("id", "DESC").GetOne(&person)
var personItem Person
err := aorm.Use(db).Table(&person).Debug(true).Driver(driver).Table(&person).WhereEq(&person.Id, id).OrderBy(&person.Id, builder.Desc).GetOne(&personItem)
if err != nil {
fmt.Println(err.Error())
}
if obj.Name.String != person.Name.String {
fmt.Println(driver + ",Name not match, expected: " + obj.Name.String + " ,but real is : " + person.Name.String)
if obj.Name.String != personItem.Name.String {
fmt.Println(driver + ",Name not match, expected: " + obj.Name.String + " ,but real is : " + personItem.Name.String)
}
if obj.Sex.Bool != person.Sex.Bool {
fmt.Println(driver + ",Sex not match, expected: " + fmt.Sprintf("%v", obj.Sex.Bool) + " ,but real is : " + fmt.Sprintf("%v", person.Sex.Bool))
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))
}
if obj.Age.Int64 != person.Age.Int64 {
fmt.Println(driver + ",Age not match, expected: " + fmt.Sprintf("%v", obj.Age.Int64) + " ,but real is : " + fmt.Sprintf("%v", person.Age.Int64))
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))
}
if obj.Type.Int64 != person.Type.Int64 {
fmt.Println(driver + ",Type not match, expected: " + fmt.Sprintf("%v", obj.Type.Int64) + " ,but real is : " + fmt.Sprintf("%v", person.Type.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))
}
if obj.Money.Float64 != person.Money.Float64 {
fmt.Println(driver + ",Money not match, expected: " + fmt.Sprintf("%v", obj.Money.Float64) + " ,but real is : " + fmt.Sprintf("%v", person.Money.Float64))
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))
}
if obj.Test.Float64 != person.Test.Float64 {
fmt.Println(driver + ",Test not match, expected: " + fmt.Sprintf("%v", obj.Test.Float64) + " ,but real is : " + fmt.Sprintf("%v", person.Test.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))
}
return id
@@ -272,7 +278,7 @@ func testInsertBatch(driver string, db *sql.DB) int64 {
Test: null.FloatFrom(200.15987654321987654321),
})
count, err := aorm.Use(db).Debug(false).Driver(driver).InsertBatch(&batch)
count, err := aorm.Use(db).Debug(true).Driver(driver).InsertBatch(&batch)
if err != nil {
panic(driver + " testInsertBatch " + "found err:" + err.Error())
}
@@ -281,8 +287,8 @@ func testInsertBatch(driver string, db *sql.DB) int64 {
}
func testGetOne(driver string, db *sql.DB, id int64) {
var person Person
errFind := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).GetOne(&person)
var personItem Person
errFind := aorm.Use(db).Debug(true).Driver(driver).Table(&person).OrderBy(&person.Id, builder.Desc).WhereEq(&person.Id, id).GetOne(&personItem)
if errFind != nil {
panic(driver + "testGetOne" + "found err")
}
@@ -290,398 +296,399 @@ func testGetOne(driver string, db *sql.DB, id int64) {
func testGetMany(driver string, db *sql.DB) {
var list []Person
errSelect := aorm.Use(db).Driver(driver).Debug(false).Where(&Person{Type: null.IntFrom(0)}).GetMany(&list)
errSelect := aorm.Use(db).Driver(driver).Debug(true).Table(&person).WhereEq(&person.Type, 0).GetMany(&list)
if errSelect != nil {
panic(driver + " testGetMany " + "found err:" + errSelect.Error())
}
}
func testUpdate(driver string, db *sql.DB, id int64) {
_, errUpdate := aorm.Use(db).Debug(false).Driver(driver).Where(&Person{Id: null.IntFrom(id)}).Update(&Person{Name: null.StringFrom("Bob")})
_, errUpdate := aorm.Use(db).Debug(true).Driver(driver).WhereEq(&person.Id, id).Update(&Person{Name: null.StringFrom("Bob")})
if errUpdate != nil {
panic(driver + "testGetMany" + "found err")
panic(driver + "testUpdate" + "found err")
}
}
func testDelete(driver string, db *sql.DB, id int64) {
_, errDelete := aorm.Use(db).Driver(driver).Debug(false).Where(&Person{Id: null.IntFrom(id)}).Delete()
_, errDelete := aorm.Use(db).Driver(driver).Debug(true).WhereEq(&person.Id, id).Delete()
if errDelete != nil {
panic(driver + "testDelete" + "found err")
}
}
func testExists(driver string, db *sql.DB, id int64) bool {
exists, err := aorm.Use(db).Driver(driver).Debug(false).Where(&Person{Id: null.IntFrom(id)}).OrderBy("id", "DESC").Exists()
exists, err := aorm.Use(db).Driver(driver).Debug(true).Table(&person).WhereEq(&person.Id, id).OrderBy("id", "DESC").Exists()
if err != nil {
panic(driver + " testExists " + "found err:" + err.Error())
}
return exists
}
func testTable(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(false).Driver(driver).Table("person_1").Insert(&Person{Name: null.StringFrom("Cherry")})
if err != nil {
panic(driver + " testTable " + "found err:" + err.Error())
}
}
//
//func testTable(driver string, db *sql.DB) {
// _, err := aorm.Use(db).Debug(false).Driver(driver).Table("person_1").Insert(&Person{Name: null.StringFrom("Cherry")})
// if err != nil {
// panic(driver + " testTable " + "found err:" + err.Error())
// }
//}
//
//func testSelect(driver string, db *sql.DB) {
// var listByFiled []Person
// err := aorm.Use(db).Debug(false).Driver(driver).Select("name,age").Where(&Person{Age: null.IntFrom(18)}).GetMany(&listByFiled)
// if err != nil {
// panic(driver + " testSelect " + "found err:" + err.Error())
// }
//}
//
//func testSelectWithSub(driver string, db *sql.DB) {
// var listByFiled []PersonWithArticleCount
//
// sub := aorm.Sub().Table("article").SelectCount("id", "article_count_tem").WhereRaw("person_id", "=person.id")
// err := aorm.Use(db).Debug(false).
// Driver(driver).
// SelectExp(&sub, "article_count").
// Select("*").
// Where(&Person{Age: null.IntFrom(18)}).
// GetMany(&listByFiled)
//
// if err != nil {
// panic(driver + " testSelectWithSub " + "found err:" + err.Error())
// }
//}
//
//func testWhereWithSub(driver string, db *sql.DB) {
// var listByFiled []Person
//
// sub := aorm.Sub().Table("article").Select("person_id").GroupBy("person_id").HavingGt("count(person_id)", 0)
//
// err := aorm.Use(db).Debug(false).
// Table("person").
// Driver(driver).
// WhereIn("id", &sub).
// GetMany(&listByFiled)
//
// if err != nil {
// panic(driver + " testWhereWithSub " + "found err:" + err.Error())
// }
//}
//
//func testWhere(driver string, db *sql.DB) {
// var listByWhere []Person
//
// var where1 []builder.WhereItem
// where1 = append(where1, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
// where1 = append(where1, builder.WhereItem{Field: "age", Opt: builder.In, Val: []int{18, 20}})
// where1 = append(where1, builder.WhereItem{Field: "money", Opt: builder.Between, Val: []float64{100.1, 200.9}})
// where1 = append(where1, builder.WhereItem{Field: "money", Opt: builder.Eq, Val: 100.15})
// where1 = append(where1, builder.WhereItem{Field: "name", Opt: builder.Like, Val: []string{"%", "li", "%"}})
//
// err := aorm.Use(db).Debug(false).Driver(driver).Table("person").WhereArr(where1).GetMany(&listByWhere)
// if err != nil {
// panic(driver + "testWhere" + "found err")
// }
//}
func testSelect(driver string, db *sql.DB) {
var listByFiled []Person
err := aorm.Use(db).Debug(false).Driver(driver).Select("name,age").Where(&Person{Age: null.IntFrom(18)}).GetMany(&listByFiled)
if err != nil {
panic(driver + " testSelect " + "found err:" + err.Error())
}
}
//func testJoin(driver string, db *sql.DB) {
// var list2 []ArticleVO
// var where2 []builder.WhereItem
// where2 = append(where2, builder.WhereItem{Field: "o.type", Opt: builder.Eq, Val: 0})
// where2 = append(where2, builder.WhereItem{Field: "p.age", Opt: builder.In, Val: []int{18, 20}})
// err := aorm.Use(db).Debug(false).
// Table("article o").
// LeftJoin("person p", "p.id=o.person_id").
// Select("o.*").
// Select("p.name as person_name").
// WhereArr(where2).
// Driver(driver).
// GetMany(&list2)
// if err != nil {
// panic(driver + " testWhere " + "found err " + err.Error())
// }
//}
func testSelectWithSub(driver string, db *sql.DB) {
var listByFiled []PersonWithArticleCount
//func testGroupBy(driver string, db *sql.DB) {
// var personAge PersonAge
// var where []builder.WhereItem
// where = append(where, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
// err := aorm.Use(db).Debug(false).
// Table("person").
// Select("age").
// Select("count(age) as age_count").
// GroupBy("age").
// WhereArr(where).
// Driver(driver).
// OrderBy("age", "DESC").
// GetOne(&personAge)
// if err != nil {
// panic(driver + "testGroupBy" + "found err")
// }
//}
//
//func testHaving(driver string, db *sql.DB) {
// var listByHaving []PersonAge
//
// var where3 []builder.WhereItem
// where3 = append(where3, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
//
// var having []builder.WhereItem
// having = append(having, builder.WhereItem{Field: "count(age)", Opt: builder.Gt, Val: 4})
//
// err := aorm.Use(db).Debug(false).
// Table("person").
// Select("age").
// Select("count(age) as age_count").
// GroupBy("age").
// WhereArr(where3).
// Driver(driver).
// OrderBy("age", "DESC").
// HavingArr(having).
// GetMany(&listByHaving)
// if err != nil {
// panic(driver + " testHaving " + "found err")
// }
//}
//
//func testOrderBy(driver string, db *sql.DB) {
// var listByOrder []Person
// var where []builder.WhereItem
// where = append(where, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
// err := aorm.Use(db).Debug(false).
// Table("person").
// WhereArr(where).
// OrderBy("age", builder.Desc).
// Driver(driver).
// GetMany(&listByOrder)
// if err != nil {
// panic(driver + "testOrderBy" + "found err")
// }
//}
//
//func testLimit(driver string, db *sql.DB) {
// var list3 []Person
// var where1 []builder.WhereItem
// where1 = append(where1, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
// err1 := aorm.Use(db).Debug(false).
// Table("person").
// WhereArr(where1).
// Limit(50, 10).
// Driver(driver).
// OrderBy("id", "DESC").
// GetMany(&list3)
// if err1 != nil {
// panic(driver + "testLimit" + "found err")
// }
//
// var list4 []Person
// var where2 []builder.WhereItem
// where2 = append(where2, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
// err := aorm.Use(db).Debug(false).
// Table("person").
// WhereArr(where2).
// Page(3, 10).
// Driver(driver).
// OrderBy("id", "DESC").
// GetMany(&list4)
// if err != nil {
// panic(driver + "testPage" + "found err")
// }
//}
sub := aorm.Sub().Table("article").SelectCount("id", "article_count_tem").WhereRaw("person_id", "=person.id")
err := aorm.Use(db).Debug(false).
Driver(driver).
SelectExp(&sub, "article_count").
Select("*").
Where(&Person{Age: null.IntFrom(18)}).
GetMany(&listByFiled)
//func testLock(driver string, db *sql.DB, id int64) {
// if driver == model.Sqlite3 || driver == model.Mssql {
// return
// }
//
// var itemByLock Person
// err := aorm.Use(db).
// Debug(false).
// LockForUpdate(true).
// Where(&Person{Id: null.IntFrom(id)}).
// Driver(driver).
// OrderBy("id", "DESC").
// GetOne(&itemByLock)
// if err != nil {
// panic(driver + "testLock" + "found err")
// }
//}
//
//func testIncrement(driver string, db *sql.DB, id int64) {
// _, err := aorm.Use(db).Debug(false).Where(&Person{Id: null.IntFrom(id)}).Driver(driver).Increment("age", 1)
// if err != nil {
// panic(driver + " testIncrement " + "found err:" + err.Error())
// }
//}
//
//func testDecrement(driver string, db *sql.DB, id int64) {
// _, err := aorm.Use(db).Debug(false).Where(&Person{Id: null.IntFrom(id)}).Driver(driver).Decrement("age", 2)
// if err != nil {
// panic(driver + "testDecrement" + "found err")
// }
//}
//
//func testValue(driver string, db *sql.DB, id int64) {
//
// var name string
// errName := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).Value("name", &name)
// if errName != nil {
// panic(driver + "testValue" + "found err")
// }
//
// var age int64
// errAge := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).Value("age", &age)
// if errAge != nil {
// panic(driver + "testValue" + "found err")
// }
//
// var money float32
// errMoney := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).Value("money", &money)
// if errMoney != nil {
// panic(driver + "testValue" + "found err")
// }
//
// var test float64
// errTest := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).Value("test", &test)
// if errTest != nil {
// panic(driver + "testValue" + "found err")
// }
//}
//
//func testPluck(driver string, db *sql.DB) {
//
// var nameList []string
// errNameList := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Type: null.IntFrom(0)}).Limit(0, 3).Pluck("name", &nameList)
// if errNameList != nil {
// panic(driver + "testPluck" + "found err")
// }
//
// var ageList []int64
// errAgeList := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Type: null.IntFrom(0)}).Limit(0, 3).Pluck("age", &ageList)
// if errAgeList != nil {
// panic(driver + "testPluck" + "found err:" + errAgeList.Error())
// }
//
// var moneyList []float32
// errMoneyList := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Type: null.IntFrom(0)}).Limit(0, 3).Pluck("money", &moneyList)
// if errMoneyList != nil {
// panic(driver + "testPluck" + "found err")
// }
//
// var testList []float64
// errTestList := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Type: null.IntFrom(0)}).Limit(0, 3).Pluck("test", &testList)
// if errTestList != nil {
// panic(driver + "testPluck" + "found err")
// }
//}
//
//func testCount(driver string, db *sql.DB) {
// _, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Count("*")
// if err != nil {
// panic(driver + "testCount" + "found err")
// }
//}
//
//func testSum(driver string, db *sql.DB) {
// _, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Sum("age")
// if err != nil {
// panic(driver + "testSum" + "found err")
// }
//}
//
//func testAvg(driver string, db *sql.DB) {
// _, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Avg("age")
// if err != nil {
// panic(driver + "testAvg" + "found err")
// }
//}
//
//func testMin(driver string, db *sql.DB) {
// _, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Min("age")
// if err != nil {
// panic(driver + "testMin" + "found err")
// }
//}
//
//func testMax(driver string, db *sql.DB) {
// _, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Max("age")
// if err != nil {
// panic(driver + "testMax" + "found err")
// }
//}
//
//func testExec(driver string, db *sql.DB) {
// _, err := aorm.Use(db).Debug(false).Driver(driver).Exec("UPDATE person SET name = ? WHERE id=?", "Bob", 3)
// if err != nil {
// panic(driver + "testExec" + "found err")
// }
//}
//
//func testTransaction(driver string, db *sql.DB) {
// tx, _ := db.Begin()
//
// id, errInsert := aorm.Use(tx).Debug(false).Driver(driver).Insert(&Person{
// Name: null.StringFrom("Alice"),
// })
//
// if errInsert != nil {
// tx.Rollback()
// panic(driver + " testTransaction " + "found err:" + errInsert.Error())
// return
// }
//
// _, errCount := aorm.Use(tx).Debug(false).Driver(driver).Where(&Person{
// Id: null.IntFrom(id),
// }).Count("*")
// if errCount != nil {
// tx.Rollback()
// panic(driver + "testTransaction" + "found err")
// return
// }
//
// var person Person
// errPerson := aorm.Use(tx).Debug(false).Where(&Person{
// Id: null.IntFrom(id),
// }).Driver(driver).OrderBy("id", "DESC").GetOne(&person)
// if errPerson != nil {
// tx.Rollback()
// panic(driver + "testTransaction" + "found err")
// return
// }
//
// _, errUpdate := aorm.Use(tx).Debug(false).Driver(driver).Where(&Person{
// Id: null.IntFrom(id),
// }).Update(&Person{
// Name: null.StringFrom("Bob"),
// })
//
// if errUpdate != nil {
// tx.Rollback()
// panic(driver + "testTransaction" + "found err")
// return
// }
//
// tx.Commit()
//}
//
//func testTruncate(driver string, db *sql.DB) {
// _, err := aorm.Use(db).Debug(false).Driver(driver).Table("person").Truncate()
// if err != nil {
// panic(driver + " testTruncate " + "found err")
// }
//}
if err != nil {
panic(driver + " testSelectWithSub " + "found err:" + err.Error())
}
}
func testWhereWithSub(driver string, db *sql.DB) {
var listByFiled []Person
sub := aorm.Sub().Table("article").Select("person_id").GroupBy("person_id").HavingGt("count(person_id)", 0)
err := aorm.Use(db).Debug(false).
Table("person").
Driver(driver).
WhereIn("id", &sub).
GetMany(&listByFiled)
if err != nil {
panic(driver + " testWhereWithSub " + "found err:" + err.Error())
}
}
func testWhere(driver string, db *sql.DB) {
var listByWhere []Person
var where1 []builder.WhereItem
where1 = append(where1, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
where1 = append(where1, builder.WhereItem{Field: "age", Opt: builder.In, Val: []int{18, 20}})
where1 = append(where1, builder.WhereItem{Field: "money", Opt: builder.Between, Val: []float64{100.1, 200.9}})
where1 = append(where1, builder.WhereItem{Field: "money", Opt: builder.Eq, Val: 100.15})
where1 = append(where1, builder.WhereItem{Field: "name", Opt: builder.Like, Val: []string{"%", "li", "%"}})
err := aorm.Use(db).Debug(false).Driver(driver).Table("person").WhereArr(where1).GetMany(&listByWhere)
if err != nil {
panic(driver + "testWhere" + "found err")
}
}
func testJoin(driver string, db *sql.DB) {
var list2 []ArticleVO
var where2 []builder.WhereItem
where2 = append(where2, builder.WhereItem{Field: "o.type", Opt: builder.Eq, Val: 0})
where2 = append(where2, builder.WhereItem{Field: "p.age", Opt: builder.In, Val: []int{18, 20}})
err := aorm.Use(db).Debug(false).
Table("article o").
LeftJoin("person p", "p.id=o.person_id").
Select("o.*").
Select("p.name as person_name").
WhereArr(where2).
Driver(driver).
GetMany(&list2)
if err != nil {
panic(driver + " testWhere " + "found err " + err.Error())
}
}
func testGroupBy(driver string, db *sql.DB) {
var personAge PersonAge
var where []builder.WhereItem
where = append(where, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
err := aorm.Use(db).Debug(false).
Table("person").
Select("age").
Select("count(age) as age_count").
GroupBy("age").
WhereArr(where).
Driver(driver).
OrderBy("age", "DESC").
GetOne(&personAge)
if err != nil {
panic(driver + "testGroupBy" + "found err")
}
}
func testHaving(driver string, db *sql.DB) {
var listByHaving []PersonAge
var where3 []builder.WhereItem
where3 = append(where3, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
var having []builder.WhereItem
having = append(having, builder.WhereItem{Field: "count(age)", Opt: builder.Gt, Val: 4})
err := aorm.Use(db).Debug(false).
Table("person").
Select("age").
Select("count(age) as age_count").
GroupBy("age").
WhereArr(where3).
Driver(driver).
OrderBy("age", "DESC").
HavingArr(having).
GetMany(&listByHaving)
if err != nil {
panic(driver + " testHaving " + "found err")
}
}
func testOrderBy(driver string, db *sql.DB) {
var listByOrder []Person
var where []builder.WhereItem
where = append(where, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
err := aorm.Use(db).Debug(false).
Table("person").
WhereArr(where).
OrderBy("age", builder.Desc).
Driver(driver).
GetMany(&listByOrder)
if err != nil {
panic(driver + "testOrderBy" + "found err")
}
}
func testLimit(driver string, db *sql.DB) {
var list3 []Person
var where1 []builder.WhereItem
where1 = append(where1, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
err1 := aorm.Use(db).Debug(false).
Table("person").
WhereArr(where1).
Limit(50, 10).
Driver(driver).
OrderBy("id", "DESC").
GetMany(&list3)
if err1 != nil {
panic(driver + "testLimit" + "found err")
}
var list4 []Person
var where2 []builder.WhereItem
where2 = append(where2, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0})
err := aorm.Use(db).Debug(false).
Table("person").
WhereArr(where2).
Page(3, 10).
Driver(driver).
OrderBy("id", "DESC").
GetMany(&list4)
if err != nil {
panic(driver + "testPage" + "found err")
}
}
func testLock(driver string, db *sql.DB, id int64) {
if driver == model.Sqlite3 || driver == model.Mssql {
return
}
var itemByLock Person
err := aorm.Use(db).
Debug(false).
LockForUpdate(true).
Where(&Person{Id: null.IntFrom(id)}).
Driver(driver).
OrderBy("id", "DESC").
GetOne(&itemByLock)
if err != nil {
panic(driver + "testLock" + "found err")
}
}
func testIncrement(driver string, db *sql.DB, id int64) {
_, err := aorm.Use(db).Debug(false).Where(&Person{Id: null.IntFrom(id)}).Driver(driver).Increment("age", 1)
if err != nil {
panic(driver + " testIncrement " + "found err:" + err.Error())
}
}
func testDecrement(driver string, db *sql.DB, id int64) {
_, err := aorm.Use(db).Debug(false).Where(&Person{Id: null.IntFrom(id)}).Driver(driver).Decrement("age", 2)
if err != nil {
panic(driver + "testDecrement" + "found err")
}
}
func testValue(driver string, db *sql.DB, id int64) {
var name string
errName := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).Value("name", &name)
if errName != nil {
panic(driver + "testValue" + "found err")
}
var age int64
errAge := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).Value("age", &age)
if errAge != nil {
panic(driver + "testValue" + "found err")
}
var money float32
errMoney := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).Value("money", &money)
if errMoney != nil {
panic(driver + "testValue" + "found err")
}
var test float64
errTest := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Id: null.IntFrom(id)}).Value("test", &test)
if errTest != nil {
panic(driver + "testValue" + "found err")
}
}
func testPluck(driver string, db *sql.DB) {
var nameList []string
errNameList := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Type: null.IntFrom(0)}).Limit(0, 3).Pluck("name", &nameList)
if errNameList != nil {
panic(driver + "testPluck" + "found err")
}
var ageList []int64
errAgeList := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Type: null.IntFrom(0)}).Limit(0, 3).Pluck("age", &ageList)
if errAgeList != nil {
panic(driver + "testPluck" + "found err:" + errAgeList.Error())
}
var moneyList []float32
errMoneyList := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Type: null.IntFrom(0)}).Limit(0, 3).Pluck("money", &moneyList)
if errMoneyList != nil {
panic(driver + "testPluck" + "found err")
}
var testList []float64
errTestList := aorm.Use(db).Debug(false).Driver(driver).OrderBy("id", "DESC").Where(&Person{Type: null.IntFrom(0)}).Limit(0, 3).Pluck("test", &testList)
if errTestList != nil {
panic(driver + "testPluck" + "found err")
}
}
func testCount(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Count("*")
if err != nil {
panic(driver + "testCount" + "found err")
}
}
func testSum(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Sum("age")
if err != nil {
panic(driver + "testSum" + "found err")
}
}
func testAvg(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Avg("age")
if err != nil {
panic(driver + "testAvg" + "found err")
}
}
func testMin(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Min("age")
if err != nil {
panic(driver + "testMin" + "found err")
}
}
func testMax(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(false).Where(&Person{Age: null.IntFrom(18)}).Driver(driver).Max("age")
if err != nil {
panic(driver + "testMax" + "found err")
}
}
func testExec(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(false).Driver(driver).Exec("UPDATE person SET name = ? WHERE id=?", "Bob", 3)
if err != nil {
panic(driver + "testExec" + "found err")
}
}
func testTransaction(driver string, db *sql.DB) {
tx, _ := db.Begin()
id, errInsert := aorm.Use(tx).Debug(false).Driver(driver).Insert(&Person{
Name: null.StringFrom("Alice"),
})
if errInsert != nil {
tx.Rollback()
panic(driver + " testTransaction " + "found err:" + errInsert.Error())
return
}
_, errCount := aorm.Use(tx).Debug(false).Driver(driver).Where(&Person{
Id: null.IntFrom(id),
}).Count("*")
if errCount != nil {
tx.Rollback()
panic(driver + "testTransaction" + "found err")
return
}
var person Person
errPerson := aorm.Use(tx).Debug(false).Where(&Person{
Id: null.IntFrom(id),
}).Driver(driver).OrderBy("id", "DESC").GetOne(&person)
if errPerson != nil {
tx.Rollback()
panic(driver + "testTransaction" + "found err")
return
}
_, errUpdate := aorm.Use(tx).Debug(false).Driver(driver).Where(&Person{
Id: null.IntFrom(id),
}).Update(&Person{
Name: null.StringFrom("Bob"),
})
if errUpdate != nil {
tx.Rollback()
panic(driver + "testTransaction" + "found err")
return
}
tx.Commit()
}
func testTruncate(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(false).Driver(driver).Table("person").Truncate()
if err != nil {
panic(driver + " testTruncate " + "found err")
}
}
func testHelper(driver string, db *sql.DB) {
var list2 []ArticleVO
var where2 []builder.WhereItem
where2 = append(where2, builder.WhereItem{Field: "o.type", Opt: builder.Eq, Val: 0})
where2 = append(where2, builder.WhereItem{Field: "p.age", Opt: builder.In, Val: []int{18, 20}})
err := aorm.Use(db).Debug(false).
Table("article o").
LeftJoin("person p", helper.Ul("p.id=o.personId")).
Select("o.*").
Select(helper.Ul("p.name as personName")).
WhereArr(where2).
Driver(driver).
GetMany(&list2)
if err != nil {
panic(driver + "testHelper" + "found err")
}
}
//func testHelper(driver string, db *sql.DB) {
// var list2 []ArticleVO
// var where2 []builder.WhereItem
// where2 = append(where2, builder.WhereItem{Field: "o.type", Opt: builder.Eq, Val: 0})
// where2 = append(where2, builder.WhereItem{Field: "p.age", Opt: builder.In, Val: []int{18, 20}})
// err := aorm.Use(db).Debug(false).
// Table("article o").
// LeftJoin("person p", helper.Ul("p.id=o.personId")).
// Select("o.*").
// Select(helper.Ul("p.name as personName")).
// WhereArr(where2).
// Driver(driver).
// GetMany(&list2)
// if err != nil {
// panic(driver + "testHelper" + "found err")
// }
//}