Merge pull request globalsign#26 from joomcode/mongo-driver

Begin migration to `go.mongodb.org/mongo-driver/bson`

Author: bozaro

.gitignore

@@ -1,2 +1,3 @@
+.idea/
 _harness
-.vscode
+.vscode

bson/bson.go

@@ -50,6 +50,8 @@ import (
 	"sync"
 	"sync/atomic"
 	"time"
+
+	"go.mongodb.org/mongo-driver/bson/bsontype"
 )
 
 //go:generate go run bson_corpus_spec_test_generator.go
@@ -59,27 +61,27 @@ import (
 
 // Element types constants from BSON specification.
 const (
-	ElementFloat64                byte = 0x01
-	ElementString                 byte = 0x02
-	ElementDocument               byte = 0x03
-	ElementArray                  byte = 0x04
-	ElementBinary                 byte = 0x05
-	Element06                     byte = 0x06
-	ElementObjectId               byte = 0x07
-	ElementBool                   byte = 0x08
-	ElementDatetime               byte = 0x09
-	ElementNil                    byte = 0x0A
-	ElementRegEx                  byte = 0x0B
-	ElementDBPointer              byte = 0x0C
-	ElementJavaScriptWithoutScope byte = 0x0D
-	ElementSymbol                 byte = 0x0E
-	ElementJavaScriptWithScope    byte = 0x0F
-	ElementInt32                  byte = 0x10
-	ElementTimestamp              byte = 0x11
-	ElementInt64                  byte = 0x12
-	ElementDecimal128             byte = 0x13
-	ElementMinKey                 byte = 0xFF
-	ElementMaxKey                 byte = 0x7F
+	ElementFloat64                = bsontype.Double
+	ElementString                 = bsontype.String
+	ElementDocument               = bsontype.EmbeddedDocument
+	ElementArray                  = bsontype.Array
+	ElementBinary                 = bsontype.Binary
+	Element06                     = bsontype.Undefined
+	ElementObjectId               = bsontype.ObjectID
+	ElementBool                   = bsontype.Boolean
+	ElementDatetime               = bsontype.DateTime
+	ElementNil                    = bsontype.Null
+	ElementRegEx                  = bsontype.Regex
+	ElementDBPointer              = bsontype.DBPointer
+	ElementJavaScriptWithoutScope = bsontype.JavaScript
+	ElementSymbol                 = bsontype.Symbol
+	ElementJavaScriptWithScope    = bsontype.CodeWithScope
+	ElementInt32                  = bsontype.Int32
+	ElementTimestamp              = bsontype.Timestamp
+	ElementInt64                  = bsontype.Int64
+	ElementDecimal128             = bsontype.Decimal128
+	ElementMinKey                 = bsontype.MinKey
+	ElementMaxKey                 = bsontype.MaxKey
 
 	BinaryGeneric     byte = 0x00
 	BinaryFunction    byte = 0x01
@@ -185,7 +187,7 @@ func (d D) Map() (m M) {
 //     http://bsonspec.org/#/specification
 //
 type Raw struct {
-	Kind byte
+	Kind bsontype.Type
 	Data []byte
 }
 
@@ -210,17 +212,22 @@ type RawDocElem struct {
 // property.
 //
 // http://www.mongodb.org/display/DOCS/Object+Ids
-type ObjectId string
+type ObjectId [12]byte
+
+var NilObjectID ObjectId
 
 // ObjectIdHex returns an ObjectId from the provided hex representation.
 // Calling this function with an invalid hex representation will
 // cause a runtime panic. See the IsObjectIdHex function.
 func ObjectIdHex(s string) ObjectId {
-	d, err := hex.DecodeString(s)
-	if err != nil || len(d) != 12 {
+	if hex.DecodedLen(len(s)) != 12 {
 		panic(fmt.Sprintf("invalid input to ObjectIdHex: %q", s))
 	}
-	return ObjectId(d)
+	var oid ObjectId
+	if _, err := hex.Decode(oid[:], []byte(s)); err != nil {
+		panic(fmt.Sprintf("invalid input to ObjectIdHex: %q", s))
+	}
+	return oid
 }
 
 // IsObjectIdHex returns whether s is a valid hex representation of
@@ -288,7 +295,7 @@ func NewObjectId() ObjectId {
 	b[9] = byte(i >> 16)
 	b[10] = byte(i >> 8)
 	b[11] = byte(i)
-	return ObjectId(b[:])
+	return b
 }
 
 // NewObjectIdWithTime returns a dummy ObjectId with the timestamp part filled
@@ -299,23 +306,23 @@ func NewObjectId() ObjectId {
 func NewObjectIdWithTime(t time.Time) ObjectId {
 	var b [12]byte
 	binary.BigEndian.PutUint32(b[:4], uint32(t.Unix()))
-	return ObjectId(string(b[:]))
+	return b
 }
 
 // String returns a hex string representation of the id.
 // Example: ObjectIdHex("4d88e15b60f486e428412dc9").
 func (id ObjectId) String() string {
-	return fmt.Sprintf(`ObjectIdHex("%x")`, string(id))
+	return fmt.Sprintf(`ObjectIdHex("%x")`, id[:])
 }
 
 // Hex returns a hex representation of the ObjectId.
 func (id ObjectId) Hex() string {
-	return hex.EncodeToString([]byte(id))
+	return hex.EncodeToString(id[:])
 }
 
 // MarshalJSON turns a bson.ObjectId into a json.Marshaller.
 func (id ObjectId) MarshalJSON() ([]byte, error) {
-	return []byte(fmt.Sprintf(`"%x"`, string(id))), nil
+	return []byte(fmt.Sprintf(`"%x"`, id[:])), nil
 }
 
 var nullBytes = []byte("null")
@@ -339,7 +346,7 @@ func (id *ObjectId) UnmarshalJSON(data []byte) error {
 		}
 	}
 	if len(data) == 2 && data[0] == '"' && data[1] == '"' || bytes.Equal(data, nullBytes) {
-		*id = ""
+		*id = ObjectId{}
 		return nil
 	}
 	if len(data) != 26 || data[0] != '"' || data[25] != '"' {
@@ -350,19 +357,22 @@ func (id *ObjectId) UnmarshalJSON(data []byte) error {
 	if err != nil {
 		return fmt.Errorf("invalid ObjectId in JSON: %s (%s)", string(data), err)
 	}
-	*id = ObjectId(string(buf[:]))
+	*id = buf
 	return nil
 }
 
 // MarshalText turns bson.ObjectId into an encoding.TextMarshaler.
 func (id ObjectId) MarshalText() ([]byte, error) {
-	return []byte(fmt.Sprintf("%x", string(id))), nil
+	if id.IsZero() {
+		return nil, nil
+	}
+	return []byte(fmt.Sprintf("%x", id[:])), nil
 }
 
 // UnmarshalText turns *bson.ObjectId into an encoding.TextUnmarshaler.
 func (id *ObjectId) UnmarshalText(data []byte) error {
 	if len(data) == 1 && data[0] == ' ' || len(data) == 0 {
-		*id = ""
+		*id = ObjectId{}
 		return nil
 	}
 	if len(data) != 24 {
@@ -373,22 +383,24 @@ func (id *ObjectId) UnmarshalText(data []byte) error {
 	if err != nil {
 		return fmt.Errorf("invalid ObjectId: %s (%s)", data, err)
 	}
-	*id = ObjectId(string(buf[:]))
+	*id = buf
 	return nil
 }
 
 // Valid returns true if id is valid. A valid id must contain exactly 12 bytes.
 func (id ObjectId) Valid() bool {
-	return len(id) == 12
+	return !id.IsZero()
+}
+
+// Valid returns true if id is valid. A valid id must contain exactly 12 bytes.
+func (id ObjectId) IsZero() bool {
+	return id == ObjectId{}
 }
 
 // byteSlice returns byte slice of id from start to end.
 // Calling this function with an invalid id will cause a runtime panic.
 func (id ObjectId) byteSlice(start, end int) []byte {
-	if len(id) != 12 {
-		panic(fmt.Sprintf("invalid ObjectId: %q", string(id)))
-	}
-	return []byte(string(id)[start:end])
+	return id[start:end]
 }
 
 // Time returns the timestamp part of the id.
@@ -684,11 +696,11 @@ func (raw Raw) Unmarshal(out interface{}) (err error) {
 // during unmarshaling
 type TypeError struct {
 	Type reflect.Type
-	Kind byte
+	Kind bsontype.Type
 }
 
 func (e *TypeError) Error() string {
-	return fmt.Sprintf("BSON kind 0x%02x isn't compatible with type %s", e.Kind, e.Type.String())
+	return fmt.Sprintf("BSON kind 0x%02x isn't compatible with type %s", byte(e.Kind), e.Type.String())
 }
 
 // --------------------------------------------------------------------------

bson/bson_test.go

@@ -33,6 +33,7 @@ import (
 	"encoding/xml"
 	"errors"
 	"fmt"
+	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"math/rand"
 	"net/url"
 	"reflect"
@@ -158,9 +159,9 @@ var allItems = []testItemType{
 		"\x05_\x00\x04\x00\x00\x00\x80udef"},
 	{bson.M{"_": bson.Undefined}, // Obsolete, but still seen in the wild.
 		"\x06_\x00"},
-	{bson.M{"_": bson.ObjectId("0123456789ab")},
+	{bson.M{"_": bson.ObjectId([12]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b'})},
 		"\x07_\x000123456789ab"},
-	{bson.M{"_": bson.DBPointer{Namespace: "testnamespace", Id: bson.ObjectId("0123456789ab")}},
+	{bson.M{"_": bson.DBPointer{Namespace: "testnamespace", Id: bson.ObjectId([12]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b'})}},
 		"\x0C_\x00\x0e\x00\x00\x00testnamespace\x000123456789ab"},
 	{bson.M{"_": false},
 		"\x08_\x00\x00"},
@@ -220,7 +221,7 @@ func (s *S) TestUnmarshalRawAllItems(c *C) {
 			continue
 		}
 		pv := reflect.New(reflect.ValueOf(value).Type())
-		raw := bson.Raw{Kind: item.data[0], Data: []byte(item.data[3:])}
+		raw := bson.Raw{Kind: bsontype.Type( item.data[0]), Data: []byte(item.data[3:])}
 		c.Logf("Unmarshal raw: %#v, %#v", raw, pv.Interface())
 		err := raw.Unmarshal(pv.Interface())
 		c.Assert(err, IsNil)
@@ -737,8 +738,6 @@ type structWithDupKeys struct {
 var marshalErrorItems = []testItemType{
 	{bson.M{"": uint64(1 << 63)},
 		"BSON has no uint64 type, and value is too large to fit correctly in an int64"},
-	{bson.M{"": bson.ObjectId("tooshort")},
-		"ObjectIDs must be exactly 12 bytes long \\(got 8\\)"},
 	{int64(123),
 		"Can't marshal int64 as a BSON document"},
 	{bson.M{"": 1i},
@@ -1716,7 +1715,7 @@ var jsonIdTests = []struct {
 	unmarshal: true,
 }, {
 	value:     jsonType{},
-	json:      `{"Id":""}`,
+	json:      `{"Id":"000000000000000000000000"}`,
 	marshal:   true,
 	unmarshal: true,
 }, {
@@ -1807,7 +1806,7 @@ func (s *S) TestObjectIdTextMarshaling(c *C) {
 			err := test.value.UnmarshalText([]byte(test.text))
 			if test.error == "" {
 				c.Assert(err, IsNil)
-				if test.value != "" {
+				if !test.value.IsZero() {
 					value := bson.ObjectIdHex(test.text)
 					c.Assert(value, DeepEquals, test.value)
 				}