Make Get operations only serialize the bare minimum.

service/datastore/multiarg.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"
 
         "github.com/luci/luci-go/common/errors"
 )
 
 type multiArgType struct {
         valid bool
 
-        getKey  func(aid, ns string, slot reflect.Value) (*Key, error)
-        getPM   func(slot reflect.Value) (PropertyMap, error)
-        setPM   func(slot reflect.Value, pm PropertyMap) error
-        setKey  func(slot reflect.Value, k *Key)
-        newElem func() reflect.Value
+        getKey    func(aid, ns string, slot reflect.Value) (*Key, error)
+        getPM     func(slot reflect.Value) (PropertyMap, error)
+        getMetaPM func(slot reflect.Value) PropertyMap
+        setPM     func(slot reflect.Value, pm PropertyMap) error
+        setKey    func(slot reflect.Value, k *Key)
+        newElem   func() reflect.Value
 }
 
-func (mat *multiArgType) GetKeysPMs(aid, ns string, slice reflect.Value) ([]*Key, []PropertyMap, error) {
+func (mat *multiArgType) GetKeysPMs(aid, ns string, slice reflect.Value, meta bool) ([]*Key, []PropertyMap, error) {
         retKey := make([]*Key, slice.Len())
         retPM := make([]PropertyMap, slice.Len())
+        getter := mat.getPM
+        if meta {
+                getter = func(slot reflect.Value) (PropertyMap, error) {
+                        return mat.getMetaPM(slot), nil
+                }
+        }
         lme := errors.NewLazyMultiError(len(retKey))
         for i := range retKey {
                 key, err := mat.getKey(aid, ns, slice.Index(i))
                 if !lme.Assign(i, err) {
                         retKey[i] = key
-                        pm, err := mat.getPM(slice.Index(i))
+                        pm, err := getter(slice.Index(i))
                         if !lme.Assign(i, err) {
                                 retPM[i] = pm
                         }
                 }
         }
         return retKey, retPM, lme.Get()
 }
 
 // parseMultiArg checks that v has type []S, []*S, []I, []P or []*P, for some
 // struct type S, for some interface type I, or some non-interface non-pointer
@@ skipping 40 matching lines @@
 func multiArgTypePLS(et reflect.Type) multiArgType {
         ret := multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, slot.Addr().Interface())
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return slot.Addr().Interface().(PropertyLoadSaver).Save(true)
                 },
+                getMetaPM: func(slot reflect.Value) PropertyMap {
+                        return slot.Addr().Interface().(PropertyLoadSaver).GetAllMeta()
+                },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return slot.Addr().Interface().(PropertyLoadSaver).Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
                         setKey(slot.Addr().Interface(), k)
                 },
         }
         if et.Kind() == reflect.Map {
                 ret.newElem = func() reflect.Value {
                         // Create a *map so that way slot.Addr() works above when this is
@@ skipping 16 matching lines @@
 func multiArgTypePLSPtr(et reflect.Type) multiArgType {
         ret := multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, slot.Interface())
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return slot.Interface().(PropertyLoadSaver).Save(true)
                 },
+                getMetaPM: func(slot reflect.Value) PropertyMap {
+                        return slot.Interface().(PropertyLoadSaver).GetAllMeta()
+                },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return slot.Interface().(PropertyLoadSaver).Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
                         setKey(slot.Interface(), k)
                 },
         }
         if et.Kind() == reflect.Map {
                 ret.newElem = func() reflect.Value {
                         ptr := reflect.New(et)
@@ skipping 17 matching lines @@
         }
         return multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, toPLS(slot))
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return toPLS(slot).(PropertyLoadSaver).Save(true)
                 },
+                getMetaPM: func(slot reflect.Value) PropertyMap {
+                        return toPLS(slot).(PropertyLoadSaver).GetAllMeta()
+                },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return toPLS(slot).(PropertyLoadSaver).Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
                         setKey(toPLS(slot), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et).Elem()
                 },
         }
@@ skipping 10 matching lines @@
         }
         return multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, toPLS(slot))
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return toPLS(slot).(PropertyLoadSaver).Save(true)
                 },
+                getMetaPM: func(slot reflect.Value) PropertyMap {
+                        return toPLS(slot).(PropertyLoadSaver).GetAllMeta()
+                },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return toPLS(slot).(PropertyLoadSaver).Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
                         setKey(toPLS(slot), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et)
                 },
         }
 }
 
 // multiArgTypeInterface == []I
 func multiArgTypeInterface() multiArgType {
         return multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, slot.Elem().Interface())
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         pls := mkPLS(slot.Elem().Interface())
                         return pls.Save(true)
                 },
+                getMetaPM: func(slot reflect.Value) PropertyMap {
+                        pls := mkPLS(slot.Elem().Interface())
+                        return pls.GetAllMeta()
+                },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         pls := mkPLS(slot.Elem().Interface())
                         return pls.Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
                         setKey(slot.Elem().Interface(), k)
                 },
         }
 }
 
@@ skipping 32 matching lines @@
                 _ = pls.SetMeta("parent", key.Parent())
         }
 }
 
 func mkPLS(o interface{}) PropertyLoadSaver {
         if pls, ok := o.(PropertyLoadSaver); ok {
                 return pls
         }
         return GetPLS(o)
 }