Refactor serialization helpers from impl/memory -> service/datastore/serialize

impl/memory/datastore_query_execution.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"
 
@@ skipping 55 matching lines @@
                 projectedRaw = make([][]byte, len(decodedProps))
         }
         pmap := make(ds.PropertyMap, len(s.project))
         for i, p := range s.project {
                 if s.distinct != nil {
                         projectedRaw[i] = rawData[p.suffixIndex]
                 }
                 pmap[p.propertyName] = []ds.Property{decodedProps[p.suffixIndex]}
         }
         if s.distinct != nil {
-                if !s.distinct.Add(string(bjoin(projectedRaw...))) {
+                if !s.distinct.Add(string(serialize.Join(projectedRaw...))) {
                         return true
                 }
         }
         return s.cb(key, pmap, gc)
 }
 
 type keysOnlyStrategy struct {
         cb ds.RawRunCB
 
         dedup stringset.Set
@@ skipping 62 matching lines @@
                 needInvert := suffixFormat[i].Descending
 
                 buf.SetInvert(needInvert)
                 decoded[i], err = serialize.ReadProperty(buf, serialize.WithoutContext, globalAppID, ns)
                 memoryCorruption(err)
 
                 offset := len(suffix) - buf.Len()
                 raw[i] = suffix[:offset]
                 suffix = suffix[offset:]
                 if needInvert {
-                        raw[i] = invert(raw[i])
+                        raw[i] = serialize.Invert(raw[i])
                 }
         }
 
         return
 }
 
 func executeQuery(fq *ds.FinalizedQuery, ns string, isTxn bool, idx, head *memStore, cb ds.RawRunCB) error {
         rq, err := reduce(fq, ns, isTxn)
         if err == ds.ErrNullQuery {
                 return nil
@@ skipping 29 matching lines @@
                                 memoryCorruption(err)
 
                                 for _, col := range rq.suffixFormat {
                                         err := serialize.WriteIndexColumn(buf, col)
                                         memoryCorruption(err)
                                 }
                                 cursorPrefix = buf.Bytes()
                         }
                         // TODO(riannucci): Do we need to decrement suffix instead of increment
                         // if we're sorting by __key__ DESCENDING?
-                        return queryCursor(bjoin(cursorPrefix, increment(suffix))), nil
+                        return queryCursor(serialize.Join(cursorPrefix, increment(suffix))), nil
                 }
         }
 
         multiIterate(idxs, func(suffix []byte) bool {
                 if offset > 0 {
                         offset--
                         return true
                 }
                 if hasLimit {
                         if limit <= 0 {
                                 return false
                         }
                         limit--
                 }
 
                 rawData, decodedProps := parseSuffix(ns, rq.suffixFormat, suffix, -1)
 
                 keyProp := decodedProps[len(decodedProps)-1]
                 if keyProp.Type() != ds.PTKey {
                         impossible(fmt.Errorf("decoded index row doesn't end with a Key: %#v", keyProp))
                 }
 
                 return strategy.handle(
                         rawData, decodedProps, keyProp.Value().(*ds.Key),
                         getCursorFn(suffix))
         })
 
         return nil
 }