Fix a bug where deletions weren't updating the raw Kind index.

impl/memory/datastore_index.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "bytes"
         "fmt"
         "sort"
@@ skipping 26 matching lines @@
                 }
                 ret = append(ret, &ds.IndexDefinition{Kind: kind, SortBy: []ds.IndexColumn{{Property: name}}})
                 ret = append(ret, &ds.IndexDefinition{Kind: kind, SortBy: []ds.IndexColumn{{Property: name, Descending: true}}})
         }
         if serializationDeterministic {
                 sort.Sort(ret)
         }
         return ret
 }
 
+// indexEntriesWithBuiltins generates a new memStore containing the default
+// indexes for (k, pm) combined with complexIdxs.
+//
+// If "pm" is nil, this indicates an absence of a value. This is used
+// specifically deletion.

[iannucci, 2016/11/12 00:19:12]

typo?

 func indexEntriesWithBuiltins(k *ds.Key, pm ds.PropertyMap, complexIdxs []*ds.IndexDefinition) memStore {
-        sip := serialize.PropertyMapPartially(k, pm)
+        var sip serialize.SerializedPmap
+        if pm == nil {
+                return newMemStore()
+        }
+        sip = serialize.PropertyMapPartially(k, pm)
         return indexEntries(sip, k.Namespace(), append(defaultIndexes(k.Kind(), pm), complexIdxs...))
 }
 
 // indexRowGen contains enough information to generate all of the index rows which
 // correspond with a propertyList and a ds.IndexDefinition.
 type indexRowGen struct {
         propVec   []serialize.SerializedPslice
         decending []bool
 }
 
@@ skipping 67 matching lines @@
                 if pv, ok := sip[sb.Property]; ok {
                         m.buf.propVec = append(m.buf.propVec, pv)
                         m.buf.decending = append(m.buf.decending, sb.Descending)
                 } else {
                         return indexRowGen{}, false
                 }
         }
         return m.buf, true
 }
 
+// indexEntries generates a new memStore containing the specified index
+// definitions.
 func indexEntries(sip serialize.SerializedPmap, ns string, idxs []*ds.IndexDefinition) memStore {
         ret := newMemStore()
         idxColl := ret.GetOrCreateCollection("idx")
 
         mtch := matcher{}
         for _, idx := range idxs {
                 idx = idx.Normalize()
                 if irg, ok := mtch.match(idx.GetFullSortOrder(), sip); ok {
                         idxBin := serialize.ToBytes(*idx.PrepForIdxTable())
                         idxColl.Set(idxBin, []byte{})
@@ skipping 103 matching lines @@
 
                                 mergeIndexes(ns, store,
                                         newMemStore(),
                                         indexEntries(sip, ns, normalized))
                                 return true
                         })
                 }
         }
 }
 
+// updateIndexes updates the indexes in store to accommodate a change in entity
+// value.
+//
+// oldEnt is the previous entity value, and newEnt is the new entity value. If
+// newEnt is nil, that signifies deletion.
 func updateIndexes(store memStore, key *ds.Key, oldEnt, newEnt ds.PropertyMap) {
         // load all current complex query index definitions.
-        compIdx := []*ds.IndexDefinition{}
+        var compIdx []*ds.IndexDefinition
         walkCompIdxs(store.Snapshot(), nil, func(i *ds.IndexDefinition) bool {
                 compIdx = append(compIdx, i)
                 return true
         })
 
         mergeIndexes(key.Namespace(), store,
                 indexEntriesWithBuiltins(key, oldEnt, compIdx),
                 indexEntriesWithBuiltins(key, newEnt, compIdx))
 }