| 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 |
} |