-
-
Notifications
You must be signed in to change notification settings - Fork 401
/
loader.go
154 lines (121 loc) · 3.11 KB
/
loader.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
package pg
import (
"reflect"
"strconv"
)
var (
Discard Loader = discardLoader{}
_ Loader = &structLoader{}
_ Loader = &valuesLoader{}
_ Loader = &Strings{}
_ Loader = &Ints{}
)
type Loader interface {
Load(colIdx int, colName string, b []byte) error
}
//------------------------------------------------------------------------------
type discardLoader struct{}
func (discardLoader) Load(colIdx int, colName string, b []byte) error {
return nil
}
//------------------------------------------------------------------------------
type structLoader struct {
v reflect.Value
fields map[string][]int
}
func newStructLoader(v reflect.Value) *structLoader {
return &structLoader{
v: v,
fields: structs.Fields(v.Type()),
}
}
func (l *structLoader) Load(colIdx int, colName string, b []byte) error {
indx, ok := l.fields[colName]
if !ok {
return errorf("pg: cannot map field %q", colName)
}
return DecodeValue(l.v.FieldByIndex(indx).Addr(), b)
}
//------------------------------------------------------------------------------
type valuesLoader struct {
values []interface{}
}
func LoadInto(values ...interface{}) Loader {
return &valuesLoader{values}
}
func (l *valuesLoader) Load(colIdx int, colName string, b []byte) error {
return Decode(l.values[colIdx], b)
}
//------------------------------------------------------------------------------
type Strings []string
func (strings *Strings) New() interface{} {
return strings
}
func (strings *Strings) Load(colIdx int, colName string, b []byte) error {
*strings = append(*strings, string(b))
return nil
}
func (strings Strings) Append(dst []byte) []byte {
if len(strings) <= 0 {
return dst
}
for _, s := range strings {
dst = appendString(dst, s)
dst = append(dst, ',')
}
dst = dst[:len(dst)-1]
return dst
}
//------------------------------------------------------------------------------
type Ints []int64
func (ints *Ints) New() interface{} {
return ints
}
func (ints *Ints) Load(colIdx int, colName string, b []byte) error {
n, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return err
}
*ints = append(*ints, n)
return nil
}
func (ints Ints) Append(dst []byte) []byte {
if len(ints) <= 0 {
return dst
}
for _, v := range ints {
dst = strconv.AppendInt(dst, v, 10)
dst = append(dst, ',')
}
dst = dst[:len(dst)-1]
return dst
}
//------------------------------------------------------------------------------
type IntsSet map[int64]struct{}
func (set IntsSet) New() interface{} {
return set
}
func (set IntsSet) Load(colIdx int, colName string, b []byte) error {
n, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return err
}
set[n] = struct{}{}
return nil
}
//------------------------------------------------------------------------------
func NewLoader(dst interface{}) (Loader, error) {
v := reflect.ValueOf(dst)
if !v.IsValid() {
return nil, errorf("pg: Decode(%s)", v)
}
if v.Kind() != reflect.Ptr {
return nil, errorf("pg: pointer expected")
}
v = v.Elem()
switch v.Kind() {
case reflect.Struct:
return newStructLoader(v), nil
}
return nil, errorf("pg: unsupported type %s", v.Type())
}