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 94 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. See serialize.WriteProperty.
 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 > 0x7f {

[dnj (Google), 2015/08/23 06:50:07]

IMO put this check in "serialize", as it owns the code that actually depends on
this condition.

[iannucci, 2015/08/23 18:19:43]

It's better here. There are actually 2 modules that rely on this behavior. I'd
rather keep with the assertion with the data that can cause the assertion
anyway. Otherwise you can change this module, and all will be well, but some
other package will break.

+                panic(
+                        "PTUnknown (and therefore PropertyType) exceeds 0x7f. This conflicts " +
+                                "with serialize.WriteProperty's use of the high bit to indicate " +
+                                "NoIndex.")
+        }
+}
+
 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
 }