Add AutoIndex

impl/memory/datastore_data.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"
         "sync"
         "sync/atomic"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/luci-go/common/errors"
         "golang.org/x/net/context"
 )
 
 //////////////////////////////// dataStoreData /////////////////////////////////
 
 type dataStoreData struct {
         rwlock sync.RWMutex
         // See README.md for head schema.
         head *memStore
         snap *memStore
         // For testing, see SetTransactionRetryCount.
         txnFakeRetry int
         // true means that head always == snap
         consistent bool
+        // true means that queries with insufficent indexes will pause to add them
+        // and then continue instead of failing.
+        autoIndex bool
 }
 
 var (
         _ = memContextObj((*dataStoreData)(nil))
         _ = sync.Locker((*dataStoreData)(nil))
 )
 
 func newDataStoreData() *dataStoreData {
         head := newMemStore()
         return &dataStoreData{
@@ skipping 19 matching lines @@
 func (d *dataStoreData) setConsistent(always bool) {
         d.Lock()
         defer d.Unlock()
 
         d.consistent = always
         if d.consistent {
                 d.snap = d.head.Snapshot()
         }
 }
 
+func (d *dataStoreData) addIndexes(ns string, idxs []*ds.IndexDefinition) {
+        d.Lock()
+        defer d.Unlock()
+        addIndexes(d.head, ns, idxs)
+        if d.consistent {
+                d.snap = d.head.Snapshot()
+        }
+}
+
+func (d *dataStoreData) setAutoIndex(enable bool) {
+        d.Lock()
+        defer d.Unlock()
+        d.autoIndex = enable
+}
+
+func (d *dataStoreData) maybeAutoIndex(err error) bool {
+        mi, ok := err.(*ErrMissingIndex)
+        if !ok {
+                return false
+        }
+
+        d.rwlock.RLock()
+        ai := d.autoIndex
+        d.rwlock.RUnlock()
+
+        if !ai {
+                return false
+        }
+
+        d.addIndexes(mi.ns, []*ds.IndexDefinition{mi.Missing})
+        return true
+}
+
 func (d *dataStoreData) getQuerySnaps(consistent bool) (idx, head *memStore) {
         d.rwlock.RLock()
         defer d.rwlock.RUnlock()
         if d.consistent {
                 // snap is already a consistent snapshot of head
                 return d.snap, d.snap
         }
 
         head = d.head.Snapshot()
         if consistent {
@@ skipping 410 matching lines @@
 
 func rpmWoCtx(data []byte, ns string) (ds.PropertyMap, error) {
         return serialize.ReadPropertyMap(bytes.NewBuffer(data),
                 serialize.WithoutContext, globalAppID, ns)
 }
 
 func rpm(data []byte) (ds.PropertyMap, error) {
         return serialize.ReadPropertyMap(bytes.NewBuffer(data),
                 serialize.WithContext, "", "")
 }