forked from gohouse/gorose
/
orm_query.go
320 lines (295 loc) · 8.25 KB
/
orm_query.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
package gorose
import (
"github.com/gohouse/t"
"math"
"reflect"
)
// Get : select more rows , relation limit set
func (dba *Orm) Select() error {
// 构建sql
sqlStr, args, err := dba.BuildSql()
if err != nil {
return err
}
// 执行查询
_, err = dba.GetISession().Query(sqlStr, args...)
return err
}
// First : select one row , relation limit set
func (dba *Orm) First() (result Data, err error) {
err = dba.Limit(1).Select()
if err != nil {
return
}
res := dba.GetISession().GetBindAll()
if len(res) > 0 {
result = res[0]
}
return
}
// Get : select more rows , relation limit set
func (dba *Orm) Get() (result []Data, err error) {
err = dba.Select()
result = dba.GetISession().GetBindAll()
return
}
// Count : select count rows
func (dba *Orm) Count(args ...string) (int64, error) {
fields := "*"
if len(args) > 0 {
fields = args[0]
}
count, err := dba._unionBuild("count", fields)
if count == nil {
return 0, err
}
return t.New(count).Int64(), err
}
// Sum : select sum field
func (dba *Orm) Sum(sum string) (interface{}, error) {
return dba._unionBuild("sum", sum)
}
// Avg : select avg field
func (dba *Orm) Avg(avg string) (interface{}, error) {
return dba._unionBuild("avg", avg)
}
// Max : select max field
func (dba *Orm) Max(max string) (interface{}, error) {
return dba._unionBuild("max", max)
}
// Min : select min field
func (dba *Orm) Min(min string) (interface{}, error) {
return dba._unionBuild("min", min)
}
// _unionBuild : build union select real
func (dba *Orm) _unionBuild(union, field string) (interface{}, error) {
var tmp interface{}
dba.union = union + "(" + field + ") as " + union
// 缓存fields字段,暂时由union占用
fieldsTmp := dba.fields
dba.fields = []string{dba.union}
dba.GetISession().SetUnion(true)
// 构建sql
sqls, args, err := dba.BuildSql()
if err != nil {
return tmp, err
}
// 执行查询
_, err = dba.GetISession().Query(sqls, args...)
if err != nil {
return tmp, err
}
// 重置union, 防止复用的时候感染
dba.union = ""
// 返还fields
dba.fields = fieldsTmp
// 语法糖获取union值
if dba.GetISession().GetUnion() != nil {
tmp = dba.GetISession().GetUnion()
// 获取之后, 释放掉
dba.GetISession().SetUnion(nil)
}
return tmp, nil
}
// Pluck 获取一列数据, 第二个字段可以指定另一个字段的值作为这一列数据的key
func (dba *Orm) Pluck(field string, fieldKey ...string) (v interface{}, err error) {
var binder = dba.GetISession().GetIBinder()
var resMap = make(map[interface{}]interface{}, 0)
var resSlice = make([]interface{}, 0)
err = dba.Select()
if err != nil {
return
}
switch binder.GetBindType() {
case OBJECT_MAP, OBJECT_MAP_T, OBJECT_STRUCT: // row
var key, val interface{}
if len(fieldKey) > 0 {
key, err = dba.Value(fieldKey[0])
if err != nil {
return
}
val, err = dba.Value(field)
if err != nil {
return
}
resMap[key] = val
} else {
v, err = dba.Value(field)
if err != nil {
return
}
}
case OBJECT_MAP_SLICE, OBJECT_MAP_SLICE_T:
for _, item := range t.New(binder.GetBindResultSlice().Interface()).Slice() {
val := item.MapInterface()
if len(fieldKey) > 0 {
resMap[val[fieldKey[0]].Interface()] = val[field].Interface()
} else {
resSlice = append(resSlice, val[field].Interface())
}
}
case OBJECT_STRUCT_SLICE: // rows
var brs = binder.GetBindResultSlice()
for i := 0; i < brs.Len(); i++ {
val := reflect.Indirect(brs.Index(i))
if len(fieldKey) > 0 {
mapkey := dba._valueFromStruct(val, fieldKey[0])
mapVal := dba._valueFromStruct(val, field)
resMap[mapkey] = mapVal
} else {
resSlice = append(resSlice, dba._valueFromStruct(val, field))
}
}
case OBJECT_STRING:
res := dba.GetISession().GetBindAll()
if len(res) > 0 {
for _, val := range res {
if len(fieldKey) > 0 {
resMap[val[fieldKey[0]]] = val[field]
} else {
resSlice = append(resSlice, val[field])
}
}
}
}
if len(fieldKey) > 0 {
v = resMap
} else {
v = resSlice
}
return
}
// Get : select more rows , relation limit set
func (dba *Orm) Value(field string) (v interface{}, err error) {
dba.Limit(1)
err = dba.Select()
if err != nil {
return
}
var binder = dba.GetISession().GetIBinder()
switch binder.GetBindType() {
case OBJECT_MAP, OBJECT_MAP_SLICE, OBJECT_MAP_SLICE_T, OBJECT_MAP_T:
v = reflect.ValueOf(binder.GetBindResult()).MapIndex(reflect.ValueOf(field)).Interface()
case OBJECT_STRUCT, OBJECT_STRUCT_SLICE:
bindResult := reflect.Indirect(reflect.ValueOf(binder.GetBindResult()))
v = dba._valueFromStruct(bindResult, field)
case OBJECT_STRING:
res := dba.GetISession().GetBindAll()
if len(res) > 0 {
v = res[0][field]
}
}
return
}
func (dba *Orm) _valueFromStruct(bindResult reflect.Value, field string) (v interface{}) {
ostype := bindResult.Type()
for i := 0; i < ostype.NumField(); i++ {
tag := ostype.Field(i).Tag.Get(TAGNAME)
if tag == field || ostype.Field(i).Name == field {
v = bindResult.FieldByName(ostype.Field(i).Name).Interface()
}
}
return
}
// Chunk : 分块处理数据,当要处理很多数据的时候, 我不需要知道具体是多少数据, 我只需要每次取limit条数据,
// 然后不断的增加offset去取更多数据, 从而达到分块处理更多数据的目的
//TODO 后续增加 gorotine 支持, 提高批量数据处理效率, 预计需要增加获取更多链接的支持
func (dba *Orm) Chunk(limit int, callback func([]Data) error) (err error) {
var page = 0
var tableName = dba.GetISession().GetIBinder().GetBindName()
// 先执行一条看看是否报错, 同时设置指定的limit, offset
result, err := dba.Table(tableName).Limit(limit).Offset(page * limit).Get()
if err != nil {
return
}
for len(result) > 0 {
if err = callback(result); err != nil {
break
}
page++
// 清理绑定数据, 进行下一次操作, 因为绑定数据是每一次执行的时候都会解析并保存的
// 而第二次以后执行的, 都会再次解析并保存, 数据结构是slice, 故会累积起来
dba.ClearBindValues()
result, _ = dba.Offset(page * limit).Get()
}
return
}
// Loop : 同chunk, 不过, 这个是循环的取前limit条数据, 为什么是循环取这些数据呢
// 因为, 我们考虑到一种情况, 那就是where条件如果刚好是要修改的值,
// 那么最后的修改结果因为offset的原因, 只会修改一半, 比如:
// DB().Where("age", 18) ===> DB().Data(gorose.Data{"age":19}).Where().Update()
func (dba *Orm) Loop(limit int, callback func([]Data) error) (err error) {
var page = 0
var tableName = dba.GetISession().GetIBinder().GetBindName()
// 先执行一条看看是否报错, 同时设置指定的limit
result, err := dba.Table(tableName).Limit(limit).Get()
if err != nil {
return
}
for len(result) > 0 {
if err = callback(result); err != nil {
break
}
page++
// 同chunk
dba.ClearBindValues()
result, _ = dba.Get()
}
return
}
// Paginate 自动分页
// @param limit 每页展示数量
// @param current_page 当前第几页, 从1开始
// 以下是laravel的Paginate返回示例
//{
// "total": 50,
// "per_page": 15,
// "current_page": 1,
// "last_page": 4,
// "first_page_url": "http://laravel.app?page=1",
// "last_page_url": "http://laravel.app?page=4",
// "next_page_url": "http://laravel.app?page=2",
// "prev_page_url": null,
// "path": "http://laravel.app",
// "from": 1,
// "to": 15,
// "data":[
// {
// // Result Object
// },
// {
// // Result Object
// }
// ]
//}
func (dba *Orm) Paginate() (res Data, err error) {
var limit = dba.GetLimit()
if limit == 0 {
limit = 15
}
var offset = dba.GetOffset()
var current_page = int(math.Ceil(float64(offset+1) / float64(limit)))
// 统计总量
count, err := dba.Count()
dba.ResetUnion()
// 获取结果
err = dba.Select()
if err != nil {
return
}
var last_page = int(math.Ceil(float64(count) / float64(limit)))
var next_page = current_page + 1
var prev_page = current_page - 1
res = Data{
"total": count,
"per_page": limit,
"current_page": current_page,
"last_page": last_page,
"first_page_url": 1,
"last_page_url": last_page,
"next_page_url": If(next_page > last_page, nil, next_page),
"prev_page_url": If(prev_page < 1, nil, prev_page),
"data": dba.GetIBinder().GetBindResultSlice().Interface(),
}
return
}