Differentiate between single- and multi- props.

impl/memory/datastore_index_test.go

Index: impl/memory/datastore_index_test.go
diff --git a/impl/memory/datastore_index_test.go b/impl/memory/datastore_index_test.go
index e5f2466cd7d7894fc28491bb0b800c1806e6ada9..7f502b76fce4c5ce589ce3d881d34bb1b2a4b902 100644
--- a/impl/memory/datastore_index_test.go
+++ b/impl/memory/datastore_index_test.go
@@ -41,9 +41,9 @@ var rowGenTestCases = []struct {
 	{

[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{
@@ -95,12 +95,12 @@ var rowGenTestCases = []struct {
 	{
 		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
@@ -137,7 +137,7 @@ var rowGenTestCases = []struct {
 	{
 		name: "ancestor",
 		pmap: ds.PropertyMap{
-			"wat": {prop("sup")},
+			"wat": prop("sup"),
 		},
 		idxs: []*ds.IndexDefinition{
 			indx("knd!", "wat"),
@@ -215,9 +215,9 @@ func TestIndexRowGen(t *testing.T) {
 
 			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)
@@ -283,16 +283,16 @@ var updateIndexesTests = []struct {
 		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{
@@ -316,24 +316,24 @@ var updateIndexesTests = []struct {
 		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{