Refactor keys and queries in datastore service and implementation.

impl/memory/datastore_index.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 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, Direction: ds.DESCENDING}}})
         }
         if serializationDeterministic {
                 sort.Sort(ret)
         }
         return ret
 }
 
-func indexEntriesWithBuiltins(k ds.Key, pm ds.PropertyMap, complexIdxs []*ds.IndexDefinition) *memStore {
+func indexEntriesWithBuiltins(k *ds.Key, pm ds.PropertyMap, complexIdxs []*ds.IndexDefinition) *memStore {
         sip := partiallySerialize(k, pm)
-        return sip.indexEntries(k.Namespace(), append(defaultIndexes(k.Kind(), pm), complexIdxs...))
+        return sip.indexEntries(k.Namespace(), append(defaultIndexes(k.Last().Kind, pm), complexIdxs...))
 }
 
 // serializedPvals is all of the serialized DSProperty values in qASC order.
 type serializedPvals [][]byte
 
 func (s serializedPvals) Len() int           { return len(s) }
 func (s serializedPvals) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s serializedPvals) Less(i, j int) bool { return bytes.Compare(s[i], s[j]) < 0 }
 
 // prop name -> [<serialized DSProperty>, ...]
@@ skipping 11 matching lines @@
                 data := serialize.ToBytes(v.ForIndex())
                 dataS := string(data)
                 if !dups.Add(dataS) {
                         continue
                 }
                 ret = append(ret, data)
         }
         return ret
 }
 
-func partiallySerialize(k ds.Key, pm ds.PropertyMap) (ret serializedIndexablePmap) {
+func partiallySerialize(k *ds.Key, pm ds.PropertyMap) (ret serializedIndexablePmap) {
         ret = make(serializedIndexablePmap, len(pm)+2)
         if k == nil {
                 impossible(fmt.Errorf("key to partiallySerialize is nil"))
         }
         ret["__key__"] = [][]byte{serialize.ToBytes(ds.MkProperty(k))}
         for k != nil {
                 ret["__ancestor__"] = append(ret["__ancestor__"], serialize.ToBytes(ds.MkProperty(k)))
                 k = k.Parent()
         }
         for k, vals := range pm {
@@ skipping 190 matching lines @@
         }
 
         if allEnts := store.GetCollection("ents:" + ns); allEnts != nil {
                 allEnts.VisitItemsAscend(nil, true, func(i *gkvlite.Item) bool {
                         pm, err := rpmWoCtx(i.Val, ns)
                         memoryCorruption(err)
 
                         prop, err := serialize.ReadProperty(bytes.NewBuffer(i.Key), serialize.WithoutContext, globalAppID, ns)
                         memoryCorruption(err)
 
-                        k := prop.Value().(ds.Key)
+                        k := prop.Value().(*ds.Key)
 
                         sip := partiallySerialize(k, pm)
 
                         mergeIndexes(ns, store,
                                 newMemStore(),
                                 sip.indexEntries(ns, normalized))
                         return true
                 })
         }
 }
 
-func updateIndexes(store *memStore, key ds.Key, oldEnt, newEnt ds.PropertyMap) {
+func updateIndexes(store *memStore, key *ds.Key, oldEnt, newEnt ds.PropertyMap) {
         // load all current complex query index definitions.
         compIdx := []*ds.IndexDefinition{}
         walkCompIdxs(store, nil, func(i *ds.IndexDefinition) bool {
                 compIdx = append(compIdx, i)
                 return true
         })
 
         mergeIndexes(key.Namespace(), store,
                 indexEntriesWithBuiltins(key, oldEnt, compIdx),
                 indexEntriesWithBuiltins(key, newEnt, compIdx))
 }