impl/memory: Implement Queries

impl/memory/datastore_test.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 (
         "fmt"
         "testing"
 
@@ skipping 121 matching lines @@
                                 keys := make([]dsS.Key, len(foos))
                                 for i, f := range foos {
                                         keys[i] = ds.KeyForObj(&f)
                                 }
 
                                 Convey("ensure that group versions persist across deletes", func() {
                                         So(ds.DeleteMulti(append(keys, k)), ShouldBeNil)
 
                                         // TODO(riannucci): replace with a Count query instead of this cast
                                         /*
-                                                ents := ds.(*dsImpl).data.store.GetCollection("ents:")
+                                                ents := ds.(*dsImpl).data.head.GetCollection("ents:")
                                                 num, _ := ents.GetTotals()
                                                 // /__entity_root_ids__,Foo
                                                 // /Foo,1/__entity_group__,1
                                                 // /Foo,1/__entity_group_ids__,1
                                                 So(num, ShouldEqual, 3)
                                         */
 
                                         So(testGetMeta(c, k), ShouldEqual, 22)
 
                                         So(ds.Put(&Foo{Id: 1}), ShouldBeNil)
@@ skipping 268 matching lines @@
                 })
 
         })
 }
 
 func TestCompoundIndexes(t *testing.T) {
         t.Parallel()
 
         idxKey := func(def dsS.IndexDefinition) string {
                 So(def, ShouldNotBeNil)
-                return "idx::" + string(serialize.ToBytes(def))
+                return "idx::" + string(serialize.ToBytes(*def.PrepForIdxTable()))
         }
 
         numItms := func(c *memCollection) uint64 {
                 ret, _ := c.GetTotals()
                 return ret
         }
 
         Convey("Test Compound indexes", t, func() {
                 type Model struct {
                         ID int64 `gae:"$id"`
 
                         Field1 []string
                         Field2 []int64
                 }
 
                 c := Use(context.Background())
                 ds := dsS.Get(c)
                 t := ds.Raw().Testable().(*dsImpl)
-                store := t.data.store
+                head := t.data.head
 
                 So(ds.Put(&Model{1, []string{"hello", "world"}, []int64{10, 11}}), ShouldBeNil)
 
                 idx := dsS.IndexDefinition{
                         Kind: "Model",
                         SortBy: []dsS.IndexColumn{
                                 {Property: "Field2"},
                         },
                 }
 
-                coll := store.GetCollection(idxKey(idx))
+                coll := head.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 2)
 
                 idx.SortBy[0].Property = "Field1"
-                coll = store.GetCollection(idxKey(idx))
+                coll = head.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 2)
 
                 idx.SortBy = append(idx.SortBy, dsS.IndexColumn{Property: "Field1"})
-                So(store.GetCollection(idxKey(idx)), ShouldBeNil)
+                So(head.GetCollection(idxKey(idx)), ShouldBeNil)
 
                 t.AddIndexes(&idx)
-                coll = store.GetCollection(idxKey(idx))
+                coll = head.GetCollection(idxKey(idx))
                 So(coll, ShouldNotBeNil)
                 So(numItms(coll), ShouldEqual, 4)
         })
 }