impl/memory: Implement Queries

service/datastore/index.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"
 )
 
 const MaxIndexColumns = 64
 
 type IndexDirection bool
 
 const (
         // ASCENDING is false so that it's the default (zero) value.
         ASCENDING  IndexDirection = false
         DESCENDING                = true
 )
 
+func (i IndexDirection) String() string {
+        if i == ASCENDING {
+                return "ASCENDING"
+        }
+        return "DESCENDING"
+}
+
 type IndexColumn struct {
         Property  string
         Direction IndexDirection
 }
 
 func (i IndexColumn) cmp(o IndexColumn) int {
         // sort ascending first
         if i.Direction == ASCENDING && o.Direction == DESCENDING {
                 return -1
         } else if i.Direction == DESCENDING && o.Direction == ASCENDING {
                 return 1
         }
         return cmpString(i.Property, o.Property)()
 }
 
 type IndexDefinition struct {
         Kind     string
         Ancestor bool
         SortBy   []IndexColumn
 }
 
+func (id *IndexDefinition) Equal(o *IndexDefinition) bool {

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

Does "gofmt" really not complain about a lack of comments? Not that I feel one
is explicitly needed with a function this obvious, but I'm used to complaints
about missing comments on exported methods of exported structures.

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

yeah I haven't been running golint on this repo (gofmt never cares about
comments). I assumed it was part of pcg, but I guess I need to configure it.

+        if id.Kind != o.Kind || id.Ancestor != o.Ancestor || len(id.SortBy) != len(o.SortBy) {
+                return false
+        }
+        for i, col := range id.SortBy {
+                if col != o.SortBy[i] {
+                        return false
+                }
+        }
+        return true
+}
+
+// NormalizeOrder returns the normalized SortBy value for this IndexDefinition.
+// This includes prepending __ancestor__ (if id.Ancestor is true), and appending
+// __key__ if it's not explicitly the last field in this IndexDefinition.
+func (id *IndexDefinition) NormalizeOrder() []IndexColumn {
+        ret := make([]IndexColumn, 0, len(id.SortBy))
+        if id.Ancestor {
+                ret = append(ret, IndexColumn{Property: "__ancestor__"})
+        }
+        ret = append(ret, id.SortBy...)
+        if len(ret) == 0 || ret[len(ret)-1].Property != "__key__" {
+                ret = append(ret, IndexColumn{Property: "__key__"})
+        }
+        return ret
+}
+
 // Yeah who needs templates, right?
 // <flames>This is fine.</flames>
 
 func cmpBool(a, b bool) func() int {
         return func() int {
                 if a == b {
                         return 0
                 }
                 if a && !b { // >
                         return 1
@@ skipping 60 matching lines @@
 
 func (i *IndexDefinition) Builtin() bool {
         return !i.Ancestor && len(i.SortBy) <= 1
 }
 
 func (i *IndexDefinition) Compound() bool {
         if i.Kind == "" || len(i.SortBy) <= 1 {
                 return false
         }
         for _, sb := range i.SortBy {
-                if sb.Property == "" {
+                if sb.Property == "" || sb.Property == "__ancestor__" {
                         return false
                 }
         }
         return true
 }
 
 func (i *IndexDefinition) String() string {
         ret := &bytes.Buffer{}
         if i.Builtin() {
                 ret.WriteRune('B')
@@ skipping 15 matching lines @@
         return ret.String()
 }
 
 func IndexBuiltinQueryPrefix() []byte {
         return []byte{0}
 }
 
 func IndexComplexQueryPrefix() []byte {
         return []byte{1}
 }