Add 'user friendly' datastore API.

impl/memory/plist.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"
         "sort"
 
-        rds "github.com/luci/gae/service/rawdatastore"
+        ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gkvlite"
 )
 
 var indexCreationDeterministic = false
 
 type qIndexSlice []*qIndex
 
 func (s qIndexSlice) Len() int           { return len(s) }
 func (s qIndexSlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s qIndexSlice) Less(i, j int) bool { return s[i].Less(s[j]) }
 
-func defaultIndicies(kind string, pmap rds.PropertyMap) []*qIndex {
+func defaultIndicies(kind string, pmap ds.PropertyMap) []*qIndex {
         ret := make(qIndexSlice, 0, 2*len(pmap)+1)
         ret = append(ret, &qIndex{kind, false, nil})
         for name, pvals := range pmap {
                 needsIndex := false
                 for _, v := range pvals {
-                        if v.IndexSetting() == rds.ShouldIndex {
+                        if v.IndexSetting() == ds.ShouldIndex {
                                 needsIndex = true
                                 break
                         }
                 }
                 if !needsIndex {
                         continue
                 }
                 ret = append(ret, &qIndex{kind, false, []qSortBy{{name, qASC}}})
                 ret = append(ret, &qIndex{kind, false, []qSortBy{{name, qDEC}}})
         }
         if indexCreationDeterministic {
                 sort.Sort(ret)
         }
         return ret
 }
 
-func indexEntriesWithBuiltins(k rds.Key, pm rds.PropertyMap, complexIdxs []*qIndex) *memStore {
+func indexEntriesWithBuiltins(k ds.Key, pm ds.PropertyMap, complexIdxs []*qIndex) *memStore {
         sip := partiallySerialize(pm)
         return sip.indexEntries(k, append(defaultIndicies(k.Kind(), pm), complexIdxs...))
 }
 
 // serializedPvals is all of the serialized DSProperty values in qASC order.
 type serializedPvals [][]byte
 
 func (s serializedPvals) Len() int           { return len(s) }
 func (s serializedPvals) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s serializedPvals) Less(i, j int) bool { return bytes.Compare(s[i], s[j]) < 0 }
 
 // prop name -> [<serialized DSProperty>, ...]
 type serializedIndexablePmap map[string]serializedPvals
 
-func partiallySerialize(pm rds.PropertyMap) (ret serializedIndexablePmap) {
+func partiallySerialize(pm ds.PropertyMap) (ret serializedIndexablePmap) {
         if len(pm) == 0 {
                 return
         }
 
         buf := &bytes.Buffer{}
         ret = make(serializedIndexablePmap, len(pm))
         for k, vals := range pm {
                 newVals := make(serializedPvals, 0, len(vals))
                 for _, v := range vals {
-                        if v.IndexSetting() == rds.NoIndex {
+                        if v.IndexSetting() == ds.NoIndex {
                                 continue
                         }
                         buf.Reset()
-                        v.Write(buf, rds.WithoutContext)
+                        v.Write(buf, ds.WithoutContext)
                         newVal := make([]byte, buf.Len())
                         copy(newVal, buf.Bytes())
                         newVals = append(newVals, newVal)
                 }
                 if len(newVals) > 0 {
                         sort.Sort(newVals)
                         ret[k] = newVals
                 }
         }
         return
@@ skipping 81 matching lines @@
                 if pv, ok := sip[sb.prop]; ok {
                         m.buf.propVec = append(m.buf.propVec, pv)
                         m.buf.orders = append(m.buf.orders, sb.dir)
                 } else {
                         return indexRowGen{}, false
                 }
         }
         return m.buf, true
 }
 
-func (sip serializedIndexablePmap) indexEntries(k rds.Key, idxs []*qIndex) *memStore {
+func (sip serializedIndexablePmap) indexEntries(k ds.Key, idxs []*qIndex) *memStore {
         ret := newMemStore()
         idxColl := ret.SetCollection("idx", nil)
         // getIdxEnts retrieves an index collection or adds it if it's not there.
         getIdxEnts := func(qi *qIndex) *memCollection {
                 buf := &bytes.Buffer{}
                 qi.WriteBinary(buf)
                 b := buf.Bytes()
                 idxColl.Set(b, []byte{})
                 return ret.SetCollection(fmt.Sprintf("idx:%s:%s", k.Namespace(), b), nil)
         }
 
         buf := &bytes.Buffer{}
-        rds.WriteKey(buf, rds.WithoutContext, k)
+        ds.WriteKey(buf, ds.WithoutContext, k)
         keyData := buf.Bytes()
 
         walkPermutations := func(prefix []byte, irg indexRowGen, ents *memCollection) {
                 prev := []byte{} // intentionally make a non-nil slice, gkvlite hates nil.
                 irg.permute(func(data []byte) {
                         buf := bytes.NewBuffer(make([]byte, 0, len(prefix)+len(data)+len(keyData)))
                         buf.Write(prefix)
                         buf.Write(data)
                         buf.Write(keyData)
                         ents.Set(buf.Bytes(), prev)
                         prev = data
                 })
         }
 
         mtch := matcher{}
         for _, idx := range idxs {
                 if irg, ok := mtch.match(idx, sip); ok {
                         idxEnts := getIdxEnts(idx)
                         if len(irg.propVec) == 0 {
                                 idxEnts.Set(keyData, []byte{}) // propless index, e.g. kind -> key = nil
                         } else if idx.ancestor {
                                 for ancKey := k; ancKey != nil; ancKey = ancKey.Parent() {
                                         buf := &bytes.Buffer{}
-                                        rds.WriteKey(buf, rds.WithoutContext, ancKey)
+                                        ds.WriteKey(buf, ds.WithoutContext, ancKey)
                                         walkPermutations(buf.Bytes(), irg, idxEnts)
                                 }
                         } else {
                                 walkPermutations(nil, irg, idxEnts)
                         }
                 }
         }
 
         return ret
 }
 
-func updateIndicies(store *memStore, key rds.Key, oldEnt, newEnt rds.PropertyMap) {
+func updateIndicies(store *memStore, key ds.Key, oldEnt, newEnt ds.PropertyMap) {
         idxColl := store.GetCollection("idx")
         if idxColl == nil {
                 idxColl = store.SetCollection("idx", nil)
         }
 
         // load all current complex query index definitions.
         compIdx := []*qIndex{}
         idxColl.VisitItemsAscend(complexQueryPrefix, false, func(i *gkvlite.Item) bool {
                 if !bytes.HasPrefix(i.Key, complexQueryPrefix) {
                         return false
@@ skipping 42 matching lines @@
                                         coll.Set(k, nv)
                                 }
                         })
                 default:
                         panic("impossible")
                 }
                 // TODO(riannucci): remove entries from idxColl and remove index collections
                 // when there are no index entries for that index any more.
         })
 }