impl/memory: Fix time serialization encoding.

service/datastore/serialize/serialize.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package serialize
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 171 matching lines @@
 
         gp.Lng, _, e = cmpbin.ReadFloat64(buf)
         panicIf(e)
 
         if !gp.Valid() {
                 err = fmt.Errorf("helper: decoded invalid GeoPoint: %v", gp)
         }
         return
 }
 
-// WriteTime writes a time.Time in a byte-sortable way.
+// timeToInt converts a time value to a datastore-appropraite integer value.
 //
 // This method truncates the time to microseconds and drops the timezone,
 // because that's the (undocumented) way that the appengine SDK does it.
+func timeToInt(t time.Time) int64 {
+        t = ds.RoundTime(t)
+        return t.Unix()*1e6 + int64(t.Nanosecond()/1e3)
+}
+
+// WriteTime writes a time to the buffer.
+//
+// The supplied time is rounded via datastore.RoundTime and written as a
+// microseconds-since-epoch integer to comform to datastore storage standards.
 func WriteTime(buf Buffer, t time.Time) error {
         name, off := t.Zone()
         if name != "UTC" || off != 0 {
                 panic(fmt.Errorf("helper: UTC OR DEATH: %s", t))
         }
-        _, err := cmpbin.WriteInt(buf, t.Unix()*1e6+int64(t.Nanosecond()/1e3))
+
+        _, err := cmpbin.WriteInt(buf, timeToInt(t))
         return err
 }
 
 // ReadTime reads a time.Time from the buffer.
 func ReadTime(buf Buffer) (time.Time, error) {
         v, _, err := cmpbin.ReadInt(buf)
         if err != nil {
                 return time.Time{}, err
         }
+
         t := time.Unix(v/1e6, (v%1e6)*1e3)
         if t.IsZero() {
                 return time.Time{}, nil
         }
         return t.UTC(), nil
 }
 
 // WriteProperty writes a Property to the buffer. `context` behaves the same
 // way that it does for WriteKey, but only has an effect if `p` contains a
 // Key as its Value.
 func WriteProperty(buf Buffer, context KeyContext, p ds.Property) (err error) {
         defer recoverTo(&err)
         typb := byte(p.Type())
         if p.IndexSetting() != ds.NoIndex {
                 typb |= 0x80
         }
         panicIf(buf.WriteByte(typb))
-        switch p.Type() {
+
+        err = writeRawProperty(buf, context, p.Type(), p.Value())
+        return
+}
+
+func writeRawProperty(buf Buffer, context KeyContext, t ds.PropertyType, val interface{}) (err error) {
+        t, val = RawType(t, val)
+        switch t {
         case ds.PTNull:
         case ds.PTBool:
-                b := p.Value().(bool)
+                b := val.(bool)
                 if b {
                         err = buf.WriteByte(1)
                 } else {
                         err = buf.WriteByte(0)
                 }
         case ds.PTInt:
-                _, err = cmpbin.WriteInt(buf, p.Value().(int64))
+                _, err = cmpbin.WriteInt(buf, val.(int64))
         case ds.PTFloat:
-                _, err = cmpbin.WriteFloat64(buf, p.Value().(float64))
+                _, err = cmpbin.WriteFloat64(buf, val.(float64))
         case ds.PTString:
-                _, err = cmpbin.WriteString(buf, p.Value().(string))
+                _, err = cmpbin.WriteString(buf, val.(string))
         case ds.PTBytes:
-                _, err = cmpbin.WriteBytes(buf, p.Value().([]byte))
-        case ds.PTTime:
-                err = WriteTime(buf, p.Value().(time.Time))
+                _, err = cmpbin.WriteBytes(buf, val.([]byte))
         case ds.PTGeoPoint:
-                err = WriteGeoPoint(buf, p.Value().(ds.GeoPoint))
+                err = WriteGeoPoint(buf, val.(ds.GeoPoint))
         case ds.PTKey:
-                err = WriteKey(buf, context, p.Value().(*ds.Key))
-        case ds.PTBlobKey:
-                _, err = cmpbin.WriteString(buf, string(p.Value().(blobstore.Key)))
+                err = WriteKey(buf, context, val.(*ds.Key))
+
+        default:
+                err = fmt.Errorf("unsupported type: %v", t)
         }
         return
 }
 
+// RawProperty converts a decomposed Property into a Property that matches its
+// primitive datastore storage format.
+//
+// See RawType for more information.
+func RawProperty(p ds.Property) ds.Property {
+        _, v := RawType(p.Type(), p.Value())
+
+        ret := ds.Property{}
+        ret.SetValue(v, p.IndexSetting())
+        return ret
+}
+
+// RawType converts a decomposed Property into fields that represent its
+// primitive datastore storage format.
+//
+// The following conversions are in place:
+//   - PTTime is converted to an microseconds-from-epoch integer value.
+//   - PTBlobKey is converted to a string.

[iannucci, 2015/12/29 21:41:48]

and PTBytes too?

+func RawType(t ds.PropertyType, v interface{}) (ds.PropertyType, interface{}) {
+        switch t {
+        case ds.PTTime:
+                return ds.PTInt, timeToInt(v.(time.Time))
+        case ds.PTBlobKey:
+                return ds.PTString, string(v.(blobstore.Key))
+        default:
+                return t, v
+        }
+}
+
 // ReadProperty reads a Property from the buffer. `context`, `appid`, and
 // `namespace` behave the same way they do for ReadKey, but only have an
 // effect if the decoded property has a Key value.
 func ReadProperty(buf Buffer, context KeyContext, appid, namespace string) (p ds.Property, err error) {
         val := interface{}(nil)
         b, err := buf.ReadByte()
         if err != nil {
                 return
         }
         is := ds.ShouldIndex
@@ skipping 230 matching lines @@
         for k, vals := range pm {
                 newVals := PropertySlice(vals)
                 if len(newVals) > 0 {
                         ret[k] = newVals
                 }
         }
         return
 }
 
 func toBytesErr(i interface{}, ctx KeyContext) (ret []byte, err error) {
-        buf := &bytes.Buffer{}
-        switch x := i.(type) {
-        case ds.GeoPoint:
-                err = WriteGeoPoint(buf, x)
+        buf := bytes.Buffer{}
 
+        switch t := i.(type) {
         case ds.IndexColumn:
-                err = WriteIndexColumn(buf, x)
+                err = WriteIndexColumn(&buf, t)
 
         case ds.IndexDefinition:
-                err = WriteIndexDefinition(buf, x)
-
-        case *ds.Key:
-                err = WriteKey(buf, ctx, x)
+                err = WriteIndexDefinition(&buf, t)
 
         case ds.KeyTok:
-                err = WriteKeyTok(buf, x)
+                err = WriteKeyTok(&buf, t)
 
         case ds.Property:
-                err = WriteProperty(buf, ctx, x)
+                err = WriteProperty(&buf, ctx, t)
 
         case ds.PropertyMap:
-                err = WritePropertyMap(buf, ctx, x)
-
-        case time.Time:
-                err = WriteTime(buf, x)
+                err = WritePropertyMap(&buf, ctx, t)
 
         default:
-                err = fmt.Errorf("unknown type for ToBytes: %T", i)
+                var pt ds.PropertyType
+                pt, err = ds.PropertyTypeOf(i, false)
+                if err == nil {
+                        err = writeRawProperty(&buf, ctx, pt, t)
+                }
         }
+
         if err == nil {
                 ret = buf.Bytes()
         }
         return
 }
 
 // ToBytesErr serializes i to a byte slice, if it's one of the type supported
 // by this library, otherwise it returns an error.
 //
 // Key types will be serialized using the 'WithoutContext' option (e.g. their
@@ skipping 47 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }