Debian Codegraph @

docstore/mongodocstore/codec.go

raw
1 // Copyright 2019 The Go Cloud Development Kit Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 package mongodocstore
16
17 import (
18 "fmt"
19 "reflect"
20 "strings"
21 "time"
22
23 "go.mongodb.org/mongo-driver/bson/primitive"
24 "gocloud.dev/docstore/driver"
25 )
26
27 // Encode and decode to map[string]interface{}.
28 // This isn't ideal, because the mongo client encodes/decodes a second time.
29 // TODO(jba): Benchmark the double decode to see if it's worth trying to avoid it.
30
31 // This code is copied from memdocstore/codec.go, except for special treatment of
32 // primitive.Binary.
33
34 func encodeDoc(doc driver.Document, lowercaseFields bool) (map[string]interface{}, error) {
35 e := encoder{lowercaseFields: lowercaseFields}
36 if err := doc.Encode(&e); err != nil {
37 return nil, err
38 }
39 return e.val.(map[string]interface{}), nil
40 }
41
42 func encodeValue(x interface{}) (interface{}, error) {
43 var e encoder
44 if err := driver.Encode(reflect.ValueOf(x), &e); err != nil {
45 return nil, err
46 }
47 return e.val, nil
48 }
49
50 type encoder struct {
51 val interface{}
52 lowercaseFields bool
53 }
54
55 func (e *encoder) EncodeNil() { e.val = nil }
56 func (e *encoder) EncodeBool(x bool) { e.val = x }
57 func (e *encoder) EncodeInt(x int64) { e.val = x }
58 func (e *encoder) EncodeUint(x uint64) { e.val = int64(x) }
59 func (e *encoder) EncodeBytes(x []byte) { e.val = x }
60 func (e *encoder) EncodeFloat(x float64) { e.val = x }
61 func (e *encoder) EncodeString(x string) { e.val = x }
62 func (e *encoder) ListIndex(int) { panic("impossible") }
63 func (e *encoder) MapKey(string) { panic("impossible") }
64
65 var (
66 typeOfGoTime = reflect.TypeOf(time.Time{})
67 typeOfObjectID = reflect.TypeOf(primitive.ObjectID{})
68 )
69
70 func (e *encoder) EncodeSpecial(v reflect.Value) (bool, error) {
71 // Treat time specially as itself (otherwise its BinaryMarshal method will be called).
72 // Also, ObjectIDs are already encoded.
73 if v.Type() == typeOfGoTime || v.Type() == typeOfObjectID {
74 e.val = v.Interface()
75 return true, nil
76 }
77 return false, nil
78 }
79
80 func (e *encoder) EncodeList(n int) driver.Encoder {
81 // All slices and arrays are encoded as []interface{}
82 s := make([]interface{}, n)
83 e.val = s
84 return &listEncoder{s: s, encoder: encoder{lowercaseFields: e.lowercaseFields}}
85 }
86
87 type listEncoder struct {
88 s []interface{}
89 encoder
90 }
91
92 func (e *listEncoder) ListIndex(i int) { e.s[i] = e.val }
93
94 type mapEncoder struct {
95 m map[string]interface{}
96 isStruct bool
97 encoder
98 }
99
100 func (e *encoder) EncodeMap(n int) driver.Encoder {
101 m := make(map[string]interface{}, n)
102 e.val = m
103 return &mapEncoder{m: m, encoder: encoder{lowercaseFields: e.lowercaseFields}}
104 }
105
106 func (e *mapEncoder) MapKey(k string) {
107 if e.lowercaseFields {
108 k = strings.ToLower(k)
109 }
110 e.m[k] = e.val
111 }
112
113 ////////////////////////////////////////////////////////////////
114
115 // decodeDoc decodes m into ddoc.
116 func decodeDoc(m map[string]interface{}, ddoc driver.Document, idField string, lowercaseFields bool) error {
117 switch idField {
118 case mongoIDField: // do nothing
119 case "": // user uses idFunc
120 delete(m, mongoIDField)
121 default: // user documents have a different ID field
122 m[idField] = m[mongoIDField]
123 delete(m, mongoIDField)
124 }
125 return ddoc.Decode(decoder{val: m, lowercaseFields: lowercaseFields})
126 }
127
128 type decoder struct {
129 val interface{}
130 lowercaseFields bool
131 }
132
133 func (d decoder) String() string {
134 return fmt.Sprint(d.val)
135 }
136
137 func (d decoder) AsNull() bool {
138 return d.val == nil
139 }
140
141 func (d decoder) AsBool() (bool, bool) {
142 b, ok := d.val.(bool)
143 return b, ok
144 }
145
146 func (d decoder) AsString() (string, bool) {
147 s, ok := d.val.(string)
148 return s, ok
149 }
150
151 func (d decoder) AsInt() (int64, bool) {
152 switch v := d.val.(type) {
153 case int64:
154 return v, true
155 case int32:
156 return int64(v), true
157 default:
158 return 0, false
159 }
160 }
161
162 func (d decoder) AsUint() (uint64, bool) {
163 i, ok := d.val.(int64)
164 return uint64(i), ok
165 }
166
167 func (d decoder) AsFloat() (float64, bool) {
168 f, ok := d.val.(float64)
169 return f, ok
170 }
171
172 func (d decoder) AsBytes() ([]byte, bool) {
173 switch v := d.val.(type) {
174 case []byte:
175 return v, true
176 case primitive.Binary:
177 return v.Data, true
178 default:
179 return nil, false
180 }
181 }
182
183 func (d decoder) AsInterface() (interface{}, error) {
184 return toGoValue(d.val)
185 }
186
187 func toGoValue(v interface{}) (interface{}, error) {
188 switch v := v.(type) {
189 case primitive.A:
190 r := make([]interface{}, len(v))
191 for i, e := range v {
192 d, err := toGoValue(e)
193 if err != nil {
194 return nil, err
195 }
196 r[i] = d
197 }
198 return r, nil
199 case primitive.Binary:
200 return v.Data, nil
201 case primitive.DateTime:
202 return bsonDateTimeToTime(v), nil
203 case map[string]interface{}:
204 r := map[string]interface{}{}
205 for k, e := range v {
206 d, err := toGoValue(e)
207 if err != nil {
208 return nil, err
209 }
210 r[k] = d
211 }
212 return r, nil
213 default:
214 return v, nil
215 }
216 }
217
218 func (d decoder) ListLen() (int, bool) {
219 if s, ok := d.val.(primitive.A); ok {
220 return len(s), true
221 }
222 return 0, false
223 }
224
225 func (d decoder) DecodeList(f func(i int, d2 driver.Decoder) bool) {
226 for i, e := range d.val.(primitive.A) {
227 if !f(i, decoder{e, d.lowercaseFields}) {
228 return
229 }
230 }
231 }
232
233 func (d decoder) MapLen() (int, bool) {
234 if m, ok := d.val.(map[string]interface{}); ok {
235 return len(m), true
236 }
237 return 0, false
238 }
239
240 func (d decoder) DecodeMap(f func(key string, d2 driver.Decoder, exactMatch bool) bool) {
241 for k, v := range d.val.(map[string]interface{}) {
242 if !f(k, decoder{v, d.lowercaseFields}, !d.lowercaseFields) {
243 return
244 }
245 }
246 }
247
248 func (d decoder) AsSpecial(v reflect.Value) (bool, interface{}, error) {
249 switch v := d.val.(type) {
250 case primitive.DateTime:
251 // A DateTime represents milliseconds since the Unix epoch.
252 return true, bsonDateTimeToTime(v), nil
253 default:
254 return false, nil, nil
255 }
256 }
257
258 func bsonDateTimeToTime(dt primitive.DateTime) time.Time {
259 return time.Unix(int64(dt)/1000, int64(dt)%1000*1e6)
260 }