Implement projection queries correctly.

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"
         "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"
 )
 
 type qExpect struct {
         q     ds.Query
@@ skipping 18 matching lines @@
         test []qExStage
 }
 
 var stage1Data = []ds.PropertyMap{
         pmap("$key", key("Kind", 1), NEXT,
                 "Val", 1, 2, 3, NEXT,
                 "Extra", "hello",
         ),
         pmap("$key", key("Kind", 2), NEXT,
                 "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,
+                "When", time.Date(2000, time.January, 1, 1, 1, 1, 1, time.UTC), NEXT,
                 "Extra", "waffle",
         ),
         pmap("$key", key("Child", "seven", key("Kind", 3)), NEXT,
                 "Interesting", 28, NEXT,
                 "Extra", "hello",
         ),
         pmap("$key", key("Unique", 1), NEXT,
                 "Derp", 39,
         ),
 }
@@ skipping 151 matching lines @@
                                         get: []ds.PropertyMap{
                                                 pmap("$key", key("Kind", 3), NEXT,
                                                         "Val", 100),
                                                 pmap("$key", key("Kind", 1, key("Kind", 3)), NEXT,
                                                         "Val", 28),
                                                 pmap("$key", key("Kind", 1, key("Kind", 3)), NEXT,
                                                         "Val", 4),
                                                 pmap("$key", key("Kind", 2, key("Kind", 3)), NEXT,
                                                         "Val", 3),
                                         }},
+
+                                // Projecting a complex type (time), gets the index type (int64)
+                                // instead. Additionally, mixed-types within the same index type are
+                                // smooshed together in the result.
+                                {q: nq("Kind").Project("When"), get: []ds.PropertyMap{
+                                        pmap("$key", key("Kind", 2), NEXT,
+                                                "When", 27),
+                                        pmap("$key", key("Kind", 6), NEXT,
+                                                "When", 946688461000000),
+                                        pmap("$key", key("Kind", 3), NEXT,
+                                                "When", 996688461000000),
+                                }},
+
+                                // Original (complex) types are retained when getting the full value.
+                                {q: nq("Kind").Order("When"), get: []ds.PropertyMap{
+                                        stage1Data[1],
+                                        stage1Data[3],
+                                        stage1Data[2],
+                                }},
                         },
 
                         extraFns: []func(context.Context){
                                 func(c context.Context) {
                                         data := ds.Get(c)
                                         curs := ds.Cursor(nil)
 
                                         q := nq("").Filter("__key__ >", key("Kind", 2))
 
                                         err := data.Run(q, func(pm ds.PropertyMap, gc ds.CursorCB) bool {
@@ skipping 113 matching lines @@
                                                         Convey(fmt.Sprintf("extraFn %d", j), func() {
                                                                 fn(c)
                                                         })
                                                 }
                                         })
                                 }
                         })
                 }
         })
 }