Split off serialization and key functions to their own packages.

impl/memory/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"
 
         ds "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/datastore/serialize"
 )
 
 const MaxQueryComponents = 100
 
 var errQueryDone = errors.New("query is done")
 
 type queryOp int
 
 const (
         qInvalid queryOp = iota
@@ skipping 214 matching lines @@
         return &nq
 }
 
 func (q *queryImpl) Ancestor(k ds.Key) ds.Query {
         return q.checkMutateClone(
                 func() error {
                         if k == nil {
                                 // SDK has an explicit nil-check
                                 return errors.New("datastore: nil query ancestor")
                         }
-                        if !ds.KeyValid(k, false, globalAppID, q.ns) {
+                        if !k.Valid(false, globalAppID, q.ns) {
                                 // 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.
                                 return ds.ErrInvalidKey
                         }
                         if k.Namespace() != q.ns {
                                 return fmt.Errorf("bad namespace: %q (expected %q)", k.Namespace(), q.ns)
                         }
@@ skipping 30 matching lines @@
                                         "kindless queries can only filter on __key__, got %q", fStr)
                         }
 
                         p := ds.Property{}
                         err = p.SetValue(val, ds.NoIndex)
                         if err != nil {
                                 return err
                         }
 
                         if p.Type() == ds.PTKey {
-                                if !ds.KeyValid(p.Value().(ds.Key), false, globalAppID, q.ns) {
+                                if !p.Value().(ds.Key).Valid(false, globalAppID, q.ns) {
                                         return ds.ErrInvalidKey
                                 }
                         }
 
-                        buf := &bytes.Buffer{}
-                        p.Write(buf, ds.WithoutContext)
+                        binVal = string(serialize.ToBytes(p))
 
                         if prop == "__key__" {
                                 if op == qEqual {
                                         return fmt.Errorf(
                                                 "query equality filter on __key__ is silly: %q", fStr)
                                 }
                                 if p.Type() != ds.PTKey {
                                         return fmt.Errorf("__key__ filter value is not a key: %T", val)
                                 }
                         }
 
                         if op != qEqual {
                                 if q.ineqFilter.prop != "" && q.ineqFilter.prop != prop {
                                         return fmt.Errorf(
                                                 "inequality filters on multiple properties: %q and %q",
                                                 q.ineqFilter.prop, prop)
                                 }
                                 if len(q.order) > 0 && q.order[0].Property != prop {
                                         return fmt.Errorf(
                                                 "first sort order must match inequality filter: %q v %q",
                                                 q.order[0].Property, prop)
                                 }
                         } else if _, ok := q.project[prop]; ok {
                                 return fmt.Errorf(
                                         "cannot project on field which is used in an equality filter: %q",
                                         prop)
                         }
-                        binVal = buf.String()
                         return
                 },
                 func(q *queryImpl) {
                         if op == qEqual {
                                 // add it to eq filters
                                 if _, ok := q.eqFilters[prop]; !ok {
                                         q.eqFilters[prop] = map[string]struct{}{binVal: {}}
                                 } else {
                                         q.eqFilters[prop][binVal] = struct{}{}
                                 }
@@ skipping 170 matching lines @@
                         q.end = curs
                 })
 }
 
 func (q *queryImpl) EventualConsistency() ds.Query {
         return q.checkMutateClone(
                 nil, func(q *queryImpl) {
                         q.eventualConsistency = true
                 })
 }