impl/memory: Implement Queries

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"
@@ skipping 80 matching lines @@
 
 func rootIDsKey(kind string) []byte {
         return keyBytes(serialize.WithoutContext,
                 dskey.New("", "", "__entity_root_ids__", kind, 0, nil))
 }
 
 func curVersion(ents *memCollection, key []byte) int64 {
         if ents != nil {
                 if v := ents.Get(key); v != nil {
                         pm, err := rpm(v)
-                        if err != nil {
-                                panic(err) // memory corruption
-                        }
+                        memoryCorruption(err)
+
                         pl, ok := pm["__version__"]
                         if ok && len(pl) > 0 && pl[0].Type() == ds.PTInt {
                                 return pl[0].Value().(int64)
                         }
-                        panic(fmt.Errorf("__version__ property missing or wrong: %v", pm))
+
+                        memoryCorruption(fmt.Errorf("__version__ property missing or wrong: %v", pm))
                 }
         }
         return 0
 }
 
 func incrementLocked(ents *memCollection, key []byte) int64 {
         ret := curVersion(ents, key) + 1
         buf := &bytes.Buffer{}
         serialize.WritePropertyMap(buf, serialize.WithContext, ds.PropertyMap{
                 "__version__": {ds.MkPropertyNI(ret)}})
@@ skipping 121 matching lines @@
 
 func (d *dataStoreData) canApplyTxn(obj memContextObj) bool {
         // TODO(riannucci): implement with Flush/FlushRevert for persistance.
 
         txn := obj.(*txnDataStoreData)
         for rk, muts := range txn.muts {
                 if len(muts) == 0 { // read-only
                         continue
                 }
                 k, err := serialize.ReadKey(bytes.NewBufferString(rk), serialize.WithContext, "", "")
-                if err != nil {
-                        panic(err)
-                }
+                memoryCorruption(err)
 
                 entKey := "ents:" + k.Namespace()
                 mkey := groupMetaKey(k)
                 entsHead := d.store.GetCollection(entKey)
                 entsSnap := txn.snap.GetCollection(entKey)
                 vHead := curVersion(entsHead, mkey)
                 vSnap := curVersion(entsSnap, mkey)
                 if vHead != vSnap {
                         return false
                 }
@@ skipping 11 matching lines @@
                 for _, m := range muts {
                         err := error(nil)
                         k := m.key
                         if m.data == nil {
                                 d.delMulti([]ds.Key{k},
                                         func(e error) { err = e })
                         } else {
                                 d.putMulti([]ds.Key{m.key}, []ds.PropertyMap{m.data},
                                         func(_ ds.Key, e error) { err = e })
                         }
-                        err = errors.SingleError(err)
-                        if err != nil {
-                                panic(err)
-                        }
+                        impossible(err)
                 }
         }
 }
 
 func (d *dataStoreData) mkTxn(o *ds.TransactionOptions) memContextObj {
         return &txnDataStoreData{
                 // alias to the main datastore's so that testing code can have primitive
                 // access to break features inside of transactions.
                 parent: d,
                 isXG:   o != nil && o.XG,
@@ skipping 33 matching lines @@
 const xgEGLimit = 25
 
 func (*txnDataStoreData) canApplyTxn(memContextObj) bool { return false }
 func (td *txnDataStoreData) endTxn() {
         if atomic.LoadInt32(&td.closed) == 1 {
                 panic("cannot end transaction twice")
         }
         atomic.StoreInt32(&td.closed, 1)
 }
 func (*txnDataStoreData) applyTxn(context.Context, memContextObj) {
-        panic("txnDataStoreData cannot apply transactions")
+        impossible(fmt.Errorf("cannot creat a recursive transaction"))
 }
 func (*txnDataStoreData) mkTxn(*ds.TransactionOptions) memContextObj {
-        panic("impossible")
+        impossible(fmt.Errorf("cannot creat a recursive transaction"))
+        return nil
 }
 
 func (td *txnDataStoreData) run(f func() error) error {
         // Slightly different from the SDK... datastore and taskqueue each implement
         // this here, where in the SDK only datastore.transaction.Call does.
         if atomic.LoadInt32(&td.closed) == 1 {
                 return errors.New("datastore: transaction context has expired")
         }
         return f()
 }
@@ skipping 85 matching lines @@
 }
 
 func rpm(data []byte) (ds.PropertyMap, error) {
         return serialize.ReadPropertyMap(bytes.NewBuffer(data),
                 serialize.WithContext, "", "")
 }
 
 type keyitem interface {
         Key() ds.Key
 }