Add initial Query generation, correctness checking and index generation.

go/src/infra/gae/libs/wrapper/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 (
         "errors"
         "infra/gae/libs/wrapper"
         goon_internal "infra/gae/libs/wrapper/memory/internal/goon"
@@ skipping 63 matching lines @@
 }
 
 func (d *dataStoreData) Lock() {
         d.rwlock.Lock()
 }
 
 func (d *dataStoreData) Unlock() {
         d.rwlock.Unlock()
 }
 
+/////////////////////////// indicies(dataStoreData) ////////////////////////////
+
 func groupMetaKey(key *datastore.Key) []byte {
         return keyBytes(noNS, newKey("", "__entity_group__", "", 1, rootKey(key)))
 }
 
 func groupIDsKey(key *datastore.Key) []byte {
         return keyBytes(noNS, newKey("", "__entity_group_ids__", "", 1, rootKey(key)))
 }
 
 func rootIDsKey(kind string) []byte {
         return keyBytes(noNS, newKey("", "__entity_root_ids__", kind, 0, nil))
@@ skipping 88 matching lines @@
         defer d.rwlock.Unlock()
 
         ents, key, err := d.entsKeyLocked(key)
         if err != nil {
                 return nil, err
         }
         if _, err = incrementLocked(ents, groupMetaKey(key)); err != nil {
                 return nil, err
         }
 
+        old := ents.Get(keyBytes(noNS, key))
+        oldPl := (*propertyList)(nil)
+        if old != nil {
+                oldPl = &propertyList{}
+                if err = oldPl.UnmarshalBinary(old); err != nil {
+                        return nil, err
+                }
+        }
+        if err = updateIndicies(d.store, key, oldPl, data); err != nil {
+                return nil, err
+        }
+
         ents.Set(keyBytes(noNS, key), dataBytes)
 
         return key, nil
 }
 
 func getInner(ns string, knr goon.KindNameResolver, dst interface{}, getColl func(*datastore.Key) (*memCollection, error)) error {
         key := newKeyObj(ns, knr, dst)
         if !keyValid(ns, key, allowSpecialKeys) {
                 return datastore.ErrInvalidKey
         }
@@ skipping 37 matching lines @@
         defer d.rwlock.Unlock()
 
         ents := d.store.GetCollection("ents:" + ns)
         if ents == nil {
                 return nil
         }
         if _, err := incrementLocked(ents, groupMetaKey(key)); err != nil {
                 return err
         }
 
+        old := ents.Get(keyBuf)
+        oldPl := (*propertyList)(nil)
+        if old != nil {
+                oldPl = &propertyList{}
+                if err := oldPl.UnmarshalBinary(old); err != nil {
+                        return err
+                }
+        }
+        if err := updateIndicies(d.store, key, oldPl, nil); err != nil {
+                return err
+        }
+
         ents.Delete(keyBuf)
         return nil
 }
 
 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 := keyFromByteString(withNS, rk)
+                k, err := keyFromByteString(withNS, rk, "")
                 if err != nil {
                         panic(err)
                 }
                 entKey := "ents:" + k.Namespace()
                 mkey := groupMetaKey(k)
                 entsHead := d.store.GetCollection(entKey)
                 entsSnap := txn.snap.GetCollection(entKey)
                 vHead, err := curVersion(entsHead, mkey)
                 if err != nil {
                         panic(err)
@@ skipping 170 matching lines @@
                 return td.snap.GetCollection("ents:" + ns), nil
         })
 }
 
 func (td *txnDataStoreData) del(ns string, key *datastore.Key) error {
         if !keyValid(ns, key, userKeyOnly) {
                 return datastore.ErrInvalidKey
         }
         return td.writeMutation(false, key, nil)
 }