impl/memory: Fix time serialization encoding.

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"
         "encoding/base64"
         "errors"
@@ skipping 89 matching lines @@
                 numComponents += v.Len()
         }
         return numComponents
 }
 
 // GetBinaryBounds gets the binary encoding of the upper and lower bounds of
 // the inequality filter on fq, if any is defined. If a bound does not exist,
 // it is nil.
 //
 // NOTE: if fq specifies a descending sort order for the inequality, the bounds
-// will be inverted, incremented, and fliped.
+// will be inverted, incremented, and flipped.
 func GetBinaryBounds(fq *ds.FinalizedQuery) (lower, upper []byte) {
         // Pick up the start/end range from the inequalities, if any.
         //
         // start and end in the reducedQuery are normalized so that `start >=
         // X < end`. Because of that, we need to tweak the inequality filters
         // contained in the query if they use the > or <= operators.
         if ineqProp := fq.IneqFilterProp(); ineqProp != "" {
                 _, startOp, startV := fq.IneqFilterLow()
                 if startOp != "" {
-                        lower = serialize.ToBytes(startV)
+                        lower = serialize.ToBytes(startV.ForIndex())
                         if startOp == ">" {
                                 lower = increment(lower)
                         }
                 }
 
                 _, endOp, endV := fq.IneqFilterHigh()
                 if endOp != "" {
-                        upper = serialize.ToBytes(endV)
+                        upper = serialize.ToBytes(endV.ForIndex())
                         if endOp == "<=" {
                                 upper = increment(upper)
                         }
                 }
 
                 // The inequality is specified in natural (ascending) order in the query's
                 // Filter syntax, but the order information may indicate to use a descending
                 // index column for it. If that's the case, then we must invert, swap and
                 // increment the inequality endpoints.
                 //
@@ skipping 34 matching lines @@
                 ns:           ns,
                 kind:         fq.Kind(),
                 suffixFormat: fq.Orders(),
         }
 
         eqFilts := fq.EqFilters()
         ret.eqFilters = make(map[string]stringset.Set, len(eqFilts))
         for prop, vals := range eqFilts {
                 sVals := stringset.New(len(vals))
                 for _, v := range vals {
-                        sVals.Add(string(serialize.ToBytes(v)))
+                        sVals.Add(string(serialize.ToBytes(v.ForIndex())))
                 }
                 ret.eqFilters[prop] = sVals
         }
 
         startD, endD := GetBinaryBounds(fq)
 
         // Now we check the start and end cursors.
         //
         // Cursors are composed of a list of IndexColumns at the beginning, followed
         // by the raw bytes to use for the suffix. The cursor is only valid if all of
@@ skipping 76 matching lines @@
                 // and the new value has overflowed this representation.
                 //
                 // Fortunately, the first byte of a serialized index column entry is a
                 // PropertyType byte, and the only valid values that we'll be incrementing
                 // are never equal to 0xFF, since they have the high bit set (so either they're
                 // 0x8*, or 0x7*, depending on if it's inverted).
                 impossible(fmt.Errorf("incrementing %v would require more sigfigs", bstr))
         }
         return ret
 }