Refactor a bit.

impl/memory/raw_datastore_query.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"
         "errors"
         "fmt"
         "math"
         "strings"
 
-        "github.com/luci/gae"
-        "github.com/luci/gae/helper"
+        rds "github.com/luci/gae/service/rawdatastore"
         "github.com/luci/gkvlite"
         "github.com/luci/luci-go/common/cmpbin"
 )
 
 type qDirection bool
 
 const (
         qASC qDirection = true
         qDEC            = false
 )
@@ skipping 187 matching lines @@
 
 type queryCursor string
 
 func (q queryCursor) String() string { return string(q) }
 func (q queryCursor) Valid() bool    { return q != "" }
 
 type queryImpl struct {
         ns string
 
         kind     string
-        ancestor gae.DSKey
+        ancestor rds.Key
         filter   []queryFilter
         order    []queryOrder
         project  []string
 
         distinct            bool
         eventualConsistency bool
         keysOnly            bool
         limit               int32
         offset              int32
 
         start queryCursor
         end   queryCursor
 
         err error
 }
 
-var _ gae.DSQuery = (*queryImpl)(nil)
+var _ rds.Query = (*queryImpl)(nil)
 
 type queryIterImpl struct {
         idx *queryImpl
 }
 
-var _ gae.RDSIterator = (*queryIterImpl)(nil)
+var _ rds.Iterator = (*queryIterImpl)(nil)
 
