Fix bugs in impl/memory queries.

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"
@@ skipping 39 matching lines @@
                 "Val", 6, 8, 7, Next,
                 "When", 27, Next,
                 "Extra", "zebra",
         ),
         pmap("$key", key("Kind", 3), Next,
                 "Val", 1, 2, 2, 100, Next,
                 "When", 996688461000000, Next,
                 "Extra", "waffle",
         ),
         pmap("$key", key("Kind", 6), Next,
-                "Val", 5, Next,
+                "Val", 5, 3, 2, Next,
                 "When", time.Date(2000, time.January, 1, 1, 1, 1, 1, time.UTC), Next,
                 "Extra", "waffle",
         ),
         pmap("$key", key("Kind", 3, "Child", "seven"), Next,
                 "Interesting", 28, Next,
                 "Extra", "hello",
         ),
         pmap("$key", key("Unique", 1), Next,
                 "Derp", 39,
         ),
@@ skipping 75 matching lines @@
 
                                 // get ziggy with it
                                 {q: nq("Kind").Eq("Extra", "waffle").Eq("Val", 100), get: []ds.PropertyMap{
                                         stage1Data[2],
                                 }},
 
                                 {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").Eq("Val", 2, 3), get: []ds.PropertyMap{
+                                        stage1Data[0],
+                                        stage1Data[3],
+                                }},
+
+                                // note the kind :)
+                                {q: (nq("Kind").Ancestor(key("Kind", 3)).
+                                        Start(curs("__key__", key("Kind", 3))).
+                                        End(curs("__key__", key("Kind", 3, "Zeta", "woot")))),
+                                        keys: []*ds.Key{
+                                                key("Kind", 3),
+                                                key("Kind", 3, "Kind", 1),
+                                                key("Kind", 3, "Kind", 2),
+                                                key("Kind", 3, "Kind", 3),
+                                        },
                                 },
 
-                                {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("").Ancestor(key("Kind", 3)).
+                                        Start(curs("__key__", key("Kind", 3))).
+                                        End(curs("__key__", key("Kind", 3, "Zeta", "woot")))),
+                                        keys: []*ds.Key{
+                                                key("Kind", 3),
+                                                key("Kind", 3, "Child", "seven"),
+                                                key("Kind", 3, "Kind", 1),
+                                                key("Kind", 3, "Kind", 2),
+                                                key("Kind", 3, "Kind", 3),
+                                        },
+                                },
+
+                                {q: (nq("Kind").Ancestor(key("Kind", 3)).
+                                        Start(curs("__key__", key("Kind", 3))).
+                                        End(curs("__key__", key("Kind", 3, "Zeta", "woot")))),
+                                        keys: []*ds.Key{
+                                                key("Kind", 3),
+                                                key("Kind", 3, "Kind", 1),
+                                                key("Kind", 3, "Kind", 2),
+                                                key("Kind", 3, "Kind", 3),
+                                        },
                                         inTxn: true},
 
+                                {q: nq("Kind").Ancestor(key("Kind", 3)).Eq("Val", 3, 4),
+                                        keys: []*ds.Key{
+                                                key("Kind", 3, "Kind", 2),
+                                                key("Kind", 3, "Kind", 3),
+                                        },
+                                        get: []ds.PropertyMap{
+                                                stage2Data[1],
+                                                stage2Data[2],
+                                        },
+                                },
+
                                 {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 134 matching lines @@
                                         }), ShouldErrLike, strings.Join([]string{
                                                 "Consider adding:",
                                                 "- kind: Something",
                                                 "  properties:",
                                                 "  - name: Does",
                                                 "  - name: Not",
                                                 "  - name: Work",
                                                 "    direction: desc",
                                         }, "\n"))
                                 },
+
+                                func(c context.Context) {
+                                        data := ds.Get(c)
+                                        q := nq("Something").Ancestor(key("Kind", 3)).Order("Val")
+                                        So(data.Run(q, func(ds.Key, ds.CursorCB) bool {
+                                                return true
+                                        }), ShouldErrLike, strings.Join([]string{
+                                                "Consider adding:",
+                                                "- kind: Something",
+                                                "  ancestor: yes",
+                                                "  properties:",
+                                                "  - name: Val",
+                                        }, "\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)},
                                         get:  []ds.PropertyMap{}},
@@ skipping 132 matching lines @@
                 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)
         })
 }