forked from ablegao/orm
/
rows.go
111 lines (96 loc) · 2.09 KB
/
rows.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
package orm
import (
"database/sql"
"reflect"
)
type Rows interface {
Next() bool
Scan(Module) error
Close() error
}
type CacheRows struct {
cache Cache
keys []string
dbName string
index int
key string
}
func (self *CacheRows) Next() bool {
defer func() {
self.index = self.index + 1
self.keys = self.keys[len(self.keys):]
}()
if len(self.keys) > self.index {
self.key = self.keys[self.index]
return true
} else {
return false
}
}
func (self *CacheRows) Close() error {
self.keys = nil
self.cache = nil
return nil
}
func (self *CacheRows) Scan(mode Module) error {
typ := reflect.TypeOf(mode).Elem()
val := reflect.ValueOf(mode).Elem()
err := self.cache.key2Mode(self.key, typ, val)
if err != nil {
Error.Println(err)
return err
}
m := CacheHook{}
m.Objects(val.Addr().Interface().(Module), self.dbName).Existed()
val.FieldByName("CacheHook").Set(reflect.ValueOf(m))
return nil
}
type ModeRows struct {
rows *sql.Rows
val []interface{}
dbName string
}
func (self *ModeRows) Next() bool {
return self.rows.Next()
}
func (self *ModeRows) Close() error {
defer func() {
self.rows = nil
}()
err := self.rows.Close()
if err != nil {
return err
}
return nil
}
func (self *ModeRows) Scan(mode Module) (err error) {
if self.val == nil {
self.val = []interface{}{}
}
self.val = self.val[len(self.val):]
defer func() {
self.val = self.val[len(self.val):]
}()
m := reflect.ValueOf(mode).Elem()
typ := reflect.TypeOf(mode).Elem()
for i := 0; i < m.NumField(); i++ {
if name := typ.Field(i).Tag.Get("field"); len(name) > 0 {
self.val = append(self.val, m.Field(i).Addr().Interface())
}
}
err = self.rows.Scan(self.val...)
if err != nil {
return
}
if field := m.FieldByName("CacheHook"); field.IsValid() {
obj := CacheHook{}
obj.Objects(m.Addr().Interface().(Module), self.dbName).Existed()
obj.SaveToCache()
field.Set(reflect.ValueOf(obj))
} else {
obj := DBHook{} //Object(m.Interface().(Module))
obj.Objects(m.Addr().Interface().(Module), self.dbName).Existed()
m.FieldByName("DBHook").Set(reflect.ValueOf(obj))
}
return
}