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
 }
 
+// timeToInt converts a time value to an integer value. See WriteTime for more
+// details.
+func timeToInt(t time.Time) int64 {
+        t = t.Round(time.Microsecond)
+        return t.Unix()*1e6 + int64(t.Nanosecond()/1e3)
+}
+
 // WriteTime writes a time.Time in a byte-sortable way.
 //
 // This method truncates the time to microseconds and drops the timezone,
 // because that's the (undocumented) way that the appengine SDK does it.
 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())
+
+        effectiveType := p.Type()
+        switch effectiveType {
+        case ds.PTTime:

[dnj, 2015/12/29 16:48:09]

I made this a switch statement in case there were other instances of data types
that made serialization-level type changes. If it's just PTTime, I could
simplify this, although probably with little gain.

+                effectiveType = ds.PTInt
+        }
+        typb := byte(effectiveType)

[iannucci, 2015/12/29 18:29:20]

This change is not good; it will call property maps to fail to round-trip to the
datastore.

+
         if p.IndexSetting() != ds.NoIndex {
                 typb |= 0x80
         }
         panicIf(buf.WriteByte(typb))
         switch p.Type() {
         case ds.PTNull:
         case ds.PTBool:
                 b := p.Value().(bool)
                 if b {
                         err = buf.WriteByte(1)
@@ skipping 359 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }