impl/memory: Implement Queries

impl/memory/datastore.go

 // Copyright 2015 The Chromium Authors. All rights reserved.

[dnj (Google), 2015/08/23 06:50:07]

Perhaps you already have, but would be worthwhile to fully document (in detail)
the outcome of the immense amount of research that you performed, and
specifically the conditions and rules that AppEngine's queries follow. I know AE
docs cover some of this, but I feel like you can add depths of information to
their overview.

[iannucci, 2015/08/23 18:19:43]

Yeah, it would be. I was thinking about doing that after this lands (as prep for
the brownbag)

 // 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"
 
         "golang.org/x/net/context"
@@ skipping 50 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
+        consistent := rq.eqFilters["__ancestor__"] != nil && !rq.eventualConsistency
+        idx, head := d.data.getQuerySnaps(consistent)
+        return executeQuery(q, 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)
 }
@@ skipping 44 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
 }