Add AutoIndex

impl/memory/datastore_query_execution_test.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 memory
 
 import (
         "fmt"
+        "strings"
         "testing"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
@@ skipping 84 matching lines @@
                         },
                 },
 
                 {
                         putEnts: stage1Data,
                         expect: []qExpect{
                                 {q: nq("Kind"), get: []ds.PropertyMap{}},
                                 {q: nq("Child").Ancestor(key("Kind", 3)), keys: []*ds.Key{
                                         key("Kind", 3, "Child", "seven"),
                                 }},
+                                {q: nq("Child").Ancestor(key("Kind", 3)).EventualConsistency(true), keys: []*ds.Key{}},
+                                {q: nq("Child").Ancestor(key("Kind", 3)).EventualConsistency(true), keys: []*ds.Key{
+                                        key("Kind", 3, "Child", "seven"),
+                                }, inTxn: true},
+                                {q: nq("Child").Ancestor(key("Kind", 3)), keys: []*ds.Key{
+                                        key("Kind", 3, "Child", "seven"),
+                                }, inTxn: true},
                         },
                 },
 
                 {
                         putEnts: stage2Data,
                         delEnts: []*ds.Key{key("Unique", 1)},
                         addIdxs: []*ds.IndexDefinition{
                                 indx("Kind!", "-Extra", "-Val"),
                                 indx("Kind!", "-Extra", "-Val", "-__key__"),
                                 indx("Kind!", "Bogus", "Extra", "-Val"),
@@ skipping 22 matching lines @@
 
                                 {q: nq("Child").Eq("Interesting", 28).Eq("Extra", "hello"), get: []ds.PropertyMap{
                                         stage1Data[4],
                                 }},
 
                                 {q: (nq("Kind").Ancestor(key("Kind", 3)).Order("Val").
                                         Start(curs("Val", 1, "__key__", key("Kind", 3))).
                                         End(curs("Val", 90, "__key__", key("Kind", 3, "Zeta", "woot")))), keys: []*ds.Key{},
                                 },
 
+                                {q: (nq("Kind").Ancestor(key("Kind", 3)).Order("Val").
+                                        Start(curs("Val", 1, "__key__", key("Kind", 3))).
+                                        End(curs("Val", 90, "__key__", key("Kind", 3, "Zeta", "woot")))),
+                                        keys:  []*ds.Key{},
+                                        inTxn: true},
+
                                 {q: nq("Kind").Gt("Val", 2).Lte("Val", 5), get: []ds.PropertyMap{
                                         stage1Data[0], stage1Data[3],
                                 }},
 
                                 {q: nq("Kind").Gt("Val", 2).Lte("Val", 5).Order("-Val"), get: []ds.PropertyMap{
                                         stage1Data[3], stage1Data[0],
                                 }},
 
                                 {q: nq("").Gt("__key__", key("Kind", 2)),
                                         // count counts from the index with KeysOnly and so counts the deleted
@@ skipping 23 matching lines @@
                                         Order("-Val").
                                         Ancestor(key("Kind", 3))),
                                         get: []ds.PropertyMap{
                                                 stage1Data[2],
                                                 stage2Data[0],
                                                 stage2Data[1],
                                         }},
 
                                 {q: (nq("Kind").
                                         Gt("Val", 2).Eq("Extra", "waffle").
+                                        Order("-Val").
+                                        Ancestor(key("Kind", 3))),
+                                        get: []ds.PropertyMap{
+                                                stage1Data[2],
+                                                stage2Data[0],
+                                                stage2Data[1],
+                                        }, inTxn: true},
+
+                                {q: (nq("Kind").
+                                        Gt("Val", 2).Eq("Extra", "waffle").
                                         Order("-Val", "-__key__").
                                         Ancestor(key("Kind", 3))),
                                         get: []ds.PropertyMap{
                                                 stage1Data[2],
                                                 stage2Data[0],
                                                 stage2Data[1],
                                         }},
 
                                 {q: (nq("Kind").
                                         Gt("Val", 2).Eq("Extra", "waffle").
@@ skipping 68 matching lines @@
 
                                         err = data.Run(q.Start(curs), func(pm ds.PropertyMap, gc ds.CursorCB) bool {
                                                 So(pm, ShouldResemble, stage1Data[2])
                                                 return false
                                         })
                                         So(err, ShouldBeNil)
                                 },
 
                                 func(c context.Context) {
                                         data := ds.Get(c)
-                                        q := nq("Something").Eq("Does", 2).Order("Not", "Work")
+                                        q := nq("Something").Eq("Does", 2).Order("Not", "-Work")
                                         So(data.Run(q, func(ds.Key, ds.CursorCB) bool {
                                                 return true
-                                        }), ShouldErrLike, "Try adding:\n  C:Something/Does/Not/Work")
+                                        }), ShouldErrLike, strings.Join([]string{
+                                                "Consider adding:",
+                                                "- kind: Something",
+                                                "  properties:",
+                                                "  - name: Does",
+                                                "  - name: Not",
+                                                "  - name: Work",
+                                                "    direction: desc",
+                                        }, "\n"))
                                 },
                         },
                 },
 
                 {
                         expect: []qExpect{
                                 // eventual consistency; Unique/1 is deleted at HEAD. Keysonly finds it,
                                 // but 'normal' doesn't.
                                 {q: nq("Unique").Gt("__key__", key("AKind", 5)).Lte("__key__", key("Zeta", "prime")),
                                         keys: []*ds.Key{key("Unique", 1)},
@@ skipping 100 matching lines @@
                                                 for j, fn := range stage.extraFns {
                                                         Convey(fmt.Sprintf("extraFn %d", j), func() {
                                                                 fn(c)
                                                         })
                                                 }
                                         })
                                 }
                         })
                 }
         })
+
+        Convey("Test AutoIndex", t, func() {
+                c, err := info.Get(Use(context.Background())).Namespace("ns")
+                if err != nil {
+                        panic(err)
+                }
+
+                data := ds.Get(c)
+                testing := data.Testable()
+                testing.Consistent(true)
+
+                So(data.Put(pmap("$key", key("Kind", 1), Next,
+                        "Val", 1, 2, 3, Next,
+                        "Extra", "hello",
+                )), ShouldBeNil)
+
+                So(data.Put(pmap("$key", key("Kind", 2), Next,
+                        "Val", 2, 3, 9, Next,
+                        "Extra", "ace", "hello", "there",
+                )), ShouldBeNil)
+
+                q := nq("Kind").Gt("Val", 2).Order("Val", "Extra")
+
+                count, err := data.Count(q)
+                So(err, ShouldErrLike, "Insufficient indexes")
+
+                testing.AutoIndex(true)
+
+                count, err = data.Count(q)
+                So(err, ShouldBeNil)
+                So(count, ShouldEqual, 2)
+        })
 }