package/aorm
1
0
Fork 0
mirror of https://github.com/tangpanqing/aorm.git synced 2025-10-15 20:30:40 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

new test

Browse Source
This commit is contained in:
tangpanqing
2023-01-06 14:03:48 +08:00
parent 9beffba8ed
commit 9f9a7c975f
8 changed files with 445 additions and 502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
builder/aggregation.go
View File

@@ -11,9 +11,9 @@ type FloatStruct struct {
} }
// Count 聚合函数-数量 // Count 聚合函数-数量
func (ex *Builder) Count(fieldName string) (int64, error) { func (b *Builder) Count(fieldName string) (int64, error) {
var obj []IntStruct var obj []IntStruct
err := ex.SelectCount(fieldName, "c", "").GetMany(&obj) err := b.SelectCount(fieldName, "c", "").GetMany(&obj)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -22,9 +22,9 @@ func (ex *Builder) Count(fieldName string) (int64, error) {
} }
// Sum 聚合函数-合计 // Sum 聚合函数-合计
func (ex *Builder) Sum(fieldName interface{}) (float64, error) { func (b *Builder) Sum(fieldName interface{}) (float64, error) {
var obj []FloatStruct var obj []FloatStruct
err := ex.SelectSum(fieldName, "c").GetMany(&obj) err := b.SelectSum(fieldName, "c").GetMany(&obj)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -33,9 +33,9 @@ func (ex *Builder) Sum(fieldName interface{}) (float64, error) {
} }
// Avg 聚合函数-平均值 // Avg 聚合函数-平均值
func (ex *Builder) Avg(fieldName interface{}) (float64, error) { func (b *Builder) Avg(fieldName interface{}) (float64, error) {
var obj []FloatStruct var obj []FloatStruct
err := ex.SelectAvg(fieldName, "c").GetMany(&obj) err := b.SelectAvg(fieldName, "c").GetMany(&obj)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -44,9 +44,9 @@ func (ex *Builder) Avg(fieldName interface{}) (float64, error) {
} }
// Max 聚合函数-最大值 // Max 聚合函数-最大值
func (ex *Builder) Max(fieldName interface{}) (float64, error) { func (b *Builder) Max(fieldName interface{}) (float64, error) {
var obj []FloatStruct var obj []FloatStruct
err := ex.SelectMax(fieldName, "c").GetMany(&obj) err := b.SelectMax(fieldName, "c").GetMany(&obj)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -55,9 +55,9 @@ func (ex *Builder) Max(fieldName interface{}) (float64, error) {
} }
// Min 聚合函数-最小值 // Min 聚合函数-最小值
func (ex *Builder) Min(fieldName interface{}) (float64, error) { func (b *Builder) Min(fieldName interface{}) (float64, error) {
var obj []FloatStruct var obj []FloatStruct
err := ex.SelectMin(fieldName, "c").GetMany(&obj) err := b.SelectMin(fieldName, "c").GetMany(&obj)
if err != nil { if err != nil {
return 0, err return 0, err
} }

12
builder/builder.go
View File

@@ -7,7 +7,6 @@ import (
"unicode" "unicode"
) )
var RawEq = "rawEq"
var TableMap = make(map[uintptr]string) var TableMap = make(map[uintptr]string)
var FieldMap = make(map[uintptr]FieldInfo) var FieldMap = make(map[uintptr]FieldInfo)
@@ -22,7 +21,6 @@ type GroupItem struct {
} }
type WhereItem struct { type WhereItem struct {
FuncName string
Prefix string Prefix string
Field interface{} Field interface{}
Opt string Opt string
@@ -185,9 +183,15 @@ func getTableNameByTable(table interface{}) string {
if table == nil { if table == nil {
panic("当前table不能是nil") panic("当前table不能是nil")
} }
tableName := TableMap[reflect.ValueOf(table).Pointer()]
valueOf := reflect.ValueOf(table)
if reflect.Ptr == valueOf.Kind() {
tableName := TableMap[valueOf.Pointer()]
strArr := strings.Split(tableName, ".") strArr := strings.Split(tableName, ".")
return UnderLine(strArr[len(strArr)-1]) return UnderLine(strArr[len(strArr)-1])
} else {
return fmt.Sprintf("%v", table)
}
} }
func getTableNameByField(field interface{}) string { func getTableNameByField(field interface{}) string {
@@ -244,7 +248,7 @@ func getWhereStr(whereList []WhereItem, paramList []interface{}) (string, []inte
paramList = append(paramList, whereList[i].Val) paramList = append(paramList, whereList[i].Val)
} }
if whereList[i].Opt == "rawEq" { if whereList[i].Opt == RawEq {
value := getFieldName(whereList[i].Val) value := getFieldName(whereList[i].Val)
sqlList = append(sqlList, prefix+"."+field+"="+value) sqlList = append(sqlList, prefix+"."+field+"="+value)
} }

303
builder/crud.go
View File

@@ -32,12 +32,13 @@ const Between = "BETWEEN"
const NotBetween = "NOT BETWEEN" const NotBetween = "NOT BETWEEN"
const Raw = "Raw" const Raw = "Raw"
const RawEq = "RawEq"
// SelectItem 将某子语句重命名为某字段 // SelectExpItem 将某子语句重命名为某字段
//type SelectItem struct { type SelectExpItem struct {
// Executor **Builder Executor **Builder
// FieldName string FieldName interface{}
//} }
// Builder 查询记录所需要的条件 // Builder 查询记录所需要的条件
type Builder struct { type Builder struct {
@@ -50,7 +51,7 @@ type Builder struct {
//查询参数 //查询参数
tableName string tableName string
selectList []SelectItem selectList []SelectItem
selectExpList []*SelectItem selectExpList []*SelectExpItem
groupList []GroupItem groupList []GroupItem
whereList []WhereItem whereList []WhereItem
joinList []JoinItem joinList []JoinItem
@@ -58,6 +59,7 @@ type Builder struct {
orderList []OrderItem orderList []OrderItem
offset int offset int
pageSize int pageSize int
distinct bool
isDebug bool isDebug bool
isLockForUpdate bool isLockForUpdate bool
@@ -69,27 +71,29 @@ type Builder struct {
driverName string driverName string
} }
//type WhereItem struct { func (b *Builder) Distinct(distinct bool) *Builder {
// Field string b.distinct = distinct
// Opt string return b
// Val any }
//}
func (ex *Builder) Driver(driverName string) *Builder { func (b *Builder) Driver(driverName string) *Builder {
ex.driverName = driverName b.driverName = driverName
return ex return b
}
func (b *Builder) getTableNameCommon(typeOf reflect.Type, valueOf reflect.Value) string {
if b.table != nil {
return getTableNameByTable(b.table)
}
return getTableName(typeOf, valueOf)
} }
// Insert 增加记录 // Insert 增加记录
func (ex *Builder) Insert(dest interface{}) (int64, error) { func (b *Builder) Insert(dest interface{}) (int64, error) {
typeOf := reflect.TypeOf(dest) typeOf := reflect.TypeOf(dest)
valueOf := reflect.ValueOf(dest) valueOf := reflect.ValueOf(dest)
//如果没有设置表名
if ex.tableName == "" {
ex.tableName = getTableName(typeOf, valueOf)
}
var keys []string var keys []string
var paramList []any var paramList []any
var place []string var place []string
@@ -104,24 +108,24 @@ func (ex *Builder) Insert(dest interface{}) (int64, error) {
} }
} }
sqlStr := "INSERT INTO " + ex.tableName + " (" + strings.Join(keys, ",") + ") VALUES (" + strings.Join(place, ",") + ")" sqlStr := "INSERT INTO " + b.getTableNameCommon(typeOf, valueOf) + " (" + strings.Join(keys, ",") + ") VALUES (" + strings.Join(place, ",") + ")"
if ex.driverName == model.Postgres { if b.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr) sqlStr = convertToPostgresSql(sqlStr)
} }
if ex.driverName == model.Mssql { if b.driverName == model.Mssql {
return ex.insertForMssqlOrPostgres(sqlStr+"; select ID = convert(bigint, SCOPE_IDENTITY())", paramList...) return b.insertForMssqlOrPostgres(sqlStr+"; select ID = convert(bigint, SCOPE_IDENTITY())", paramList...)
} else if ex.driverName == model.Postgres { } else if b.driverName == model.Postgres {
return ex.insertForMssqlOrPostgres(sqlStr+" returning id", paramList...) return b.insertForMssqlOrPostgres(sqlStr+" returning id", paramList...)
} else { } else {
return ex.insertForCommon(sqlStr, paramList...) return b.insertForCommon(sqlStr, paramList...)
} }
} }
//对于Mssql,Postgres类型数据库，为了获取最后插入的id，需要改写入为查询 //对于Mssql,Postgres类型数据库，为了获取最后插入的id，需要改写入为查询
func (ex *Builder) insertForMssqlOrPostgres(sql string, paramList ...any) (int64, error) { func (b *Builder) insertForMssqlOrPostgres(sql string, paramList ...any) (int64, error) {
rows, err := ex.LinkCommon.Query(sql, paramList...) rows, err := b.LinkCommon.Query(sql, paramList...)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -134,8 +138,8 @@ func (ex *Builder) insertForMssqlOrPostgres(sql string, paramList ...any) (int64
} }
//对于非Mssql,Postgres类型数据库，可以直接获取最后插入的id //对于非Mssql,Postgres类型数据库，可以直接获取最后插入的id
func (ex *Builder) insertForCommon(sql string, paramList ...any) (int64, error) { func (b *Builder) insertForCommon(sql string, paramList ...any) (int64, error) {
res, err := ex.Exec(sql, paramList...) res, err := b.Exec(sql, paramList...)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -163,7 +167,7 @@ func convertToPostgresSql(sqlStr string) string {
} }
// InsertBatch 批量增加记录 // InsertBatch 批量增加记录
func (ex *Builder) InsertBatch(values interface{}) (int64, error) { func (b *Builder) InsertBatch(values interface{}) (int64, error) {
var keys []string var keys []string
var paramList []any var paramList []any
@@ -175,11 +179,6 @@ func (ex *Builder) InsertBatch(values interface{}) (int64, error) {
} }
typeOf := reflect.TypeOf(values).Elem().Elem() typeOf := reflect.TypeOf(values).Elem().Elem()
//如果没有设置表名
if ex.tableName == "" {
ex.tableName = getTableName(typeOf, valueOf.Index(0))
}
for j := 0; j < valueOf.Len(); j++ { for j := 0; j < valueOf.Len(); j++ {
var placeItem []string var placeItem []string
@@ -200,13 +199,13 @@ func (ex *Builder) InsertBatch(values interface{}) (int64, error) {
place = append(place, "("+strings.Join(placeItem, ",")+")") place = append(place, "("+strings.Join(placeItem, ",")+")")
} }
sqlStr := "INSERT INTO " + ex.tableName + " (" + strings.Join(keys, ",") + ") VALUES " + strings.Join(place, ",") sqlStr := "INSERT INTO " + b.getTableNameCommon(typeOf, valueOf.Index(0)) + " (" + strings.Join(keys, ",") + ") VALUES " + strings.Join(place, ",")
if ex.driverName == model.Postgres { if b.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr) sqlStr = convertToPostgresSql(sqlStr)
} }
res, err := ex.Exec(sqlStr, paramList...) res, err := b.Exec(sqlStr, paramList...)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -220,10 +219,10 @@ func (ex *Builder) InsertBatch(values interface{}) (int64, error) {
} }
// GetRows 获取行操作 // GetRows 获取行操作
func (ex *Builder) GetRows() (*sql.Rows, error) { func (b *Builder) GetRows() (*sql.Rows, error) {
sqlStr, paramList := ex.GetSqlAndParams() sqlStr, paramList := b.GetSqlAndParams()
smt, errSmt := ex.LinkCommon.Prepare(sqlStr) smt, errSmt := b.LinkCommon.Prepare(sqlStr)
if errSmt != nil { if errSmt != nil {
return nil, errSmt return nil, errSmt
} }
@@ -238,8 +237,8 @@ func (ex *Builder) GetRows() (*sql.Rows, error) {
} }
// GetMany 查询记录(新) // GetMany 查询记录(新)
func (ex *Builder) GetMany(values interface{}) error { func (b *Builder) GetMany(values interface{}) error {
rows, errRows := ex.GetRows() rows, errRows := b.GetRows()
defer rows.Close() defer rows.Close()
if errRows != nil { if errRows != nil {
return errRows return errRows
@@ -273,10 +272,10 @@ func (ex *Builder) GetMany(values interface{}) error {
} }
// GetOne 查询某一条记录 // GetOne 查询某一条记录
func (ex *Builder) GetOne(obj interface{}) error { func (b *Builder) GetOne(obj interface{}) error {
ex.Limit(0, 1) b.Limit(0, 1)
rows, errRows := ex.GetRows() rows, errRows := b.GetRows()
defer rows.Close() defer rows.Close()
if errRows != nil { if errRows != nil {
return errRows return errRows
@@ -306,35 +305,35 @@ func (ex *Builder) GetOne(obj interface{}) error {
} }
// RawSql 执行原始的sql语句 // RawSql 执行原始的sql语句
func (ex *Builder) RawSql(sql string, paramList ...interface{}) *Builder { func (b *Builder) RawSql(sql string, paramList ...interface{}) *Builder {
ex.sql = sql b.sql = sql
ex.paramList = paramList b.paramList = paramList
return ex return b
} }
func (ex *Builder) GetSqlAndParams() (string, []interface{}) { func (b *Builder) GetSqlAndParams() (string, []interface{}) {
if ex.sql != "" { if b.sql != "" {
return ex.sql, ex.paramList return b.sql, b.paramList
} }
var paramList []interface{} var paramList []interface{}
tableName := getTableNameByTable(ex.table) tableName := getTableNameByTable(b.table)
fieldStr, paramList := ex.handleField(paramList) fieldStr, paramList := b.handleField(paramList)
whereStr, paramList := ex.handleWhere(paramList) whereStr, paramList := b.handleWhere(paramList)
joinStr, paramList := ex.handleJoin(paramList) joinStr, paramList := b.handleJoin(paramList)
groupStr, paramList := ex.handleGroup(paramList) groupStr, paramList := b.handleGroup(paramList)
havingStr, paramList := ex.handleHaving(paramList) havingStr, paramList := b.handleHaving(paramList)
orderStr, paramList := ex.handleOrder(paramList) orderStr, paramList := b.handleOrder(paramList)
limitStr, paramList := ex.handleLimit(ex.offset, ex.pageSize, paramList) limitStr, paramList := b.handleLimit(b.offset, b.pageSize, paramList)
lockStr := handleLockForUpdate(ex.isLockForUpdate) lockStr := handleLockForUpdate(b.isLockForUpdate)
sqlStr := "SELECT " + fieldStr + " FROM " + tableName + " " + ex.tableAlias + joinStr + whereStr + groupStr + havingStr + orderStr + limitStr + lockStr sqlStr := "SELECT " + fieldStr + " FROM " + tableName + " " + b.tableAlias + joinStr + whereStr + groupStr + havingStr + orderStr + limitStr + lockStr
if ex.driverName == model.Postgres { if b.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr) sqlStr = convertToPostgresSql(sqlStr)
} }
if ex.isDebug { if b.isDebug {
fmt.Println(sqlStr) fmt.Println(sqlStr)
//fmt.Println(paramList...) //fmt.Println(paramList...)
} }
@@ -343,47 +342,64 @@ func (ex *Builder) GetSqlAndParams() (string, []interface{}) {
} }
// Update 更新记录 // Update 更新记录
func (ex *Builder) Update(dest interface{}) (int64, error) { func (b *Builder) Update(dest interface{}) (int64, error) {
var paramList []any typeOf := reflect.TypeOf(dest)
setStr, paramList := ex.handleSet(dest, paramList) valueOf := reflect.ValueOf(dest)
whereStr, paramList := ex.handleWhere(paramList)
sqlStr := "UPDATE " + ex.tableName + setStr + whereStr
if ex.driverName == model.Postgres { var paramList []any
setStr, paramList := b.handleSet(typeOf, valueOf, paramList)
whereStr, paramList := b.handleWhere(paramList)
sqlStr := "UPDATE " + b.getTableNameCommon(typeOf, valueOf) + setStr + whereStr
if b.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr) sqlStr = convertToPostgresSql(sqlStr)
} }
return ex.ExecAffected(sqlStr, paramList...) return b.ExecAffected(sqlStr, paramList...)
} }
// Delete 删除记录 // Delete 删除记录
func (ex *Builder) Delete() (int64, error) { func (b *Builder) Delete(destList ...interface{}) (int64, error) {
var paramList []any tableName := ""
whereStr, paramList := ex.handleWhere(paramList)
sqlStr := "DELETE FROM " + getTableNameByTable(ex.table) + whereStr
if ex.driverName == model.Postgres { if len(destList) > 0 {
b.Where(destList[0])
typeOf := reflect.TypeOf(destList[0])
valueOf := reflect.ValueOf(destList[0])
tableName = b.getTableNameCommon(typeOf, valueOf)
}
if tableName == "" {
tableName = getTableNameByTable(b.table)
}
var paramList []any
whereStr, paramList := b.handleWhere(paramList)
sqlStr := "DELETE FROM " + tableName + whereStr
if b.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr) sqlStr = convertToPostgresSql(sqlStr)
} }
return ex.ExecAffected(sqlStr, paramList...) return b.ExecAffected(sqlStr, paramList...)
} }
// Truncate 清空记录, sqlite3不支持此操作 // Truncate 清空记录, sqlite3不支持此操作
func (ex *Builder) Truncate() (int64, error) { func (b *Builder) Truncate() (int64, error) {
sqlStr := "TRUNCATE TABLE " + ex.tableName sqlStr := "TRUNCATE TABLE " + getTableNameByTable(b.table)
if ex.driverName == model.Sqlite3 { if b.driverName == model.Sqlite3 {
sqlStr = "DELETE FROM " + ex.tableName sqlStr = "DELETE FROM " + getTableNameByTable(b.table)
} }
return ex.ExecAffected(sqlStr) return b.ExecAffected(sqlStr)
} }
// Exists 存在某记录 // Exists 存在某记录
func (ex *Builder) Exists() (bool, error) { func (b *Builder) Exists() (bool, error) {
var obj IntStruct var obj IntStruct
err := ex.selectCommon("", "1 as c", nil, "").Limit(0, 1).GetOne(&obj) err := b.selectCommon("", "1 as c", nil, "").Limit(0, 1).GetOne(&obj)
if err != nil { if err != nil {
return false, err return false, err
} }
@@ -396,18 +412,18 @@ func (ex *Builder) Exists() (bool, error) {
} }
// DoesntExist 不存在某记录 // DoesntExist 不存在某记录
func (ex *Builder) DoesntExist() (bool, error) { func (b *Builder) DoesntExist() (bool, error) {
isE, err := ex.Exists() isE, err := b.Exists()
return !isE, err return !isE, err
} }
// Value 字段值 // Value 字段值
func (ex *Builder) Value(field interface{}, dest interface{}) error { func (b *Builder) Value(field interface{}, dest interface{}) error {
ex.Select(field).Limit(0, 1) b.Select(field).Limit(0, 1)
fieldName := getFieldName(field) fieldName := getFieldName(field)
rows, errRows := ex.GetRows() rows, errRows := b.GetRows()
defer rows.Close() defer rows.Close()
if errRows != nil { if errRows != nil {
return errRows return errRows
@@ -442,10 +458,10 @@ func (ex *Builder) Value(field interface{}, dest interface{}) error {
} }
// Pluck 获取某一列的值 // Pluck 获取某一列的值
func (ex *Builder) Pluck(fieldName interface{}, values interface{}) error { func (b *Builder) Pluck(fieldName interface{}, values interface{}) error {
ex.Select(fieldName) b.Select(fieldName)
rows, errRows := ex.GetRows() rows, errRows := b.GetRows()
defer rows.Close() defer rows.Close()
if errRows != nil { if errRows != nil {
return errRows return errRows
@@ -484,45 +500,45 @@ func (ex *Builder) Pluck(fieldName interface{}, values interface{}) error {
} }
// Increment 某字段自增 // Increment 某字段自增
func (ex *Builder) Increment(field interface{}, step int) (int64, error) { func (b *Builder) Increment(field interface{}, step int) (int64, error) {
var paramList []any var paramList []any
paramList = append(paramList, step) paramList = append(paramList, step)
whereStr, paramList := ex.handleWhere(paramList) whereStr, paramList := b.handleWhere(paramList)
sqlStr := "UPDATE " + getTableNameByTable(ex.table) + " SET " + getFieldName(field) + "=" + getFieldName(field) + "+?" + whereStr sqlStr := "UPDATE " + getTableNameByTable(b.table) + " SET " + getFieldName(field) + "=" + getFieldName(field) + "+?" + whereStr
if ex.driverName == model.Postgres { if b.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr) sqlStr = convertToPostgresSql(sqlStr)
} }
return ex.ExecAffected(sqlStr, paramList...) return b.ExecAffected(sqlStr, paramList...)
} }
// Decrement 某字段自减 // Decrement 某字段自减
func (ex *Builder) Decrement(field interface{}, step int) (int64, error) { func (b *Builder) Decrement(field interface{}, step int) (int64, error) {
var paramList []any var paramList []any
paramList = append(paramList, step) paramList = append(paramList, step)
whereStr, paramList := ex.handleWhere(paramList) whereStr, paramList := b.handleWhere(paramList)
sqlStr := "UPDATE " + getTableNameByTable(ex.table) + " SET " + getFieldName(field) + "=" + getFieldName(field) + "-?" + whereStr sqlStr := "UPDATE " + getTableNameByTable(b.table) + " SET " + getFieldName(field) + "=" + getFieldName(field) + "-?" + whereStr
if ex.driverName == model.Postgres { if b.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr) sqlStr = convertToPostgresSql(sqlStr)
} }
return ex.ExecAffected(sqlStr, paramList...) return b.ExecAffected(sqlStr, paramList...)
} }
// Exec 通用执行-新增,更新,删除 // Exec 通用执行-新增,更新,删除
func (ex *Builder) Exec(sqlStr string, args ...interface{}) (sql.Result, error) { func (b *Builder) Exec(sqlStr string, args ...interface{}) (sql.Result, error) {
if ex.driverName == model.Postgres { if b.driverName == model.Postgres {
sqlStr = convertToPostgresSql(sqlStr) sqlStr = convertToPostgresSql(sqlStr)
} }
if ex.isDebug { if b.isDebug {
fmt.Println(sqlStr) fmt.Println(sqlStr)
//fmt.Println(args...) //fmt.Println(args...)
} }
smt, err1 := ex.LinkCommon.Prepare(sqlStr) smt, err1 := b.LinkCommon.Prepare(sqlStr)
if err1 != nil { if err1 != nil {
return nil, err1 return nil, err1
} }
@@ -533,13 +549,13 @@ func (ex *Builder) Exec(sqlStr string, args ...interface{}) (sql.Result, error)
return nil, err2 return nil, err2
} }
//ex.clear() //b.clear()
return res, nil return res, nil
} }
// ExecAffected 通用执行-更新,删除 // ExecAffected 通用执行-更新,删除
func (ex *Builder) ExecAffected(sqlStr string, args ...interface{}) (int64, error) { func (b *Builder) ExecAffected(sqlStr string, args ...interface{}) (int64, error) {
res, err := ex.Exec(sqlStr, args...) res, err := b.Exec(sqlStr, args...)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -553,9 +569,9 @@ func (ex *Builder) ExecAffected(sqlStr string, args ...interface{}) (int64, erro
} }
// Debug 链式操作-是否开启调试,打印sql // Debug 链式操作-是否开启调试,打印sql
func (ex *Builder) Debug(isDebug bool) *Builder { func (b *Builder) Debug(isDebug bool) *Builder {
ex.isDebug = isDebug b.isDebug = isDebug
return ex return b
} }
// Table 链式操作-从哪个表查询,允许直接写别名,例如 person p // Table 链式操作-从哪个表查询,允许直接写别名,例如 person p
@@ -568,12 +584,12 @@ func (b *Builder) Table(table interface{}, alias ...string) *Builder {
} }
// GroupBy 链式操作,以某字段进行分组 // GroupBy 链式操作,以某字段进行分组
func (ex *Builder) GroupBy(field interface{}, prefix ...string) *Builder { func (b *Builder) GroupBy(field interface{}, prefix ...string) *Builder {
ex.groupList = append(ex.groupList, GroupItem{ b.groupList = append(b.groupList, GroupItem{
Prefix: getPrefixByField(field, prefix...), Prefix: getPrefixByField(field, prefix...),
Field: field, Field: field,
}) })
return ex return b
} }
// OrderBy 链式操作,以某字段进行排序 // OrderBy 链式操作,以某字段进行排序
@@ -588,27 +604,27 @@ func (b *Builder) OrderBy(field interface{}, orderType string, prefix ...string)
} }
// Limit 链式操作,分页 // Limit 链式操作,分页
func (ex *Builder) Limit(offset int, pageSize int) *Builder { func (b *Builder) Limit(offset int, pageSize int) *Builder {
ex.offset = offset b.offset = offset
ex.pageSize = pageSize b.pageSize = pageSize
return ex return b
} }
// Page 链式操作,分页 // Page 链式操作,分页
func (ex *Builder) Page(pageNum int, pageSize int) *Builder { func (b *Builder) Page(pageNum int, pageSize int) *Builder {
ex.offset = (pageNum - 1) * pageSize b.offset = (pageNum - 1) * pageSize
ex.pageSize = pageSize b.pageSize = pageSize
return ex return b
} }
// LockForUpdate 加锁, sqlte3不支持此操作 // LockForUpdate 加锁, sqlte3不支持此操作
func (ex *Builder) LockForUpdate(isLockForUpdate bool) *Builder { func (b *Builder) LockForUpdate(isLockForUpdate bool) *Builder {
ex.isLockForUpdate = isLockForUpdate b.isLockForUpdate = isLockForUpdate
return ex return b
} }
//拼接SQL,查询与筛选通用操作 //拼接SQL,查询与筛选通用操作
func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string, []any) { func (b *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string, []any) {
var whereList []string var whereList []string
for i := 0; i < len(where); i++ { for i := 0; i < len(where); i++ {
allFieldName := "" allFieldName := ""
@@ -616,9 +632,6 @@ func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string,
allFieldName += where[i].Prefix + "." allFieldName += where[i].Prefix + "."
} }
allFieldName += getFieldName(where[i].Field) allFieldName += getFieldName(where[i].Field)
if where[i].FuncName != "" {
allFieldName = where[i].FuncName + "(" + allFieldName + ")"
}
if "**builder.Builder" == reflect.TypeOf(where[i].Val).String() { if "**builder.Builder" == reflect.TypeOf(where[i].Val).String() {
executor := *(**Builder)(unsafe.Pointer(reflect.ValueOf(where[i].Val).Pointer())) executor := *(**Builder)(unsafe.Pointer(reflect.ValueOf(where[i].Val).Pointer()))
@@ -627,19 +640,17 @@ func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string,
if where[i].Opt != Raw { if where[i].Opt != Raw {
whereList = append(whereList, allFieldName+" "+where[i].Opt+" "+"("+subSql+")") whereList = append(whereList, allFieldName+" "+where[i].Opt+" "+"("+subSql+")")
paramList = append(paramList, subParams...) paramList = append(paramList, subParams...)
} else {
} }
} else { } 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 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 { if b.driverName == model.Sqlite3 {
whereList = append(whereList, allFieldName+" "+where[i].Opt+" "+"?") whereList = append(whereList, allFieldName+" "+where[i].Opt+" "+"?")
} else { } else {
switch where[i].Val.(type) { switch where[i].Val.(type) {
case float32: case float32:
whereList = append(whereList, ex.getConcatForFloat(allFieldName, "''")+" "+where[i].Opt+" "+"?") whereList = append(whereList, b.getConcatForFloat(allFieldName, "''")+" "+where[i].Opt+" "+"?")
case float64: case float64:
whereList = append(whereList, ex.getConcatForFloat(allFieldName, "''")+" "+where[i].Opt+" "+"?") whereList = append(whereList, b.getConcatForFloat(allFieldName, "''")+" "+where[i].Opt+" "+"?")
default: default:
whereList = append(whereList, allFieldName+" "+where[i].Opt+" "+"?") whereList = append(whereList, allFieldName+" "+where[i].Opt+" "+"?")
} }
@@ -668,7 +679,7 @@ func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string,
} }
} }
whereList = append(whereList, allFieldName+" "+where[i].Opt+" "+ex.getConcatForLike(valueStr...)) whereList = append(whereList, allFieldName+" "+where[i].Opt+" "+b.getConcatForLike(valueStr...))
} }
if where[i].Opt == In || where[i].Opt == NotIn { if where[i].Opt == In || where[i].Opt == NotIn {
@@ -685,6 +696,10 @@ func (ex *Builder) whereAndHaving(where []WhereItem, paramList []any) ([]string,
if where[i].Opt == Raw { if where[i].Opt == Raw {
whereList = append(whereList, allFieldName+fmt.Sprintf("%v", where[i].Val)) whereList = append(whereList, allFieldName+fmt.Sprintf("%v", where[i].Val))
} }
if where[i].Opt == RawEq {
whereList = append(whereList, allFieldName+Eq+getPrefixByField(where[i].Val)+"."+getFieldName(where[i].Val))
}
} }
} }
return whereList, paramList return whereList, paramList
@@ -758,18 +773,18 @@ func getScans(columnNameList []string, fieldNameMap map[string]int, destValue re
return scans return scans
} }
func (ex *Builder) getConcatForFloat(vars ...string) string { func (b *Builder) getConcatForFloat(vars ...string) string {
if ex.driverName == model.Sqlite3 { if b.driverName == model.Sqlite3 {
return strings.Join(vars, "||") return strings.Join(vars, "||")
} else if ex.driverName == model.Postgres { } else if b.driverName == model.Postgres {
return vars[0] return vars[0]
} else { } else {
return "CONCAT(" + strings.Join(vars, ",") + ")" return "CONCAT(" + strings.Join(vars, ",") + ")"
} }
} }
func (ex *Builder) getConcatForLike(vars ...string) string { func (b *Builder) getConcatForLike(vars ...string) string {
if ex.driverName == model.Sqlite3 || ex.driverName == model.Postgres { if b.driverName == model.Sqlite3 || b.driverName == model.Postgres {
return strings.Join(vars, "||") return strings.Join(vars, "||")
} else { } else {
return "CONCAT(" + strings.Join(vars, ",") + ")" return "CONCAT(" + strings.Join(vars, ",") + ")"

77
builder/handle.go
View File

@@ -8,22 +8,22 @@ import (
) )
//拼接SQL,字段相关 //拼接SQL,字段相关
func (ex *Builder) handleField(paramList []any) (string, []any) { func (b *Builder) handleField(paramList []any) (string, []any) {
if len(ex.selectList) == 0 && len(ex.selectExpList) == 0 { fieldStr := ""
return "*", paramList if b.distinct {
fieldStr += "DISTINCT "
}
if len(b.selectList) == 0 && len(b.selectExpList) == 0 {
fieldStr += "*"
return fieldStr, 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...)
//}
var strList []string var strList []string
for i := 0; i < len(ex.selectList); i++ { //处理一般的参数
selectItem := ex.selectList[i] for i := 0; i < len(b.selectList); i++ {
selectItem := b.selectList[i]
str := "" str := ""
if selectItem.FuncName != "" { if selectItem.FuncName != "" {
@@ -50,28 +50,35 @@ func (ex *Builder) handleField(paramList []any) (string, []any) {
strList = append(strList, str) strList = append(strList, str)
} }
return strings.Join(strList, ","), paramList //处理子语句
for i := 0; i < len(b.selectExpList); i++ {
executor := *(b.selectExpList[i].Executor)
subSql, subParamList := executor.GetSqlAndParams()
strList = append(strList, "("+subSql+") AS "+getFieldName(b.selectExpList[i].FieldName))
paramList = append(paramList, subParamList...)
}
fieldStr += strings.Join(strList, ",")
return fieldStr, paramList
} }
//拼接SQL,查询条件 //拼接SQL,查询条件
func (ex *Builder) handleWhere(paramList []any) (string, []any) { func (b *Builder) handleWhere(paramList []any) (string, []any) {
if len(ex.whereList) == 0 { if len(b.whereList) == 0 {
return "", paramList return "", paramList
} }
strList, paramList := ex.whereAndHaving(ex.whereList, paramList) strList, paramList := b.whereAndHaving(b.whereList, paramList)
return " WHERE " + strings.Join(strList, " AND "), paramList return " WHERE " + strings.Join(strList, " AND "), paramList
} }
//拼接SQL,更新信息 //拼接SQL,更新信息
func (ex *Builder) handleSet(dest interface{}, paramList []any) (string, []any) { func (b *Builder) handleSet(typeOf reflect.Type, valueOf reflect.Value, paramList []any) (string, []any) {
typeOf := reflect.TypeOf(dest)
valueOf := reflect.ValueOf(dest)
//如果没有设置表名 //如果没有设置表名
if ex.tableName == "" { if b.tableName == "" {
ex.tableName = getTableName(typeOf, valueOf) b.tableName = getTableName(typeOf, valueOf)
} }
var keys []string var keys []string
@@ -110,52 +117,52 @@ func (b *Builder) handleJoin(paramList []interface{}) (string, []interface{}) {
} }
//拼接SQL,结果分组 //拼接SQL,结果分组
func (ex *Builder) handleGroup(paramList []any) (string, []any) { func (b *Builder) handleGroup(paramList []any) (string, []any) {
if len(ex.groupList) == 0 { if len(b.groupList) == 0 {
return "", paramList return "", paramList
} }
var groupList []string var groupList []string
for i := 0; i < len(ex.groupList); i++ { for i := 0; i < len(b.groupList); i++ {
groupList = append(groupList, ex.groupList[i].Prefix+"."+getFieldName(ex.groupList[i].Field)) groupList = append(groupList, b.groupList[i].Prefix+"."+getFieldName(b.groupList[i].Field))
} }
return " GROUP BY " + strings.Join(groupList, ","), paramList return " GROUP BY " + strings.Join(groupList, ","), paramList
} }
//拼接SQL,结果筛选 //拼接SQL,结果筛选
func (ex *Builder) handleHaving(paramList []any) (string, []any) { func (b *Builder) handleHaving(paramList []any) (string, []any) {
if len(ex.havingList) == 0 { if len(b.havingList) == 0 {
return "", paramList return "", paramList
} }
strList, paramList := ex.whereAndHaving(ex.havingList, paramList) strList, paramList := b.whereAndHaving(b.havingList, paramList)
return " Having " + strings.Join(strList, " AND "), paramList return " Having " + strings.Join(strList, " AND "), paramList
} }
//拼接SQL,结果排序 //拼接SQL,结果排序
func (ex *Builder) handleOrder(paramList []any) (string, []any) { func (b *Builder) handleOrder(paramList []any) (string, []any) {
if len(ex.orderList) == 0 { if len(b.orderList) == 0 {
return "", paramList return "", paramList
} }
var orderList []string var orderList []string
for i := 0; i < len(ex.orderList); i++ { for i := 0; i < len(b.orderList); i++ {
orderList = append(orderList, ex.orderList[i].Prefix+"."+getFieldName(ex.orderList[i].Field)+" "+ex.orderList[i].OrderType) orderList = append(orderList, b.orderList[i].Prefix+"."+getFieldName(b.orderList[i].Field)+" "+b.orderList[i].OrderType)
} }
return " ORDER BY " + strings.Join(orderList, ","), paramList return " ORDER BY " + strings.Join(orderList, ","), paramList
} }
//拼接SQL,分页相关 Postgres数据库分页数量在前偏移在后，其他数据库偏移量在前分页数量在后，另外Mssql数据库的关键词是offset...next //拼接SQL,分页相关 Postgres数据库分页数量在前偏移在后，其他数据库偏移量在前分页数量在后，另外Mssql数据库的关键词是offset...next
func (ex *Builder) handleLimit(offset int, pageSize int, paramList []any) (string, []any) { func (b *Builder) handleLimit(offset int, pageSize int, paramList []any) (string, []any) {
if 0 == pageSize { if 0 == pageSize {
return "", paramList return "", paramList
} }
str := "" str := ""
if ex.driverName == model.Postgres { if b.driverName == model.Postgres {
paramList = append(paramList, pageSize) paramList = append(paramList, pageSize)
paramList = append(paramList, offset) paramList = append(paramList, offset)
@@ -165,7 +172,7 @@ func (ex *Builder) handleLimit(offset int, pageSize int, paramList []any) (strin
paramList = append(paramList, pageSize) paramList = append(paramList, pageSize)
str = " Limit ?,? " str = " Limit ?,? "
if ex.driverName == model.Mssql { if b.driverName == model.Mssql {
str = " offset ? rows fetch next ? rows only " str = " offset ? rows fetch next ? rows only "
} }
} }

172
builder/having.go
View File

@@ -6,13 +6,13 @@ import (
) )
// Having 链式操作,以对象作为筛选条件 // Having 链式操作,以对象作为筛选条件
func (ex *Builder) Having(dest interface{}) *Builder { func (b *Builder) Having(dest interface{}) *Builder {
typeOf := reflect.TypeOf(dest) typeOf := reflect.TypeOf(dest)
valueOf := reflect.ValueOf(dest) valueOf := reflect.ValueOf(dest)
//如果没有设置表名 //如果没有设置表名
if ex.tableName == "" { if b.tableName == "" {
ex.tableName = getTableName(typeOf, valueOf) b.tableName = getTableName(typeOf, valueOf)
} }
for i := 0; i < typeOf.Elem().NumField(); i++ { for i := 0; i < typeOf.Elem().NumField(); i++ {
@@ -20,158 +20,80 @@ func (ex *Builder) Having(dest interface{}) *Builder {
if isNotNull { if isNotNull {
key := helper.UnderLine(typeOf.Elem().Field(i).Name) key := helper.UnderLine(typeOf.Elem().Field(i).Name)
val := valueOf.Elem().Field(i).Field(0).Field(0).Interface() val := valueOf.Elem().Field(i).Field(0).Field(0).Interface()
ex.havingList = append(ex.havingList, WhereItem{Field: key, Opt: Eq, Val: val}) b.havingList = append(b.havingList, WhereItem{Field: key, Opt: Eq, Val: val})
} }
} }
return ex return b
} }
// HavingArr 链式操作,以数组作为筛选条件 // HavingArr 链式操作,以数组作为筛选条件
func (ex *Builder) HavingArr(havingList []WhereItem) *Builder { func (b *Builder) HavingArr(havingList []WhereItem) *Builder {
ex.havingList = append(ex.havingList, havingList...) b.havingList = append(b.havingList, havingList...)
return ex return b
} }
func (ex *Builder) HavingEq(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingEq(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Eq, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: Eq,
Val: val,
})
return ex
} }
func (ex *Builder) HavingNe(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingNe(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Ne, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: Ne,
Val: val,
})
return ex
} }
func (ex *Builder) HavingGt(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingGt(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Gt, val})
FuncName: "", return b
Prefix: "",
Field: field,
Opt: Gt,
Val: val,
})
return ex
} }
func (ex *Builder) HavingGe(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingGe(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Ge, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: Ge,
Val: val,
})
return ex
} }
func (ex *Builder) HavingLt(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingLt(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Lt, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: Lt,
Val: val,
})
return ex
} }
func (ex *Builder) HavingLe(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingLe(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Le, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: Le,
Val: val,
})
return ex
} }
func (ex *Builder) HavingIn(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingIn(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, In, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: In,
Val: val,
})
return ex
} }
func (ex *Builder) HavingNotIn(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingNotIn(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, NotIn, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: NotIn,
Val: val,
})
return ex
} }
func (ex *Builder) HavingBetween(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingBetween(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Between, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: Between,
Val: val,
})
return ex
} }
func (ex *Builder) HavingNotBetween(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingNotBetween(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, NotBetween, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: NotBetween,
Val: val,
})
return ex
} }
func (ex *Builder) HavingLike(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingLike(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Like, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: Like,
Val: val,
})
return ex
} }
func (ex *Builder) HavingNotLike(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingNotLike(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, NotLike, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: NotLike,
Val: val,
})
return ex
} }
func (ex *Builder) HavingRaw(funcName string, field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) HavingRaw(field interface{}, val interface{}, prefix ...string) *Builder {
ex.havingList = append(ex.havingList, WhereItem{ b.havingList = append(b.havingList, WhereItem{"", field, Raw, val})
FuncName: funcName, return b
Prefix: getPrefixByField(field, prefix...),
Field: field,
Opt: Raw,
Val: val,
})
return ex
} }

10
builder/select.go
View File

@@ -50,10 +50,10 @@ func (b *Builder) selectCommon(funcName string, field interface{}, fieldNew inte
} }
// SelectExp 链式操作-表达式 // SelectExp 链式操作-表达式
func (b *Builder) SelectExp(dbSub **Builder, fieldName string) *Builder { func (b *Builder) SelectExp(dbSub **Builder, fieldName interface{}) *Builder {
//ex.selectExpList = append(ex.selectExpList, &SelectItem{ b.selectExpList = append(b.selectExpList, &SelectExpItem{
// Executor: dbSub, Executor: dbSub,
// FieldName: fieldName, FieldName: fieldName,
//}) })
return b return b
} }

31
builder/where.go
View File

@@ -34,66 +34,71 @@ func (b *Builder) WhereArr(whereList []WhereItem) *Builder {
} }
func (b *Builder) WhereEq(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereEq(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Eq, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Eq, val})
return b return b
} }
func (b *Builder) WhereNe(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereNe(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Ne, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Ne, val})
return b return b
} }
func (b *Builder) WhereGt(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereGt(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Gt, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Gt, val})
return b return b
} }
func (b *Builder) WhereGe(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereGe(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Ge, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Ge, val})
return b return b
} }
func (b *Builder) WhereLt(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereLt(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Lt, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Lt, val})
return b return b
} }
func (b *Builder) WhereLe(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereLe(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Le, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Le, val})
return b return b
} }
func (b *Builder) WhereIn(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereIn(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, In, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, In, val})
return b return b
} }
func (b *Builder) WhereNotIn(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereNotIn(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, NotIn, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, NotIn, val})
return b return b
} }
func (b *Builder) WhereBetween(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereBetween(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Between, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Between, val})
return b return b
} }
func (b *Builder) WhereNotBetween(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereNotBetween(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, NotBetween, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, NotBetween, val})
return b return b
} }
func (b *Builder) WhereLike(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereLike(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Like, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Like, val})
return b return b
} }
func (b *Builder) WhereNotLike(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereNotLike(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, NotLike, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, NotLike, val})
return b return b
} }
func (b *Builder) WhereRaw(field interface{}, val interface{}, prefix ...string) *Builder { func (b *Builder) WhereRaw(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{"", getPrefixByField(field, prefix...), field, Raw, val}) b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, Raw, val})
return b
}
func (b *Builder) WhereRawEq(field interface{}, val interface{}, prefix ...string) *Builder {
b.whereList = append(b.whereList, WhereItem{getPrefixByField(field, prefix...), field, RawEq, val})
return b return b
} }

310
test/aorm_test.go
View File

@@ -62,11 +62,12 @@ var person = Person{}
var article = Article{} var article = Article{}
var articleVO = ArticleVO{} var articleVO = ArticleVO{}
var personAge = PersonAge{} var personAge = PersonAge{}
var personWithArticleCount = PersonWithArticleCount{}
func TestAll(t *testing.T) { func TestAll(t *testing.T) {
aorm.Store(&person, &article) aorm.Store(&person, &article)
aorm.Store(&articleVO) aorm.Store(&articleVO)
aorm.Store(&personAge) aorm.Store(&personAge, &personWithArticleCount)
dbList := make([]aorm.DbContent, 0) dbList := make([]aorm.DbContent, 0)
//dbList = append(dbList, testSqlite3Connect()) //dbList = append(dbList, testSqlite3Connect())
@@ -77,16 +78,15 @@ func TestAll(t *testing.T) {
for i := 0; i < len(dbList); i++ { for i := 0; i < len(dbList); i++ {
dbItem := 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) id := testInsert(dbItem.DriverName, dbItem.DbLink)
testInsertBatch(dbItem.DriverName, dbItem.DbLink) testInsertBatch(dbItem.DriverName, dbItem.DbLink)
testGetOne(dbItem.DriverName, dbItem.DbLink, id) testGetOne(dbItem.DriverName, dbItem.DbLink, id)
testGetMany(dbItem.DriverName, dbItem.DbLink) testGetMany(dbItem.DriverName, dbItem.DbLink)
testUpdate(dbItem.DriverName, dbItem.DbLink, id) testUpdate(dbItem.DriverName, dbItem.DbLink, id)
isExists := testExists(dbItem.DriverName, dbItem.DbLink, id) isExists := testExists(dbItem.DriverName, dbItem.DbLink, id)
if isExists != true { if isExists != true {
panic("应该存在，但是数据库不存在") panic("应该存在，但是数据库不存在")
@@ -99,17 +99,16 @@ func TestAll(t *testing.T) {
} }
id2 := testInsert(dbItem.DriverName, dbItem.DbLink) id2 := testInsert(dbItem.DriverName, dbItem.DbLink)
//testTable(dbItem.DriverName, dbItem.DbLink) testTable(dbItem.DriverName, dbItem.DbLink)
//testSelect(dbItem.DriverName, dbItem.DbLink) testSelect(dbItem.DriverName, dbItem.DbLink)
//testSelectWithSub(dbItem.DriverName, dbItem.DbLink) testSelectWithSub(dbItem.DriverName, dbItem.DbLink)
//testWhereWithSub(dbItem.DriverName, dbItem.DbLink) testWhereWithSub(dbItem.DriverName, dbItem.DbLink)
//testWhere(dbItem.DriverName, dbItem.DbLink) testWhere(dbItem.DriverName, dbItem.DbLink)
testJoin(dbItem.DriverName, dbItem.DbLink) testJoin(dbItem.DriverName, dbItem.DbLink)
testJoinWithAlias(dbItem.DriverName, dbItem.DbLink) testJoinWithAlias(dbItem.DriverName, dbItem.DbLink)
testGroupBy(dbItem.DriverName, dbItem.DbLink) testGroupBy(dbItem.DriverName, dbItem.DbLink)
testHaving(dbItem.DriverName, dbItem.DbLink) testHaving(dbItem.DriverName, dbItem.DbLink)
return
testOrderBy(dbItem.DriverName, dbItem.DbLink) testOrderBy(dbItem.DriverName, dbItem.DbLink)
testLimit(dbItem.DriverName, dbItem.DbLink) testLimit(dbItem.DriverName, dbItem.DbLink)
testLock(dbItem.DriverName, dbItem.DbLink, id2) testLock(dbItem.DriverName, dbItem.DbLink, id2)
@@ -125,12 +124,13 @@ func TestAll(t *testing.T) {
testAvg(dbItem.DriverName, dbItem.DbLink) testAvg(dbItem.DriverName, dbItem.DbLink)
testMin(dbItem.DriverName, dbItem.DbLink) testMin(dbItem.DriverName, dbItem.DbLink)
testMax(dbItem.DriverName, dbItem.DbLink) testMax(dbItem.DriverName, dbItem.DbLink)
//
//testExec(dbItem.DriverName, dbItem.DbLink) testDistinct(dbItem.DriverName, dbItem.DbLink)
//
//testTransaction(dbItem.DriverName, dbItem.DbLink) testExec(dbItem.DriverName, dbItem.DbLink)
//testTruncate(dbItem.DriverName, dbItem.DbLink)
//testHelper(dbItem.DriverName, dbItem.DbLink) testTransaction(dbItem.DriverName, dbItem.DbLink)
testTruncate(dbItem.DriverName, dbItem.DbLink)
} }
} }
@@ -318,6 +318,13 @@ func testDelete(driver string, db *sql.DB, id int64) {
if errDelete != nil { if errDelete != nil {
panic(driver + "testDelete" + "found err") panic(driver + "testDelete" + "found err")
} }
_, errDelete2 := aorm.Use(db).Driver(driver).Debug(true).Delete(&Person{
Id: null.IntFrom(id),
})
if errDelete2 != nil {
panic(driver + "testDelete" + "found err")
}
} }
func testExists(driver string, db *sql.DB, id int64) bool { func testExists(driver string, db *sql.DB, id int64) bool {
@@ -328,69 +335,69 @@ func testExists(driver string, db *sql.DB, id int64) bool {
return exists return exists
} }
// func testTable(driver string, db *sql.DB) {
//func testTable(driver string, db *sql.DB) { _, err := aorm.Use(db).Debug(true).Driver(driver).Table("person_1").Insert(&Person{Name: null.StringFrom("Cherry")})
// _, err := aorm.Use(db).Debug(true).Driver(driver).Table("person_1").Insert(&Person{Name: null.StringFrom("Cherry")}) if err != nil {
// if err != nil { panic(driver + " testTable " + "found err:" + err.Error())
// panic(driver + " testTable " + "found err:" + err.Error()) }
// }
//} _, err2 := aorm.Use(db).Debug(true).Driver(driver).Table(&person).Insert(&Person{Name: null.StringFrom("Cherry")})
// if err2 != nil {
//func testSelect(driver string, db *sql.DB) { panic(driver + " testTable " + "found err:" + err2.Error())
// var listByFiled []Person }
// err := aorm.Use(db).Debug(true).Driver(driver).Select("name,age").Where(&Person{Age: null.IntFrom(18)}).GetMany(&listByFiled) }
// if err != nil {
// panic(driver + " testSelect " + "found err:" + err.Error()) func testSelect(driver string, db *sql.DB) {
// } var listByFiled []Person
//} err := aorm.Use(db).Debug(true).Driver(driver).Table(&person).Select(&person.Name).Select(&person.Age).WhereEq(&person.Age, 18).GetMany(&listByFiled)
// if err != nil {
//func testSelectWithSub(driver string, db *sql.DB) { panic(driver + " testSelect " + "found err:" + err.Error())
// var listByFiled []PersonWithArticleCount }
// }
// sub := aorm.Sub().Table("article").SelectCount("id", "article_count_tem").WhereRaw("person_id", "=person.id")
// err := aorm.Use(db).Debug(true). func testSelectWithSub(driver string, db *sql.DB) {
// Driver(driver). var listByFiled []PersonWithArticleCount
// SelectExp(&sub, "article_count").
// Select("*"). sub := aorm.Sub().Table(&article).SelectCount(&article.Id, "article_count_tem").WhereRawEq(&article.PersonId, &person.Id)
// Where(&Person{Age: null.IntFrom(18)}). err := aorm.Use(db).Debug(true).
// GetMany(&listByFiled) Driver(driver).
// SelectExp(&sub, &personWithArticleCount.ArticleCount).
// if err != nil { SelectAll(&person).
// panic(driver + " testSelectWithSub " + "found err:" + err.Error()) Table(&person).
// } WhereEq(&person.Age, 18).
//} GetMany(&listByFiled)
//
//func testWhereWithSub(driver string, db *sql.DB) { if err != nil {
// var listByFiled []Person panic(driver + " testSelectWithSub " + "found err:" + err.Error())
// }
// sub := aorm.Sub().Table("article").Select("person_id").GroupBy("person_id").HavingGt("count(person_id)", 0) }
//
// err := aorm.Use(db).Debug(true). func testWhereWithSub(driver string, db *sql.DB) {
// Table("person"). var listByFiled []Person
// Driver(driver). sub := aorm.Sub().Table(&article).SelectCount(&article.PersonId, "count_person_id").GroupBy(&article.PersonId).HavingGt("count_person_id", 0)
// WhereIn("id", &sub). err := aorm.Use(db).Debug(true).
// GetMany(&listByFiled) Table(&person).
// Driver(driver).
// if err != nil { WhereIn(&person.Id, &sub).
// panic(driver + " testWhereWithSub " + "found err:" + err.Error()) GetMany(&listByFiled)
// } if err != nil {
//} panic(driver + " testWhereWithSub " + "found err:" + err.Error())
// }
//func testWhere(driver string, db *sql.DB) { }
// var listByWhere []Person
// func testWhere(driver string, db *sql.DB) {
// var where1 []builder.WhereItem var listByWhere []Person
// where1 = append(where1, builder.WhereItem{Field: "type", Opt: builder.Eq, Val: 0}) err := aorm.Use(db).Debug(true).Driver(driver).Table(&person).WhereArr([]builder.WhereItem{
// where1 = append(where1, builder.WhereItem{Field: "age", Opt: builder.In, Val: []int{18, 20}}) {Field: &person.Type, Opt: builder.Eq, Val: 0},
// where1 = append(where1, builder.WhereItem{Field: "money", Opt: builder.Between, Val: []float64{100.1, 200.9}}) {Field: &person.Age, Opt: builder.In, Val: []int{18, 20}},
// where1 = append(where1, builder.WhereItem{Field: "money", Opt: builder.Eq, Val: 100.15}) {Field: &person.Money, Opt: builder.Between, Val: []float64{100.1, 200.9}},
// where1 = append(where1, builder.WhereItem{Field: "name", Opt: builder.Like, Val: []string{"%", "li", "%"}}) {Field: &person.Money, Opt: builder.Eq, Val: 100.15},
// {Field: &person.Name, Opt: builder.Like, Val: []string{"%", "li", "%"}},
// err := aorm.Use(db).Debug(true).Driver(driver).Table("person").WhereArr(where1).GetMany(&listByWhere) }).GetMany(&listByWhere)
// if err != nil { if err != nil {
// panic(driver + "testWhere" + "found err") panic(driver + "testWhere" + "found err")
// } }
//} }
func testJoin(driver string, db *sql.DB) { func testJoin(driver string, db *sql.DB) {
var list2 []ArticleVO var list2 []ArticleVO
@@ -601,7 +608,6 @@ func testPluck(driver string, db *sql.DB) {
} }
} }
//
func testCount(driver string, db *sql.DB) { func testCount(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(true).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Count("*") _, err := aorm.Use(db).Debug(true).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Count("*")
if err != nil { if err != nil {
@@ -609,7 +615,6 @@ func testCount(driver string, db *sql.DB) {
} }
} }
//
func testSum(driver string, db *sql.DB) { func testSum(driver string, db *sql.DB) {
_, err := aorm.Use(db).Debug(true).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Sum(&person.Age) _, err := aorm.Use(db).Debug(true).Table(&person).WhereEq(&person.Age, 18).Driver(driver).Sum(&person.Age)
if err != nil { if err != nil {
@@ -638,82 +643,67 @@ func testMax(driver string, db *sql.DB) {
} }
} }
// func testDistinct(driver string, db *sql.DB) {
//func testExec(driver string, db *sql.DB) { var listByFiled []Person
// _, err := aorm.Use(db).Debug(true).Driver(driver).Exec("UPDATE person SET name = ? WHERE id=?", "Bob", 3) err := aorm.Use(db).Debug(true).Driver(driver).Distinct(true).Table(&person).Select(&person.Name).Select(&person.Age).WhereEq(&person.Age, 18).GetMany(&listByFiled)
// if err != nil { if err != nil {
// panic(driver + "testExec" + "found err") panic(driver + " testSelect " + "found err:" + err.Error())
// } }
//} }
//
//func testTransaction(driver string, db *sql.DB) {
// tx, _ := db.Begin()
//
// id, errInsert := aorm.Use(tx).Debug(true).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(true).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(true).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(true).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(true).Driver(driver).Table("person").Truncate()
// if err != nil {
// panic(driver + " testTruncate " + "found err")
// }
//}
//func testHelper(driver string, db *sql.DB) { func testExec(driver string, db *sql.DB) {
// var list2 []ArticleVO _, err := aorm.Use(db).Debug(true).Driver(driver).Exec("UPDATE person SET name = ? WHERE person.id=?", "Bob", 3)
// var where2 []builder.WhereItem if err != nil {
// where2 = append(where2, builder.WhereItem{Field: "o.type", Opt: builder.Eq, Val: 0}) panic(driver + "testExec" + "found err")
// where2 = append(where2, builder.WhereItem{Field: "p.age", Opt: builder.In, Val: []int{18, 20}}) }
// err := aorm.Use(db).Debug(true). }
// Table("article o").
// LeftJoin("person p", helper.Ul("p.id=o.personId")). func testTransaction(driver string, db *sql.DB) {
// Select("o.*"). tx, _ := db.Begin()
// Select(helper.Ul("p.name as personName")).
// WhereArr(where2). id, errInsert := aorm.Use(tx).Debug(true).Driver(driver).Insert(&Person{
// Driver(driver). Name: null.StringFrom("Alice"),
// GetMany(&list2) })
// if err != nil {
// panic(driver + "testHelper" + "found err") if errInsert != nil {
// } tx.Rollback()
//} panic(driver + " testTransaction " + "found err:" + errInsert.Error())
return
}
_, errCount := aorm.Use(tx).Debug(true).Driver(driver).Table(&person).WhereEq(&person.Id, id).Count("*")
if errCount != nil {
tx.Rollback()
panic(driver + "testTransaction" + "found err")
return
}
var personItem Person
errPerson := aorm.Use(tx).Debug(true).Driver(driver).Table(&person).WhereEq(&person.Id, id).OrderBy(&person.Id, builder.Desc).GetOne(&personItem)
if errPerson != nil {
tx.Rollback()
panic(driver + "testTransaction" + "found err")
return
}
_, errUpdate := aorm.Use(tx).Debug(true).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(true).Driver(driver).Table(&person).Truncate()
if err != nil {
panic(driver + " testTruncate " + "found err")
}
}