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

impl/memory/datastore_index_selection.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"
@@ skipping 299 matching lines @@
 func generate(q *reducedQuery, idx *indexDefinitionSortable, c *constraints) *iterDefinition {
         def := &iterDefinition{
                 c:     idx.coll,
                 start: q.start,
                 end:   q.end,
         }
         toJoin := make([][]byte, len(idx.eqFilts))
         for _, sb := range idx.eqFilts {
                 val := c.peel(sb.Property)
                 if sb.Descending {
-                        val = invert(val)
+                        val = serialize.Invert(val)
                 }
                 toJoin = append(toJoin, val)
         }
-        def.prefix = bjoin(toJoin...)
+        def.prefix = serialize.Join(toJoin...)
         def.prefixLen = len(def.prefix)
 
         if q.eqFilters["__ancestor__"] != nil && !idx.hasAncestor() {
                 // The query requires an ancestor, but the index doesn't explicitly have it
                 // as part of the prefix (otherwise it would have been the first eqFilt
                 // above). This happens when it's a builtin index, or if it's the primary
                 // index (for a kindless query), or if it's the Kind index (for a filterless
                 // query).
                 //
                 // builtin indexes are:
@@ skipping 12 matching lines @@
                 // Intentionally do NOT update prefixLen. This allows multiIterator to
                 // correctly include the entire key in the shared iterator suffix, instead
                 // of just the remainder.
 
                 // chop the terminal null byte off the q.ancestor key... we can accept
                 // anything which is a descendant or an exact match.  Removing the last byte
                 // from the key (the terminating null) allows this trick to work. Otherwise
                 // it would be a closed range of EXACTLY this key.
                 chopped := []byte(anc[:len(anc)-1])
                 if q.suffixFormat[0].Descending {
-                        chopped = invert(chopped)
+                        chopped = serialize.Invert(chopped)
                 }
-                def.prefix = bjoin(def.prefix, chopped)
+                def.prefix = serialize.Join(def.prefix, chopped)
 
                 // Update start and end, since we know that if they contain anything, they
                 // contain values for the __key__ field.
                 if def.start != nil {
                         offset := 0
                         if len(q.suffixFormat) > 1 {
                                 chunks, _ := parseSuffix(q.ns, q.suffixFormat, def.start, 1)
                                 offset = len(chunks[0])
                         }
                         if !bytes.HasPrefix(def.start[offset:], chopped) {
@@ skipping 161 matching lines @@
                 if bestIdx == nil {
                         // something is really wrong here... if relevantIdxs is !nil, then we
                         // should always be able to make progress in this loop.
                         impossible(fmt.Errorf("deadlock: cannot fulfil query?"))
                 }
                 ret = append(ret, generate(q, bestIdx, constraints))
         }
 
         return ret, nil
 }