impl/memory: Implement Queries

impl/memory/datastore.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 (
         "errors"
         "fmt"
 
@@ skipping 51 matching lines @@
 func (d *dsImpl) DeleteMulti(keys []ds.Key, cb ds.DeleteMultiCB) error {
         d.data.delMulti(keys, cb)
         return nil
 }
 
 func (d *dsImpl) NewQuery(kind string) ds.Query {
         return &queryImpl{ns: d.ns, kind: kind}
 }
 
 func (d *dsImpl) DecodeCursor(s string) (ds.Cursor, error) {
-        return decodeCursor(s)
+        return newCursor(s)
 }
 
-func (d *dsImpl) Run(q ds.Query, cb ds.RawRunCB) error {
-        rq := q.(*queryImpl)
-        done, err := rq.valid(d.ns, true)
-        if done || err != nil {
-                return err // will be nil if done
-        }
-        return nil
+func (d *dsImpl) Run(qi ds.Query, cb ds.RawRunCB) error {
+        q := qi.(*queryImpl)
+        consistent := q.eqFilters["__ancestor__"] != nil && !q.eventualConsistency
+        idx, head := d.data.getQuerySnaps(consistent)
+        return executeQuery(qi, d.ns, false, idx, head, cb)
 }
 
 func (d *dsImpl) AddIndexes(idxs ...*ds.IndexDefinition) {
+        if len(idxs) == 0 {
+                return
+        }
+
         for _, i := range idxs {
                 if !i.Compound() {
                         panic(fmt.Errorf("Attempted to add non-compound index: %s", i))
                 }
         }
 
         d.data.Lock()
         defer d.data.Unlock()
-        addIndex(d.data.store, d.ns, idxs)
+        addIndex(d.data.head, d.ns, idxs)
 }
 
 func (d *dsImpl) TakeIndexSnapshot() ds.TestingSnapshot {
         return d.data.takeSnapshot()
 }
 
 func (d *dsImpl) SetIndexSnapshot(snap ds.TestingSnapshot) {
         d.data.setSnapshot(snap.(*memStore))
 }
 
@@ skipping 35 matching lines @@
         })
 }
 
 func (d *txnDsImpl) DeleteMulti(keys []ds.Key, cb ds.DeleteMultiCB) error {
         return d.data.run(func() error {
                 return d.data.delMulti(keys, cb)
         })
 }
 
 func (d *txnDsImpl) DecodeCursor(s string) (ds.Cursor, error) {
-        return decodeCursor(s)
+        return newCursor(s)
 }
 
 func (d *txnDsImpl) Run(q ds.Query, cb ds.RawRunCB) error {
-        rq := q.(*queryImpl)
-        done, err := rq.valid(d.ns, true)
-        if done || err != nil {
-                return err // will be nil if done
-        }
-        if rq.eventualConsistency {
-                rq = rq.checkMutateClone(nil, nil)
-                rq.eventualConsistency = false
-        }
-        // TODO(riannucci): use head instead of snap for indexes
-        panic("NOT IMPLEMENTED")
+        return executeQuery(q, d.ns, true, d.data.snap, d.data.snap, cb)
 }
 
 func (*txnDsImpl) RunInTransaction(func(c context.Context) error, *ds.TransactionOptions) error {
         return errors.New("datastore: nested transactions are not supported")
 }
 
 func (d *txnDsImpl) NewQuery(kind string) ds.Query {
         return &queryImpl{ns: d.ns, kind: kind}
 }
 
 func (*txnDsImpl) Testable() ds.Testable {
         return nil
 }