Add testable interface for datastore.

service/datastore/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 datastore
 
 import (
         "bytes"
         "errors"
         "fmt"
         "sort"
         "time"
 
         "github.com/luci/gae/service/blobstore"
         "github.com/luci/luci-go/common/cmpbin"
 )
 
+// MaxIndexColumns is the maximum number of sort orders you may have on a
+// single composite index. 64 was chosen as a likely-astronomical number.
+const MaxIndexColumns = 64
+
 // WritePropertyMapDeterministic allows tests to make WritePropertyMap
 // deterministic.
 var WritePropertyMapDeterministic = false
 
 // ReadPropertyMapReasonableLimit sets a limit on the number of rows and
 // number of properties per row which can be read by ReadPropertyMap. The
 // total number of Property objects readable by this method is this number
 // squared (e.g. Limit rows * Limit properties)
 const ReadPropertyMapReasonableLimit uint64 = 30000
 
@@ skipping 330 matching lines @@
                 props := make([]Property, 0, numProps)
                 for j := uint64(0); j < numProps; j++ {
                         panicIf(prop.Read(buf, context, appid, namespace))
                         props = append(props, prop)
                 }
                 pm[name] = props
         }
         return
 }
 
+func (c *IndexColumn) Write(buf Buffer) (err error) {
+        defer recoverTo(&err)
+
+        if c.Direction == ASCENDING {
+                panicIf(buf.WriteByte(0))
+        } else {
+                panicIf(buf.WriteByte(1))
+        }
+        _, err = cmpbin.WriteString(buf, c.Property)
+        return
+}
+
+func (c *IndexColumn) Read(buf Buffer) (err error) {
+        defer recoverTo(&err)
+
+        dir, err := buf.ReadByte()
+        panicIf(err)
+
+        switch dir {
+        case 0:
+                c.Direction = ASCENDING
+        default:
+                c.Direction = DESCENDING
+        }
+        c.Property, _, err = cmpbin.ReadString(buf)
+        return err
+}
+
+func (i *IndexDefinition) Write(buf Buffer) (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(sb.Write(buf))
+        }
+        return
+}
+
+func (i *IndexDefinition) Read(buf Buffer) (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)
+
+        if numSorts > MaxIndexColumns {
+                return fmt.Errorf("datastore: Got over %d sort orders: %d",
+                        MaxIndexColumns, numSorts)
+        }
+
+        if numSorts > 0 {
+                i.SortBy = make([]IndexColumn, numSorts)
+                for idx := range i.SortBy {
+                        panicIf(i.SortBy[idx].Read(buf))
+                }
+        }
+
+        return
+}
+
 type parseError error
 
 func panicIf(err error) {
         if err != nil {
                 panic(parseError(err))
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }