Make Get operations only serialize the bare minimum.

service/datastore/properties.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 datastore
 
 import (
         "encoding/base64"
         "errors"
         "fmt"
@@ skipping 662 matching lines @@
         // objects.
         Load(PropertyMap) error
 
         // Save returns the current property as a PropertyMap. if withMeta is true,
         // then the PropertyMap contains all the metadata (e.g. '$meta' fields)
         // which was held by this PropertyLoadSaver.
         Save(withMeta bool) (PropertyMap, error)
 
         MetaGetter
 
+        // GetAllMeta returns a PropertyMap with all of the metadata in this
+        // PropertyLoadSaver. If a metadata field has an error during serialization,
+        // it is skipped.
+        GetAllMeta() PropertyMap
+
         // SetMeta allows you to set the current value of the meta-keyed field.
         SetMeta(key string, val interface{}) error
 
         // Problem indicates that this PLS has a fatal problem. Usually this is
         // set when the underlying struct has recursion, invalid field types, nested
         // slices, etc.
         Problem() error
 }
 
 // PropertyMap represents the contents of a datastore entity in a generic way.
@@ skipping 53 matching lines @@
         v, ok := pm["$"+key]
         if !ok || len(v) == 0 {
                 return nil, ErrMetaFieldUnset
         }
         if len(v) > 1 {
                 return nil, errors.New("gae: too many values for Meta key")
         }
         return v[0].Value(), nil
 }
 
+// GetAllMeta implements PropertyLoadSaver.GetAllMeta.
+func (pm PropertyMap) GetAllMeta() PropertyMap {
+        ret := make(PropertyMap, 8)
+        for k, v := range pm {
+                if isMetaKey(k) {
+                        newV := make([]Property, len(v))
+                        copy(newV, v)
+                        ret[k] = newV
+                }
+        }
+        return ret
+}
+
 // GetMetaDefault is the implementation of PropertyLoadSaver.GetMetaDefault.
 func (pm PropertyMap) GetMetaDefault(key string, dflt interface{}) interface{} {
         return GetMetaDefaultImpl(pm.GetMeta, key, dflt)
 }
 
 // SetMeta implements PropertyLoadSaver.SetMeta. It will only return an error
 // if `val` has an invalid type (e.g. not one supported by Property).
 func (pm PropertyMap) SetMeta(key string, val interface{}) error {
         prop := Property{}
         if err := prop.SetValue(val, NoIndex); err != nil {
@@ skipping 22 matching lines @@
         dflt = UpconvertUnderlyingType(dflt)
         cur, err := gm(key)
         if err != nil {
                 return dflt
         }
         if dflt != nil && reflect.TypeOf(cur) != reflect.TypeOf(dflt) {
                 return dflt
         }
         return cur
 }