Implement projection queries correctly.

service/datastore/serialize/serialize.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 serialize
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 204 matching lines @@
 // way that it does for WriteKey, but only has an effect if `p` contains a
 // Key as its Value.
 func WriteProperty(buf Buffer, context KeyContext, p ds.Property) (err error) {
         defer recoverTo(&err)
         typb := byte(p.Type())
         if p.IndexSetting() != ds.NoIndex {
                 typb |= 0x80
         }
         panicIf(buf.WriteByte(typb))
         switch p.Type() {
-        case ds.PTNull, ds.PTBoolTrue, ds.PTBoolFalse:
+        case ds.PTNull:
+        case ds.PTBool:
+                b := p.Value().(bool)
+                if b {
+                        err = buf.WriteByte(1)
+                } else {
+                        err = buf.WriteByte(0)
+                }
         case ds.PTInt:
                 _, err = cmpbin.WriteInt(buf, p.Value().(int64))
         case ds.PTFloat:
                 _, err = cmpbin.WriteFloat64(buf, p.Value().(float64))
         case ds.PTString:
                 _, err = cmpbin.WriteString(buf, p.Value().(string))
         case ds.PTBytes:
-                if p.IndexSetting() == ds.NoIndex {
-                        _, err = cmpbin.WriteBytes(buf, p.Value().([]byte))
-                } else {
-                        _, err = cmpbin.WriteBytes(buf, p.Value().(ds.ByteString))
-                }
+                _, err = cmpbin.WriteBytes(buf, p.Value().([]byte))
         case ds.PTTime:
                 err = WriteTime(buf, p.Value().(time.Time))
         case ds.PTGeoPoint:
                 err = WriteGeoPoint(buf, p.Value().(ds.GeoPoint))
         case ds.PTKey:
                 err = WriteKey(buf, context, p.Value().(ds.Key))
         case ds.PTBlobKey:
                 _, err = cmpbin.WriteString(buf, string(p.Value().(blobstore.Key)))
         }
         return
 }
 
 // ReadProperty reads a Property from the buffer. `context`, `appid`, and
 // `namespace` behave the same way they do for ReadKey, but only have an
 // effect if the decoded property has a Key value.
 func ReadProperty(buf Buffer, context KeyContext, appid, namespace string) (p ds.Property, err error) {
         val := interface{}(nil)
-        typb, err := buf.ReadByte()
+        b, err := buf.ReadByte()
         if err != nil {
                 return
         }
         is := ds.ShouldIndex
-        if (typb & 0x80) == 0 {
+        if (b & 0x80) == 0 {
                 is = ds.NoIndex
         }
-        switch ds.PropertyType(typb & 0x7f) {
+        switch ds.PropertyType(b & 0x7f) {
         case ds.PTNull:
-        case ds.PTBoolTrue:
-                val = true
-        case ds.PTBoolFalse:
-                val = false
+        case ds.PTBool:
+                b, err = buf.ReadByte()
+                val = (b != 0)
         case ds.PTInt:
                 val, _, err = cmpbin.ReadInt(buf)
         case ds.PTFloat:
                 val, _, err = cmpbin.ReadFloat64(buf)
         case ds.PTString:
                 val, _, err = cmpbin.ReadString(buf)
         case ds.PTBytes:
-                b := []byte(nil)
-                if b, _, err = cmpbin.ReadBytes(buf); err != nil {
-                        break
-                }
-                if is == ds.NoIndex {
-                        val = b
-                } else {
-                        val = ds.ByteString(b)
-                }
+                val, _, err = cmpbin.ReadBytes(buf)
         case ds.PTTime:
                 val, err = ReadTime(buf)
         case ds.PTGeoPoint:
                 val, err = ReadGeoPoint(buf)
         case ds.PTKey:
                 val, err = ReadKey(buf, context, appid, namespace)
         case ds.PTBlobKey:
                 s := ""
                 if s, _, err = cmpbin.ReadString(buf); err != nil {
                         break
                 }
                 val = blobstore.Key(s)
         default:
-                err = fmt.Errorf("read: unknown type! %v", typb)
+                err = fmt.Errorf("read: unknown type! %v", b)
         }
         if err == nil {
                 err = p.SetValue(val, is)
         }
         return
 }
 
 // WritePropertyMap writes an entire PropertyMap to the buffer. `context` behaves the same
 // way that it does for WriteKey. If WritePropertyMapDeterministic is true, then
 // the rows will be sorted by property name before they're serialized to buf
@@ skipping 239 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }