Implement projection queries correctly.

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 42 matching lines @@
 
 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>, ...]
 // includes special values '__key__' and '__ancestor__' which contains all of
 // the ancestor entries for this key.
 type serializedIndexablePmap map[string]serializedPvals
 
+func serializeRow(vals []ds.Property) serializedPvals {

[iannucci, 2015/09/10 03:56:58]

This was a convenient refactoring. It'll become more apparently useful in a
future CL.

+        dups := map[string]struct{}{}
+        ret := make(serializedPvals, 0, len(vals))
+        for _, v := range vals {
+                if v.IndexSetting() == ds.NoIndex {
+                        continue
+                }
+                data := serialize.ToBytes(v.ForIndex())
+                dataS := string(data)
+                if _, ok := dups[dataS]; ok {
+                        continue
+                }
+                dups[dataS] = struct{}{}
+                ret = append(ret, data)
+        }
+        return ret
+}
+
 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 {
-                dups := stringSet{}
-                newVals := make(serializedPvals, 0, len(vals))
-                for _, v := range vals {
-                        if v.IndexSetting() == ds.NoIndex {
-                                continue
-                        }
-                        data := serialize.ToBytes(v)
-                        dataS := string(data)
-                        if !dups.add(dataS) {
-                                continue
-                        }
-                        newVals = append(newVals, data)
-                }
+                newVals := serializeRow(vals)
                 if len(newVals) > 0 {
                         ret[k] = newVals
                 }
         }
         return
 }
 
 // indexRowGen contains enough information to generate all of the index rows which
 // correspond with a propertyList and a ds.IndexDefinition.
 type indexRowGen struct {
@@ skipping 203 matching lines @@
         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))
 }