Add AutoIndex

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 47 matching lines @@
         d.data.delMulti(keys, cb)
         return nil
 }
 
 func (d *dsImpl) DecodeCursor(s string) (ds.Cursor, error) {
         return newCursor(s)
 }
 
 func (d *dsImpl) Run(fq *ds.FinalizedQuery, cb ds.RawRunCB) error {
         idx, head := d.data.getQuerySnaps(!fq.EventuallyConsistent())
-        return executeQuery(fq, d.ns, false, idx, head, cb)
+        err := executeQuery(fq, d.ns, false, idx, head, cb)
+        if d.data.maybeAutoIndex(err) {
+                idx, head = d.data.getQuerySnaps(!fq.EventuallyConsistent())
+                err = executeQuery(fq, d.ns, false, idx, head, cb)
+        }
+        return err
 }
 
 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.head, d.ns, idxs)
+        d.data.addIndexes(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))
 }
 
 func (d *dsImpl) CatchupIndexes() {
         d.data.catchupIndexes()
 }
 
 func (d *dsImpl) SetTransactionRetryCount(count int) {
         d.data.setTxnRetry(count)
 }
 
 func (d *dsImpl) Consistent(always bool) {
         d.data.setConsistent(always)
 }
 
+func (d *dsImpl) AutoIndex(enable bool) {
+        d.data.setAutoIndex(enable)
+}
+
 func (d *dsImpl) Testable() ds.Testable {
         return d
 }
 
 ////////////////////////////////// txnDsImpl ///////////////////////////////////
 
 type txnDsImpl struct {
         data *txnDataStoreData
         ns   string
 }
@@ skipping 22 matching lines @@
         return d.data.run(func() error {
                 return d.data.delMulti(keys, cb)
         })
 }
 
 func (d *txnDsImpl) DecodeCursor(s string) (ds.Cursor, error) {
         return newCursor(s)
 }
 
 func (d *txnDsImpl) Run(q *ds.FinalizedQuery, cb ds.RawRunCB) error {
+        // note that autoIndex has no effect inside transactions. This is because
+        // the transaction guarantees a consistent view of head at the time that the
+        // transaction opens. At best, we could add the index on head, but then return
+        // the error anyway, but adding the index then re-snapping at head would
+        // potentially reveal other entities not in the original transaction snapshot.
+        //
+        // It's possible that if you have full-consistency and also auto index enabled
+        // that this would make sense... but at that point you should probably just
+        // add the index up front.
         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 (*txnDsImpl) Testable() ds.Testable {
         return nil
 }