Fix #66.

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 37 matching lines @@
 // indexes for (k, pm) combined with complexIdxs.
 //
 // If "pm" is nil, this indicates an absence of a value. This is used
 // specifically for deletion.
 func indexEntriesWithBuiltins(k *ds.Key, pm ds.PropertyMap, complexIdxs []*ds.IndexDefinition) memStore {
         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...))
+        return indexEntries(k, sip, 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
 }
 
 // permute calls cb for each index row, in the sorted order of the rows.
@@ skipping 68 matching lines @@
                         m.buf.decending = append(m.buf.decending, sb.Descending)
                 } else {
                         return indexRowGen{}, false
                 }
         }
         return m.buf, true
 }
 
 // indexEntries generates a new memStore containing index entries for sip for
 // the supplied index definitions.
-func indexEntries(sip serialize.SerializedPmap, ns string, idxs []*ds.IndexDefinition) memStore {
+func indexEntries(key *ds.Key, sip serialize.SerializedPmap, idxs []*ds.IndexDefinition) memStore {
         ret := newMemStore()
         idxColl := ret.GetOrCreateCollection("idx")
 
         mtch := matcher{}
         for _, idx := range idxs {
                 idx = idx.Normalize()
+                if idx.Kind != "" && idx.Kind != key.Kind() {
+                        continue
+                }
                 if irg, ok := mtch.match(idx.GetFullSortOrder(), sip); ok {
                         idxBin := serialize.ToBytes(*idx.PrepForIdxTable())
                         idxColl.Set(idxBin, []byte{})
-                        coll := ret.GetOrCreateCollection(fmt.Sprintf("idx:%s:%s", ns, idxBin))
+                        coll := ret.GetOrCreateCollection(
+                                fmt.Sprintf("idx:%s:%s", key.Namespace(), idxBin))
                         irg.permute(coll.Set)
                 }
         }
 
         return ret
 }
 
 // walkCompIdxs walks the table of compound indexes in the store. If `endsWith`
 // is provided, this will only walk over compound indexes which match
 // Kind, Ancestor, and whose SortBy has `endsWith.SortBy` as a suffix.
@@ skipping 85 matching lines @@
 
                                 prop, err := serialize.ReadProperty(bytes.NewBuffer(i.Key), serialize.WithoutContext, ds.MkKeyContext(aid, ns))
                                 memoryCorruption(err)
 
                                 k := prop.Value().(*ds.Key)
 
                                 sip := serialize.PropertyMapPartially(k, pm)
 
                                 mergeIndexes(ns, store,
                                         newMemStore(),
-                                        indexEntries(sip, ns, normalized))
+                                        indexEntries(k, sip, 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.
         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))
 }