Refactor keys and queries in datastore service and implementation.

service/datastore/serialize/serialize.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 serialize
 
 import (
         "bytes"
         "errors"
         "fmt"
         "sort"
         "time"
 
         "github.com/luci/gae/service/blobstore"
         ds "github.com/luci/gae/service/datastore"
-        "github.com/luci/gae/service/datastore/dskey"
         "github.com/luci/luci-go/common/cmpbin"
 )
 
 // MaxIndexColumns is the maximum number of sort columns (e.g. sort orders) that
 // ReadIndexDefinition is willing to deserialize. 64 was chosen as
 // a likely-astronomical number.
 const MaxIndexColumns = 64
 
 // WritePropertyMapDeterministic allows tests to make WritePropertyMap
 // deterministic.
@@ skipping 17 matching lines @@
 
 // With- and WithoutContext indicate if the serialization method should include
 // context for Keys. See KeyContext for more information.
 const (
         WithContext    KeyContext = true
         WithoutContext            = false
 )
 
 // WriteKey encodes a key to the buffer. If context is WithContext, then this
 // encoded value will include the appid and namespace of the key.
-func WriteKey(buf Buffer, context KeyContext, k ds.Key) (err error) {
+func WriteKey(buf Buffer, context KeyContext, k *ds.Key) (err error) {
         // [appid ++ namespace]? ++ [1 ++ token]* ++ NULL
         defer recoverTo(&err)
-        appid, namespace, toks := dskey.Split(k)
+        appid, namespace, toks := k.Split()
         if context == WithContext {
                 panicIf(buf.WriteByte(1))
                 _, e := cmpbin.WriteString(buf, appid)
                 panicIf(e)
                 _, e = cmpbin.WriteString(buf, namespace)
                 panicIf(e)
         } else {
                 panicIf(buf.WriteByte(0))
         }
         for _, tok := range toks {
                 panicIf(buf.WriteByte(1))
                 panicIf(WriteKeyTok(buf, tok))
         }
         return buf.WriteByte(0)
 }
 
 // ReadKey deserializes a key from the buffer. The value of context must match
 // the value of context that was passed to WriteKey when the key was encoded.
 // If context == WithoutContext, then the appid and namespace parameters are
 // used in the decoded Key. Otherwise they're ignored.
-func ReadKey(buf Buffer, context KeyContext, appid, namespace string) (ret ds.Key, err error) {
+func ReadKey(buf Buffer, context KeyContext, appid, namespace string) (ret *ds.Key, err error) {
         defer recoverTo(&err)
         actualCtx, e := buf.ReadByte()
         panicIf(e)
 
         actualAid, actualNS := "", ""
         if actualCtx == 1 {
                 actualAid, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
                 actualNS, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
@@ skipping 21 matching lines @@
                                 ReadKeyNumToksReasonableLimit)
                         return
                 }
 
                 tok, e := ReadKeyTok(buf)
                 panicIf(e)
 
                 toks = append(toks, tok)
         }
 
-        return dskey.NewToks(actualAid, actualNS, toks), nil
+        return ds.NewKeyToks(actualAid, actualNS, toks), nil
 }
 
 // WriteKeyTok writes a KeyTok to the buffer. You usually want WriteKey
 // instead of this.
 func WriteKeyTok(buf Buffer, tok ds.KeyTok) (err error) {
         // tok.kind ++ typ ++ [tok.stringID || tok.intID]
         defer recoverTo(&err)
         _, e := cmpbin.WriteString(buf, tok.Kind)
         panicIf(e)
         if tok.StringID != "" {
@@ skipping 105 matching lines @@
                 _, err = cmpbin.WriteFloat64(buf, p.Value().(float64))
         case ds.PTString:
                 _, err = cmpbin.WriteString(buf, p.Value().(string))
         case ds.PTBytes:
                 _, err = cmpbin.WriteBytes(buf, p.Value().([]byte))
         case ds.PTTime:
                 err = WriteTime(buf, p.Value().(time.Time))
         case ds.PTGeoPoint:
                 err = WriteGeoPoint(buf, p.Value().(ds.GeoPoint))
         case ds.PTKey:
-                err = WriteKey(buf, context, p.Value().(ds.Key))
+                err = WriteKey(buf, context, p.Value().(*ds.Key))
         case ds.PTBlobKey:
                 _, err = cmpbin.WriteString(buf, string(p.Value().(blobstore.Key)))
         }
         return
 }
 
 // ReadProperty reads a Property from the buffer. `context`, `appid`, and
 // `namespace` behave the same way they do for ReadKey, but only have an
 // effect if the decoded property has a Key value.
 func ReadProperty(buf Buffer, context KeyContext, appid, namespace string) (p ds.Property, err error) {
@@ skipping 111 matching lines @@
                 }
                 pm[name] = props
         }
         return
 }
 
 // WriteIndexColumn writes an IndexColumn to the buffer.
 func WriteIndexColumn(buf Buffer, c ds.IndexColumn) (err error) {
         defer recoverTo(&err)
 
-        if c.Direction == ds.ASCENDING {
+        if !c.Descending {
                 panicIf(buf.WriteByte(0))
         } else {
                 panicIf(buf.WriteByte(1))
         }
         _, err = cmpbin.WriteString(buf, c.Property)
         return
 }
 
 // ReadIndexColumn reads an IndexColumn from the buffer.
 func ReadIndexColumn(buf Buffer) (c ds.IndexColumn, err error) {
         defer recoverTo(&err)
 
         dir, err := buf.ReadByte()
         panicIf(err)
 
-        switch dir {
-        case 0:
-                c.Direction = ds.ASCENDING
-        default:
-                c.Direction = ds.DESCENDING
-        }
+        c.Descending = dir != 0
         c.Property, _, err = cmpbin.ReadString(buf)
         return
 }
 
 // WriteIndexDefinition writes an IndexDefinition to the buffer
 func WriteIndexDefinition(buf Buffer, i ds.IndexDefinition) (err error) {
         defer recoverTo(&err)
 
         _, err = cmpbin.WriteString(buf, i.Kind)
         panicIf(err)
@@ skipping 47 matching lines @@
         switch x := i.(type) {
         case ds.GeoPoint:
                 err = WriteGeoPoint(buf, x)
 
         case ds.IndexColumn:
                 err = WriteIndexColumn(buf, x)
 
         case ds.IndexDefinition:
                 err = WriteIndexDefinition(buf, x)
 
-        case ds.Key:
+        case *ds.Key:
                 err = WriteKey(buf, ctx, x)
 
         case ds.KeyTok:
                 err = WriteKeyTok(buf, x)
 
         case ds.Property:
                 err = WriteProperty(buf, ctx, x)
 
         case ds.PropertyMap:
                 err = WritePropertyMap(buf, ctx, x)
@@ skipping 64 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }