impl/memory: Implement Queries

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 199 matching lines @@
         }
         return time.Unix(int64(v/1e6), int64((v%1e6)*1e3)).UTC(), nil
 }
 
 // WriteProperty writes a Property to the buffer. `context` behaves the same
 // 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 {
+        if p.IndexSetting() != ds.NoIndex {
                 typb |= 0x80
         }
         panicIf(buf.WriteByte(typb))
         switch p.Type() {
         case ds.PTNull, ds.PTBoolTrue, ds.PTBoolFalse:
         case ds.PTInt:
                 _, err = cmpbin.WriteInt(buf, p.Value().(int64))
         case ds.PTFloat:
                 _, err = cmpbin.WriteFloat64(buf, p.Value().(float64))
         case ds.PTString:
@@ skipping 19 matching lines @@
 // 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()
         if err != nil {
                 return
         }
         is := ds.ShouldIndex
-        if (typb & 0x80) != 0 {
+        if (typb & 0x80) == 0 {
                 is = ds.NoIndex
         }
         switch ds.PropertyType(typb & 0x7f) {
         case ds.PTNull:
         case ds.PTBoolTrue:
                 val = true
         case ds.PTBoolFalse:
                 val = false
         case ds.PTInt:
                 val, _, err = cmpbin.ReadInt(buf)
@@ skipping 133 matching lines @@
                 c.Direction = ds.DESCENDING
         }
         c.Property, _, err = cmpbin.ReadString(buf)
         return
 }
 
 // WriteIndexDefinition writes an IndexDefinition to the buffer
 func WriteIndexDefinition(buf Buffer, i ds.IndexDefinition) (err error) {
         defer recoverTo(&err)
 
-        if i.Builtin() {
-                panicIf(buf.WriteByte(0))
-        } else {
-                panicIf(buf.WriteByte(1))
-        }
         _, err = cmpbin.WriteString(buf, i.Kind)
         panicIf(err)
         if !i.Ancestor {
                 panicIf(buf.WriteByte(0))
         } else {
                 panicIf(buf.WriteByte(1))
         }
-        _, err = cmpbin.WriteUint(buf, uint64(len(i.SortBy)))
-        panicIf(err)
         for _, sb := range i.SortBy {
+                panicIf(buf.WriteByte(1))
                 panicIf(WriteIndexColumn(buf, sb))
         }
-        return
+        return buf.WriteByte(0)
 }
 
 // ReadIndexDefinition reads an IndexDefinition from the buffer.
 func ReadIndexDefinition(buf Buffer) (i ds.IndexDefinition, err error) {
         defer recoverTo(&err)
 
-        // discard builtin/complex byte
-        _, err = buf.ReadByte()
-        panicIf(err)
-
         i.Kind, _, err = cmpbin.ReadString(buf)
         panicIf(err)
 
         anc, err := buf.ReadByte()
         panicIf(err)
 
         i.Ancestor = anc == 1
 
-        numSorts, _, err := cmpbin.ReadUint(buf)
-        panicIf(err)
+        for {
+                ctrl := byte(0)
+                ctrl, err = buf.ReadByte()
+                panicIf(err)
+                if ctrl == 0 {
+                        break
+                }
+                if len(i.SortBy) > MaxIndexColumns {
+                        err = fmt.Errorf("datastore: Got over %d sort orders", MaxIndexColumns)
+                        return
+                }
 
-        if numSorts > MaxIndexColumns {
-                err = fmt.Errorf("datastore: Got over %d sort orders: %d",
-                        MaxIndexColumns, numSorts)
-                return
-        }
+                sb, err := ReadIndexColumn(buf)
+                panicIf(err)
 
-        if numSorts > 0 {
-                i.SortBy = make([]ds.IndexColumn, numSorts)
-                for idx := range i.SortBy {
-                        i.SortBy[idx], err = ReadIndexColumn(buf)
-                        panicIf(err)
-                }
+                i.SortBy = append(i.SortBy, sb)
         }
 
         return
 }
 
 func toBytesErr(i interface{}, ctx KeyContext) (ret []byte, err error) {
         buf := &bytes.Buffer{}
         switch x := i.(type) {
         case ds.GeoPoint:
                 err = WriteGeoPoint(buf, x)
@@ skipping 82 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }