Make Get operations only serialize the bare minimum.

service/datastore/datastore.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 (
         "fmt"
         "reflect"
 
@@ skipping 181 matching lines @@
         return errors.SingleError(d.DeleteMulti([]*Key{key}))
 }
 
 func (d *datastoreImpl) GetMulti(dst interface{}) error {
         slice := reflect.ValueOf(dst)
         mat := parseMultiArg(slice.Type())
         if !mat.valid {
                 return fmt.Errorf("invalid GetMulti input type: %T", dst)
         }
 
-        keys, pms, err := mat.GetKeysPMs(d.aid, d.ns, slice)
+        keys, pms, err := mat.GetKeysPMs(d.aid, d.ns, slice, true)
         if err != nil {
                 return err
         }
 
         lme := errors.NewLazyMultiError(len(keys))
         i := 0
         meta := NewMultiMetaGetter(pms)
         err = d.RawInterface.GetMulti(keys, meta, func(pm PropertyMap, err error) {
                 if !lme.Assign(i, err) {
                         lme.Assign(i, mat.setPM(slice.Index(i), pm))
                 }
                 i++
         })
 
         if err == nil {
                 err = lme.Get()
         }
         return err
 }
 
 func (d *datastoreImpl) PutMulti(src interface{}) error {
         slice := reflect.ValueOf(src)
         mat := parseMultiArg(slice.Type())
         if !mat.valid {
                 return fmt.Errorf("invalid PutMulti input type: %T", src)
         }
 
-        keys, vals, err := mat.GetKeysPMs(d.aid, d.ns, slice)
+        keys, vals, err := mat.GetKeysPMs(d.aid, d.ns, slice, false)
         if err != nil {
                 return err
         }
 
         lme := errors.NewLazyMultiError(len(keys))
         i := 0
         err = d.RawInterface.PutMulti(keys, vals, func(key *Key, err error) {
                 if key != keys[i] {
                         mat.setKey(slice.Index(i), key)
                 }
@@ skipping 17 matching lines @@
         err = lme.Get()
         if err == nil {
                 err = extErr
         }
         return
 }
 
 func (d *datastoreImpl) Raw() RawInterface {
         return d.RawInterface
 }