-func (q *queryIterImpl) Cursor() (gae.DSCursor, error) {
+func (q *queryIterImpl) Cursor() (rds.Cursor, error) {
         if q.idx.err != nil {
                 return nil, q.idx.err
         }
         return nil, nil
 }
 
-func (q *queryIterImpl) Next(dst gae.DSPropertyLoadSaver) (gae.DSKey, error) {
+func (q *queryIterImpl) Next(dst rds.PropertyLoadSaver) (rds.Key, error) {
         if q.idx.err != nil {
                 return nil, q.idx.err
         }
         return nil, nil
 }
 
 func (q *queryImpl) normalize() (ret *queryImpl) {
         // ported from GAE SDK datastore_index.py;Normalize()
         ret = q.clone()
 
@@ skipping 114 matching lines @@
         //   "query app is x but ancestor app is x"
         // if ret.ancestor.namespace() != current namespace
         //   "query namespace is x but ancestor namespace is x"
 
         // if not all(g in orders for g in group_by)
         //  "items in the group by clause must be specified first in the ordering"
 
         ineqPropName := ""
         for _, f := range ret.filter {
                 if f.field == "__key__" {
-                        k, ok := f.value.(gae.DSKey)
+                        k, ok := f.value.(rds.Key)
                         if !ok {
                                 ret.err = errors.New(
                                         "gae/memory: __key__ filter value must be a Key")
                                 return
                         }
-                        if !helper.DSKeyValid(k, ret.ns, false) {
+                        if !rds.KeyValid(k, ret.ns, false) {
                                 // See the comment in queryImpl.Ancestor; basically this check
                                 // never happens in the real env because the SDK silently swallows
                                 // this condition :/
-                                ret.err = gae.ErrDSInvalidKey
+                                ret.err = rds.ErrInvalidKey
                                 return
                         }
                         // __key__ filter app is X but query app is X
                         // __key__ filter namespace is X but query namespace is X
                 }
                 // if f.op == qEqual and f.field in ret.project_fields
                 //   "cannot use projection on a proprety with an equality filter"
 
                 if f.op.isINEQOp() {
                         if ineqPropName == "" {
@@ skipping 57 matching lines @@
 }
 
 func (q *queryImpl) clone() *queryImpl {
         ret := *q
         ret.filter = append([]queryFilter(nil), q.filter...)
         ret.order = append([]queryOrder(nil), q.order...)
         ret.project = append([]string(nil), q.project...)
         return &ret
 }
 
-func (q *queryImpl) Ancestor(k gae.DSKey) gae.DSQuery {
+func (q *queryImpl) Ancestor(k rds.Key) rds.Query {
         q = q.clone()
         q.ancestor = k
         if k == nil {
                 // SDK has an explicit nil-check
                 q.err = errors.New("datastore: nil query ancestor")
-        } else if !helper.DSKeyValid(k, q.ns, false) {
+        } else if !rds.KeyValid(k, q.ns, false) {
                 // technically the SDK implementation does a Weird Thing (tm) if both the
                 // stringID and intID are set on a key; it only serializes the stringID in
                 // the proto. This means that if you set the Ancestor to an invalid key,
                 // you'll never actually hear about it. Instead of doing that insanity, we
                 // just swap to an error here.
-                q.err = gae.ErrDSInvalidKey
+                q.err = rds.ErrInvalidKey
         }
         return q
 }
 
-func (q *queryImpl) Distinct() gae.DSQuery {
+func (q *queryImpl) Distinct() rds.Query {
         q = q.clone()
         q.distinct = true
         return q
 }
 
-func (q *queryImpl) Filter(fStr string, val interface{}) gae.DSQuery {
+func (q *queryImpl) Filter(fStr string, val interface{}) rds.Query {
         q = q.clone()
         f, err := parseFilter(fStr, val)
         if err != nil {
                 q.err = err
                 return q
         }
         q.filter = append(q.filter, f)
         return q
 }
 
-func (q *queryImpl) Order(field string) gae.DSQuery {
+func (q *queryImpl) Order(field string) rds.Query {
         q = q.clone()
         field = strings.TrimSpace(field)
         o := queryOrder{field, qASC}
         if strings.HasPrefix(field, "-") {
                 o.direction = qDEC
                 o.field = strings.TrimSpace(field[1:])
         } else if strings.HasPrefix(field, "+") {
                 q.err = fmt.Errorf("datastore: invalid order: %q", field)
                 return q
         }
         if len(o.field) == 0 {
                 q.err = errors.New("datastore: empty order")
                 return q
         }
         q.order = append(q.order, o)
         return q
 }
 
-func (q *queryImpl) Project(fieldName ...string) gae.DSQuery {
+func (q *queryImpl) Project(fieldName ...string) rds.Query {
         q = q.clone()
         q.project = append(q.project, fieldName...)
         return q
 }
 
-func (q *queryImpl) KeysOnly() gae.DSQuery {
+func (q *queryImpl) KeysOnly() rds.Query {
         q = q.clone()
         q.keysOnly = true
         return q
 }
 
-func (q *queryImpl) Limit(limit int) gae.DSQuery {
+func (q *queryImpl) Limit(limit int) rds.Query {
         q = q.clone()
         if limit < math.MinInt32 || limit > math.MaxInt32 {
                 q.err = errors.New("datastore: query limit overflow")
                 return q
         }
         q.limit = int32(limit)
         return q
 }
 
-func (q *queryImpl) Offset(offset int) gae.DSQuery {
+func (q *queryImpl) Offset(offset int) rds.Query {
         q = q.clone()
         if offset < 0 {
                 q.err = errors.New("datastore: negative query offset")
                 return q
         }
         if offset > math.MaxInt32 {
                 q.err = errors.New("datastore: query offset overflow")
                 return q
         }
         q.offset = int32(offset)
         return q
 }
 
-func (q *queryImpl) Start(c gae.DSCursor) gae.DSQuery {
+func (q *queryImpl) Start(c rds.Cursor) rds.Query {
         q = q.clone()
         curs := c.(queryCursor)
         if !curs.Valid() {
                 q.err = errors.New("datastore: invalid cursor")
                 return q
         }
         q.start = curs
         return q
 }
 
-func (q *queryImpl) End(c gae.DSCursor) gae.DSQuery {
+func (q *queryImpl) End(c rds.Cursor) rds.Query {
         q = q.clone()
         curs := c.(queryCursor)
         if !curs.Valid() {
                 q.err = errors.New("datastore: invalid cursor")
                 return q
         }
         q.end = curs
         return q
 }
 
-func (q *queryImpl) EventualConsistency() gae.DSQuery {
+func (q *queryImpl) EventualConsistency() rds.Query {
         q = q.clone()
         q.eventualConsistency = true
         return q
 }