Add prototype of improved BSON support

Migration Notes:
The bson.Reader type has been replaced with bson.Raw. This new type has
it's own Element and Value types, called bson.RawElement and
bson.RawValue respectively. The API of bson.Raw is different from
bson.Reader:
    - the ElementAt method has been replaced with Index and IndexErr
    - the Lookup method now returns a bson.RawValue instead of a
      *bson.Element
    - the Iterator method and ReaderIterator type have been replaced
      with the Elements method and a []RawElement

The bson.Raw family of types are wrappers around their bsoncore
equivalents. The errors returned from this types are not wrapped, so
users using these types will need to import the bsoncore package when
identifying errors.

There is no bsoncore.Array type nor a bson.RawArray, instead the
bsoncore.Document and bson.Raw types should be used. A Values method on
each will return just the values as a slice.

Change-Id: Ie170697a07cf21c27839a54894b92d17a4a2f61c

Author: skriptble

benchmark/bson.go

@@ -36,7 +36,7 @@ func loadSourceDocument(pathParts ...string) (*bson.Document, error) {
 	return doc, nil
 }
 
-func loadSourceReader(pathParts ...string) (bson.Reader, error) {
+func loadSourceRaw(pathParts ...string) (bson.Raw, error) {
 	doc, err := loadSourceDocument(pathParts...)
 	if err != nil {
 		return nil, err
@@ -46,5 +46,5 @@ func loadSourceReader(pathParts ...string) (bson.Reader, error) {
 		return nil, err
 	}
 
-	return bson.Reader(raw), nil
+	return bson.Raw(raw), nil
 }

benchmark/bson_map.go

@@ -9,7 +9,7 @@ import (
 )
 
 func bsonMapDecoding(ctx context.Context, tm TimerManager, iters int, dataSet string) error {
-	r, err := loadSourceReader(getProjectRoot(), perfDataDir, bsonDataDir, dataSet)
+	r, err := loadSourceRaw(getProjectRoot(), perfDataDir, bsonDataDir, dataSet)
 	if err != nil {
 		return err
 	}
@@ -30,7 +30,7 @@ func bsonMapDecoding(ctx context.Context, tm TimerManager, iters int, dataSet st
 }
 
 func bsonMapEncoding(ctx context.Context, tm TimerManager, iters int, dataSet string) error {
-	r, err := loadSourceReader(getProjectRoot(), perfDataDir, bsonDataDir, dataSet)
+	r, err := loadSourceRaw(getProjectRoot(), perfDataDir, bsonDataDir, dataSet)
 	if err != nil {
 		return err
 	}

benchmark/bson_reader.go

@@ -8,7 +8,7 @@ import (
 )
 
 func BSONFlatStructDecoding(ctx context.Context, tm TimerManager, iters int) error {
-	r, err := loadSourceReader(getProjectRoot(), perfDataDir, bsonDataDir, flatBSONData)
+	r, err := loadSourceRaw(getProjectRoot(), perfDataDir, bsonDataDir, flatBSONData)
 	if err != nil {
 		return err
 	}
@@ -26,7 +26,7 @@ func BSONFlatStructDecoding(ctx context.Context, tm TimerManager, iters int) err
 }
 
 func BSONFlatStructEncoding(ctx context.Context, tm TimerManager, iters int) error {
-	r, err := loadSourceReader(getProjectRoot(), perfDataDir, bsonDataDir, flatBSONData)
+	r, err := loadSourceRaw(getProjectRoot(), perfDataDir, bsonDataDir, flatBSONData)
 	if err != nil {
 		return err
 	}
@@ -53,7 +53,7 @@ func BSONFlatStructEncoding(ctx context.Context, tm TimerManager, iters int) err
 }
 
 func BSONFlatStructTagsEncoding(ctx context.Context, tm TimerManager, iters int) error {
-	r, err := loadSourceReader(getProjectRoot(), perfDataDir, bsonDataDir, flatBSONData)
+	r, err := loadSourceRaw(getProjectRoot(), perfDataDir, bsonDataDir, flatBSONData)
 	if err != nil {
 		return err
 	}
@@ -80,7 +80,7 @@ func BSONFlatStructTagsEncoding(ctx context.Context, tm TimerManager, iters int)
 }
 
 func BSONFlatStructTagsDecoding(ctx context.Context, tm TimerManager, iters int) error {
-	r, err := loadSourceReader(getProjectRoot(), perfDataDir, bsonDataDir, flatBSONData)
+	r, err := loadSourceRaw(getProjectRoot(), perfDataDir, bsonDataDir, flatBSONData)
 	if err != nil {
 		return err
 	}

benchmark/bson_struct.go

@@ -2,9 +2,6 @@ package benchmark
 
 import "testing"
 
-func BenchmarkBSONFlatReaderDecoding(b *testing.B) { WrapCase(BSONFlatReaderDecoding)(b) }
-func BenchmarkBSONDeepReaderDecoding(b *testing.B) { WrapCase(BSONDeepReaderDecoding)(b) }
-
 // func BenchmarkBSONFullReaderDecoding(b *testing.B)       { WrapCase(BSONFullReaderDecoding)(b) }
 
 func BenchmarkBSONFlatDocumentEncoding(b *testing.B)     { WrapCase(BSONFlatDocumentEncoding)(b) }

benchmark/bson_test.go

@@ -107,18 +107,6 @@ func getAllCases() []*CaseDefinition {
 		//	Size:    57340000,
 		//	Runtime: StandardRuntime,
 		// },
-		{
-			Bench:   BSONFlatReaderDecoding,
-			Count:   tenThousand,
-			Size:    75310000,
-			Runtime: StandardRuntime,
-		},
-		{
-			Bench:   BSONDeepReaderDecoding,
-			Count:   tenThousand,
-			Size:    19640000,
-			Runtime: StandardRuntime,
-		},
 		// {
 		//	Bench:   BSONFullReaderDecoding,
 		//	Count:   tenThousand,

benchmark/harness.go

@@ -52,7 +52,7 @@ func MultiFindMany(ctx context.Context, tm TimerManager, iters int) error {
 		if err != nil {
 			return err
 		}
-		var r bson.Reader
+		var r bson.Raw
 		r, err = cursor.DecodeBytes()
 		if err != nil {
 			return err

benchmark/multi.go

@@ -154,9 +154,9 @@ func (a *Array) Set(index uint, value *Value) *Array {
 //   - *Array
 //   - *Document
 //   - []byte
-//   - bson.Reader
+//   - bson.Raw
 //
-// Note that in the case of *Document, []byte, and bson.Reader, the keys will be ignored and only
+// Note that in the case of *Document, []byte, and bson.Raw, the keys will be ignored and only
 // the values will be appended.
 func (a *Array) Concat(docs ...interface{}) error {
 	for _, arr := range docs {
@@ -194,11 +194,11 @@ func (a *Array) Concat(docs ...interface{}) error {
 				a.Append(e.value)
 			}
 		case []byte:
-			if err := a.concatReader(Reader(val)); err != nil {
+			if err := a.concatRaw(Raw(val)); err != nil {
 				return err
 			}
-		case Reader:
-			if err := a.concatReader(val); err != nil {
+		case Raw:
+			if err := a.concatRaw(val); err != nil {
 				return err
 			}
 		default:
@@ -209,12 +209,15 @@ func (a *Array) Concat(docs ...interface{}) error {
 	return nil
 }
 
-func (a *Array) concatReader(r Reader) error {
-	_, err := r.readElements(func(e *Element) error {
-		a.Append(e.value)
-
-		return nil
-	})
+func (a *Array) concatRaw(r Raw) error {
+	elems, err := r.Elements()
+	if err != nil {
+		return err
+	}
+	for _, elem := range elems {
+		idx := bytes.IndexByte(elem[1:], 0x00) // elements will only contain valid elements
+		a.Append(&Value{start: 0, offset: uint32(idx + 2), data: elem})
+	}
 
 	return err
 }

bson/array.go

@@ -3,6 +3,9 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer
+// See THIRD-PARTY-NOTICES for original license terms.
 
 package bson
 
@@ -23,3 +26,52 @@ type node [2]uint32
 type Zeroer interface {
 	IsZero() bool
 }
+
+// D represents a BSON Document. This type can be used to represent BSON in a concise and readable
+// manner. It should generally be used when serializing to BSON. For deserializing, the Raw or
+// Document types should be used.
+//
+// Example usage:
+//
+// 		bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
+//
+// This type should be used in situations where order matters, such as MongoDB commands. If the
+// order is not important, a map is more comfortable and concise.
+type D []E
+
+// Map creates a map from the elements of the D.
+func (d D) Map() M {
+	m := make(M, len(d))
+	for _, e := range d {
+		m[e.Key] = e.Value
+	}
+	return m
+}
+
+// E represents a BSON element for a D. It is usually used inside a D.
+type E struct {
+	Key   string
+	Value interface{}
+}
+
+// M is an unordered, concise representation of a BSON Document. It should generally be used to
+// serialize BSON when the order of the elements of a BSON document do not matter. If the element
+// order matters, use a D instead.
+//
+// Example usage:
+//
+// 		bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
+//
+// This type is handled in the encoders as a regular map[string]interface{}. The elements will be
+// serialized in an undefined, random order, and the order will be different each time.
+type M map[string]interface{}
+
+// An A represents a BSON array. This type can be used to represent a BSON array in a concise and
+// readable manner. It should generally be used when serializing to BSON. For deserializing, the
+// RawArray or Array types should be used.
+//
+// Example usage:
+//
+// 		bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}}
+//
+type A []interface{}

bson/bson.go

@@ -163,7 +163,7 @@ func normalizeRelaxedDouble(t *testing.T, key string, rEJ string) string {
 // bsonToNative decodes the BSON bytes (b) into a native Document
 func bsonToNative(t *testing.T, b []byte, bType, testDesc string) *Document {
 	doc := NewDocument()
-	err := pc.DocumentDecodeValue(dc, bsonrw.NewBSONValueReader(b), &doc)
+	err := pc.DocumentDecodeValue(dc, bsonrw.NewBSONDocumentReader(b), &doc)
 	expectNoError(t, err, fmt.Sprintf("%s: decoding %s BSON", testDesc, bType))
 	return doc
 }
@@ -299,7 +299,7 @@ func runTest(t *testing.T, file string) {
 			expectNoError(t, err, d.Description)
 
 			doc := NewDocument()
-			err = pc.DocumentDecodeValue(dc, bsonrw.NewBSONValueReader(b), &doc)
+			err = pc.DocumentDecodeValue(dc, bsonrw.NewBSONDocumentReader(b), &doc)
 			expectError(t, err, fmt.Sprintf("%s: expected decode error", d.Description))
 		}