时间字段由数据存储区舍入

Question

A Time value when saved to the datastore appears to lose some accuracy. The same does not happen for Time values saved to memcache.

The code below typically returns the following:

1) 2014-09-29 21:38:45.5991137 +0100 BST
2) 2014-09-29 21:38:45.599113 +0100 BST
3) 2014-09-29 21:38:45.5991137 +0100 BST

Why does this happen, and can I prevent it? Or do I have some fundamental misunderstanding?

Thanks.

import (
    "appengine/aetest"
    "appengine/datastore"
    "appengine/memcache"
    "log"
    "os"
    "testing"
    "time"
)

func TestTimeDiff(t *testing.T) {

    logger := log.New(os.Stderr, "", 0)
    c, _ := aetest.NewContext(&aetest.Options{"", true})
    defer c.Close()

    type MyType struct {
        Time time.Time
    }

    value1 := MyType{time.Now()} // create value1

    k := datastore.NewKey(c, "MyType", "mykey", 0, nil)
    datastore.Put(c, k, &value1) // persist value1 to datastore

    var value2 MyType
    datastore.Get(c, k, &value2) // create value2 as value1 retrieved from datastore

    item := &memcache.Item{
        Key:    "MC_MYTYPE",
        Object: value1,
    }
    memcache.Gob.Set(c, item) // persist value1 to memcache
    var value3 MyType
    memcache.Gob.Get(c, "MC_MYTYPE", &value3) // create value3 as value1 retrieved from memcache

    logger.Println("1) " + value1.Time.String())
    logger.Println("2) " + value2.Time.String())
    logger.Println("3) " + value3.Time.String())

}

Answer 1

The App Engine Datastore stores times with with microsecond precision.

The Go time.Time type has nanosecond precision. The gob stored to Memcache uses this full precision.