Differentiate between single- and multi- props.

impl/memory/datastore_index_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "sort"
         "testing"
         "time"
@@ skipping 20 matching lines @@
         idxs        []*ds.IndexDefinition
 
         // These are checked in TestIndexRowGen. nil to skip test case.
         expected []serialize.SerializedPslice
 
         // just the collections you want to assert. These are checked in
         // TestIndexEntries. nil to skip test case.
         collections map[string][][]byte
 }{
 
         {

[iannucci, 2016/09/16 07:11:03]

question: now that we know that the datastore retains the 'multiple' data inside
the datastore itself, does that data affect the sort-order of the indexed
values? So if you have:

type Foo struct { Value int }
type Foo struct { Value []int }

And you store:

Foo{1}
Foo{[]int{1}}
Foo{2}
Foo{[]int{2}}

And then do

Query("Foo").Order("Value")

What order do they come back in?

[dnj, 2016/09/16 19:07:22]

Discussed, probably can't matter for queries.

                 name: "simple including builtins",
                 pmap: ds.PropertyMap{
-                        "wat":  {propNI("thing"), prop("hat"), prop(100)},
-                        "nerd": {prop(103.7)},
-                        "spaz": {propNI(false)},
+                        "wat":  ds.PropertySlice{propNI("thing"), prop("hat"), prop(100)},
+                        "nerd": prop(103.7),
+                        "spaz": propNI(false),
                 },
                 withBuiltin: true,
                 idxs: []*ds.IndexDefinition{
                         indx("knd", "-wat", "nerd"),
                 },
                 expected: []serialize.SerializedPslice{
                         {cat(prop(fakeKey))},              // B:knd
                         {cat(prop(103.7), prop(fakeKey))}, // B:knd/nerd
                         { // B:knd/wat
                                 cat(prop(100), prop(fakeKey)),
@@ skipping 31 matching lines @@
                         "idx:ns:" + sat(indx("knd", "-wat").PrepForIdxTable()): {
                                 cat(icat(prop("hat")), prop(fakeKey)),
                                 cat(icat(prop(100)), prop(fakeKey)),
                         },
                 },
         },
 
         {
                 name: "complex",
                 pmap: ds.PropertyMap{
-                        "yerp": {prop("hat"), prop(73.9)},
-                        "wat": {
+                        "yerp": ds.PropertySlice{prop("hat"), prop(73.9)},
+                        "wat": ds.PropertySlice{
                                 prop(rgenComplexTime),
                                 prop([]byte("value")),
                                 prop(rgenComplexKey)},
-                        "spaz": {prop(nil), prop(false), prop(true)},
+                        "spaz": ds.PropertySlice{prop(nil), prop(false), prop(true)},
                 },
                 idxs: []*ds.IndexDefinition{
                         indx("knd", "-wat", "nerd", "spaz"), // doesn't match, so empty
                         indx("knd", "yerp", "-wat", "spaz"),
                 },
                 expected: []serialize.SerializedPslice{
                         {}, // C:knd/-wat/nerd/spaz, no match
                         { // C:knd/yerp/-wat/spaz
                                 // thank goodness the binary serialization only happens 1/val in the
                                 // real code :).
@@ skipping 16 matching lines @@
                                 cat(prop(73.9), icat(rgenComplexTimeIdx), prop(nil), prop(fakeKey)),
                                 cat(prop(73.9), icat(rgenComplexTimeIdx), prop(false), prop(fakeKey)),
                                 cat(prop(73.9), icat(rgenComplexTimeIdx), prop(true), prop(fakeKey)),
                         },
                 },
         },
 
         {
                 name: "ancestor",
                 pmap: ds.PropertyMap{
-                        "wat": {prop("sup")},
+                        "wat": prop("sup"),
                 },
                 idxs: []*ds.IndexDefinition{
                         indx("knd!", "wat"),
                 },
                 collections: map[string][][]byte{
                         "idx:ns:" + sat(indx("knd!", "wat").PrepForIdxTable()): {
                                 cat(prop(fakeKey.Parent()), prop("sup"), prop(fakeKey)),
                                 cat(prop(fakeKey), prop("sup"), prop(fakeKey)),
                         },
                 },
@@ skipping 57 matching lines @@
                                 numItems, _ := s.GetCollection("idx").GetTotals()
                                 So(numItems, ShouldEqual, 1)
                                 itm := s.GetCollection("idx").MinItem(false)
                                 So(itm.Key, ShouldResemble, cat(indx("knd").PrepForIdxTable()))
                                 numItems, _ = s.GetCollection("idx:ns:" + string(itm.Key)).GetTotals()
                                 So(numItems, ShouldEqual, 1)
                         })
 
                         Convey("defaultIndexes", func() {
                                 pm := ds.PropertyMap{
-                                        "wat":  {propNI("thing"), prop("hat"), prop(100)},
-                                        "nerd": {prop(103.7)},
-                                        "spaz": {propNI(false)},
+                                        "wat":  ds.PropertySlice{propNI("thing"), prop("hat"), prop(100)},
+                                        "nerd": prop(103.7),
+                                        "spaz": propNI(false),
                                 }
                                 idxs := defaultIndexes("knd", pm)
                                 So(len(idxs), ShouldEqual, 5)
                                 So(idxs[0].String(), ShouldEqual, "B:knd")
                                 So(idxs[1].String(), ShouldEqual, "B:knd/nerd")
                                 So(idxs[2].String(), ShouldEqual, "B:knd/wat")
                                 So(idxs[3].String(), ShouldEqual, "B:knd/-nerd")
                                 So(idxs[4].String(), ShouldEqual, "B:knd/-wat")
                         })
 
@@ skipping 45 matching lines @@
         name     string
         idxs     []*ds.IndexDefinition
         data     []dumbItem
         expected map[string][][]byte
 }{
 
         {
                 name: "basic",
                 data: []dumbItem{
                         {key("knd", 1), ds.PropertyMap{
-                                "wat":  {prop(10)},
-                                "yerp": {prop(10)}},
+                                "wat":  prop(10),
+                                "yerp": prop(10)},
                         },
                         {key("knd", 10), ds.PropertyMap{
-                                "wat":  {prop(1)},
-                                "yerp": {prop(200)}},
+                                "wat":  prop(1),
+                                "yerp": prop(200)},
                         },
                         {key("knd", 1), ds.PropertyMap{
-                                "wat":  {prop(10)},
-                                "yerp": {prop(202)}},
+                                "wat":  prop(10),
+                                "yerp": prop(202)},
                         },
                 },
                 expected: map[string][][]byte{
                         "idx:ns:" + sat(indx("knd", "wat").PrepForIdxTable()): {
                                 cat(prop(1), prop(key("knd", 10))),
                                 cat(prop(10), prop(key("knd", 1))),
                         },
                         "idx:ns:" + sat(indx("knd", "-wat").PrepForIdxTable()): {
                                 cat(icat(prop(10)), prop(key("knd", 1))),
                                 cat(icat(prop(1)), prop(key("knd", 10))),
                         },
                         "idx:ns:" + sat(indx("knd", "yerp").PrepForIdxTable()): {
                                 cat(prop(200), prop(key("knd", 10))),
                                 cat(prop(202), prop(key("knd", 1))),
                         },
                 },
         },
 
         {
                 name: "compound",
                 idxs: []*ds.IndexDefinition{indx("knd", "yerp", "-wat")},
                 data: []dumbItem{
                         {key("knd", 1), ds.PropertyMap{
-                                "wat":  {prop(10)},
-                                "yerp": {prop(100)}},
+                                "wat":  prop(10),
+                                "yerp": prop(100)},
                         },
                         {key("knd", 10), ds.PropertyMap{
-                                "wat":  {prop(1)},
-                                "yerp": {prop(200)}},
+                                "wat":  prop(1),
+                                "yerp": prop(200)},
                         },
                         {key("knd", 11), ds.PropertyMap{
-                                "wat":  {prop(20)},
-                                "yerp": {prop(200)}},
+                                "wat":  prop(20),
+                                "yerp": prop(200)},
                         },
                         {key("knd", 14), ds.PropertyMap{
-                                "wat":  {prop(20)},
-                                "yerp": {prop(200)}},
+                                "wat":  prop(20),
+                                "yerp": prop(200)},
                         },
                         {key("knd", 1), ds.PropertyMap{
-                                "wat":  {prop(10)},
-                                "yerp": {prop(202)}},
+                                "wat":  prop(10),
+                                "yerp": prop(202)},
                         },
                 },
                 expected: map[string][][]byte{
                         "idx:ns:" + sat(indx("knd", "yerp", "-wat").PrepForIdxTable()): {
                                 cat(prop(200), icat(prop(20)), prop(key("knd", 11))),
                                 cat(prop(200), icat(prop(20)), prop(key("knd", 14))),
                                 cat(prop(200), icat(prop(1)), prop(key("knd", 10))),
                                 cat(prop(202), icat(prop(10)), prop(key("knd", 1))),
                         },
                 },
@@ skipping 29 matching lines @@
                                                 So(data[i], ShouldResemble, itm.Key)
                                                 i++
                                                 return true
                                         })
                                         So(i, ShouldEqual, len(data))
                                 }
                         })
                 }
         })
 }