impl/memory: Implement Queries

service/datastore/properties.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 datastore
 
 import (
         "errors"
         "fmt"
         "math"
@@ skipping 93 matching lines @@
 
 // PropertyType is a single-byte representation of the type of data contained
 // in a Property. The specific values of this type information are chosen so
 // that the types sort according to the order of types as sorted by the
 // datastore.
 type PropertyType byte
 
 // These constants are in the order described by
 //   https://cloud.google.com/appengine/docs/go/datastore/entities#Go_Value_type_ordering
 // with a slight divergence for the Int/Time split.
+//
 // NOTE: this enum can only occupy 7 bits, because we use the high bit to encode
-// indexed/non-indexed. See typData.WriteBinary.
+// indexed/non-indexed, and we additionally require that all valid values and
+// all INVERTED valid values must never equal 0xFF or 0x00. The reason for this
+// constraint is that we must always be able to create a byte that sorts before
+// and after it.
+//
+// See "./serialize".WriteProperty and "impl/memory".increment for more info.
 const (
         PTNull PropertyType = iota
         PTInt
 
         // PTTime is a slight divergence from the way that datastore natively stores
         // time. In datastore, times and integers actually sort together
         // (apparently?). This is probably insane, and I don't want to add the
         // complexity of field 'meaning' as a sparate concept from the field's 'type'
         // (which is what datastore seems to do, judging from the protobufs). So if
         // you're here because you implemented an app which relies on time.Time and
@@ skipping 13 matching lines @@
         PTBoolFalse
         PTBoolTrue
 
         PTBytes  // []byte or datastore.ByteString
         PTString // string or string noindex
         PTFloat
         PTGeoPoint
         PTKey
         PTBlobKey
 
+        // NOTE: THIS MUST BE LAST VALUE FOR THE init() ASSERTION BELOW TO WORK.
         PTUnknown
 )
 
+func init() {
+        if PTUnknown > 0x7e {
+                panic(
+                        "PTUnknown (and therefore PropertyType) exceeds 0x7e. This conflicts " +
+                                "with serialize.WriteProperty's use of the high bit to indicate " +
+                                "NoIndex and/or \"impl/memory\".increment's ability to guarantee " +
+                                "incrementability.")
+        }
+}
+
 func (t PropertyType) String() string {
         switch t {
         case PTNull:
                 return "PTNull"
         case PTInt:
                 return "PTInt"
         case PTTime:
                 return "PTTime"
         case PTBoolFalse:
                 return "PTBoolFalse"
@@ skipping 336 matching lines @@
         dflt = UpconvertUnderlyingType(dflt)
         cur, err := gm(key)
         if err != nil {
                 return dflt
         }
         if dflt != nil && reflect.TypeOf(cur) != reflect.TypeOf(dflt) {
                 return dflt
         }
         return cur
 }