Redesign Document, Array, Element, and Value types

Migration Notes:
The Document, Element, Value, and Array types have been redesign and
rewritten. They have been renamed Doc, Elem, Val, and Arr respectively.
And additional type, MDoc, has been created.

The Value type no longer stores values as a slice of bytes,
instead opting for a compact 32byte representation that stores values
closer to native Go types. An empty Value is equivalent to a BSON Null.
All of the methods in this package will treat Value{} and
bson.Null() as the same.

The Element type is much simpler and adds a key to a Value.

The Document and Array types have been simplified, removing many of
their methods, and making them conceptually two different types, instead
of building an Array on top of a Document. Their methods have also been
updated to handle easier usage of Element and Value instances.

The constructors have been removed and replaced with a simpler
construction system that uses functions. There is a symmetry between
these functions and the methods on the Value type. The input to the
constructor matches the output of the Value method, for example this is
valid: bson.Double(val.Double()).

The BSON primitive types have been moved from the bson package to a new
package called primitive. The types that were (briefly) called
*Primitive are now call primitive.*, e.g.
RegexPrimitive->primitive.Regex.

The Doc and MDoc types are functionally equivalents of D and M, but with
much higher type safety. Because Doc, MDoc, Arr, Elem, and Val form a
closed systems, and because it's not possible to create an invalid Val
type, Doc, MDoc, and Arr never return errors when Marshaling to BSON.
Both Doc and MDoc have depth traversal capabilities, so looking up a key
thats several subdocuments deep can be done with a single method call,
and in the case of MDoc can be done so in a higher performance manner.

When migrating from Document to Doc, users should ensure they reassign
the return of Append, Prepend, and Set to the doc. With Document, one
could call Append and it would modify the original document, the new Doc
type does not operate in this manner and operates similar to a regular
slice.

GODRIVER-413
GODRIVER-610

Change-Id: I353a83b7c8f8c5fa0c2552de9ff8bc78d55c50bc

Author: skriptble

benchmark/bson.go

@@ -24,18 +24,18 @@ const (
 
 // utility functions for the bson benchmarks
 
-func loadSourceDocument(pathParts ...string) (*bson.Document, error) {
+func loadSourceDocument(pathParts ...string) (bson.Doc, error) {
 	data, err := ioutil.ReadFile(filepath.Join(pathParts...))
 	if err != nil {
 		return nil, err
 	}
-	doc := bson.NewDocument()
+	doc := bson.Doc{}
 	err = bson.UnmarshalExtJSON(data, true, &doc)
 	if err != nil {
 		return nil, err
 	}
 
-	if doc.Len() == 0 {
+	if len(doc) == 0 {
 		return nil, errors.New("empty bson document")
 	}
 
@@ -54,3 +54,21 @@ func loadSourceRaw(pathParts ...string) (bson.Raw, error) {
 
 	return bson.Raw(raw), nil
 }
+
+func loadSourceD(pathParts ...string) (bson.D, error) {
+	data, err := ioutil.ReadFile(filepath.Join(pathParts...))
+	if err != nil {
+		return nil, err
+	}
+	doc := bson.D{}
+	err = bson.UnmarshalExtJSON(data, true, &doc)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(doc) == 0 {
+		return nil, errors.New("empty bson document")
+	}
+
+	return doc, nil
+}

benchmark/bson_document.go

@@ -48,11 +48,11 @@ func bsonDocumentDecodingLazy(ctx context.Context, tm TimerManager, iters int, s
 	tm.ResetTimer()
 
 	for i := 0; i < iters; i++ {
-		out, err := bson.ReadDocument(raw)
+		out, err := bson.ReadDoc(raw)
 		if err != nil {
 			return err
 		}
-		if out.Len() == 0 {
+		if len(out) == 0 {
 			return errors.New("marshaling error")
 		}
 	}
@@ -73,16 +73,12 @@ func bsonDocumentDecoding(ctx context.Context, tm TimerManager, iters, numKeys i
 	tm.ResetTimer()
 
 	for i := 0; i < iters; i++ {
-		out, err := bson.ReadDocument(raw)
+		out, err := bson.ReadDoc(raw)
 		if err != nil {
 			return err
 		}
 
-		keys, err := out.Keys(true)
-		if err != nil {
-			return err
-		}
-		if len(keys) != numKeys {
+		if len(out) != numKeys {
 			return errors.New("document parsing error")
 		}
 	}

benchmark/multi.go

@@ -46,7 +46,7 @@ func MultiFindMany(ctx context.Context, tm TimerManager, iters int) error {
 
 	tm.ResetTimer()
 
-	cursor, err := coll.Find(ctx, bson.NewDocument())
+	cursor, err := coll.Find(ctx, bson.Doc{})
 	if err != nil {
 		return err
 	}
@@ -108,7 +108,7 @@ func multiInsertCase(ctx context.Context, tm TimerManager, iters int, data strin
 		return err
 	}
 
-	_, err = db.RunCommand(ctx, bson.NewDocument(bson.EC.String("create", "corpus")))
+	_, err = db.RunCommand(ctx, bson.Doc{{"create", bson.String("corpus")}})
 	if err != nil {
 		return err
 	}

benchmark/single.go

@@ -49,7 +49,7 @@ func SingleRunCommand(ctx context.Context, tm TimerManager, iters int) error {
 	}
 	defer db.Client().Disconnect(ctx)
 
-	cmd := bson.NewDocument(bson.EC.Boolean("ismaster", true))
+	cmd := bson.Doc{{"ismaster", bson.Boolean(true)}}
 
 	tm.ResetTimer()
 	for i := 0; i < iters; i++ {
@@ -88,7 +88,7 @@ func SingleFindOneByID(ctx context.Context, tm TimerManager, iters int) error {
 	coll := db.Collection("corpus")
 	for i := 0; i < iters; i++ {
 		id := int32(i)
-		res, err := coll.InsertOne(ctx, doc.Set(bson.EC.Int32("_id", id)))
+		res, err := coll.InsertOne(ctx, doc.Set("_id", bson.Int32(id)))
 		if err != nil {
 			return err
 		}
@@ -100,7 +100,7 @@ func SingleFindOneByID(ctx context.Context, tm TimerManager, iters int) error {
 	tm.ResetTimer()
 
 	for i := 0; i < iters; i++ {
-		res := coll.FindOne(ctx, bson.NewDocument(bson.EC.Int32("_id", int32(i))))
+		res := coll.FindOne(ctx, bson.Doc{{"_id", bson.Int32(int32(i))}})
 		if res == nil {
 			return errors.New("find one query produced nil result")
 		}
@@ -135,7 +135,7 @@ func singleInsertCase(ctx context.Context, tm TimerManager, iters int, data stri
 		return err
 	}
 
-	_, err = db.RunCommand(ctx, bson.NewDocument(bson.EC.String("create", "corpus")))
+	_, err = db.RunCommand(ctx, bson.Doc{{"create", bson.String("corpus")}})
 	if err != nil {
 		return err
 	}