Documentation

Overview

    Package primitive contains types similar to Go primitives for BSON types can do not have direct Go primitive representations.

    Index

    Constants

    View Source
    const (
    	MaxDecimal128Exp = 6111
    	MinDecimal128Exp = -6176
    )

      These constants are the maximum and minimum values for the exponent field in a decimal128 value.

      Variables

      View Source
      var (
      	ErrParseNaN    = errors.New("cannot parse NaN as a *big.Int")
      	ErrParseInf    = errors.New("cannot parse Infinity as a *big.Int")
      	ErrParseNegInf = errors.New("cannot parse -Infinity as a *big.Int")
      )

        These errors are returned when an invalid value is parsed as a big.Int.

        View Source
        var ErrInvalidHex = errors.New("the provided hex string is not a valid ObjectID")

          ErrInvalidHex indicates that a hex string cannot be converted to an ObjectID.

          Functions

          func CompareTimestamp

          func CompareTimestamp(tp, tp2 Timestamp) int

            CompareTimestamp returns an integer comparing two Timestamps, where T is compared first, followed by I. Returns 0 if tp = tp2, 1 if tp > tp2, -1 if tp < tp2.

            Types

            type A

            type A []interface{}

              An A is an ordered representation of a BSON array.

              Example usage:

              bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}}
              

              type Binary

              type Binary struct {
              	Subtype byte
              	Data    []byte
              }

                Binary represents a BSON binary value.

                func (Binary) Equal

                func (bp Binary) Equal(bp2 Binary) bool

                  Equal compares bp to bp2 and returns true is the are equal.

                  func (Binary) IsZero

                  func (bp Binary) IsZero() bool

                    IsZero returns if bp is the empty Binary

                    type CodeWithScope

                    type CodeWithScope struct {
                    	Code  JavaScript
                    	Scope interface{}
                    }

                      CodeWithScope represents a BSON JavaScript code with scope value.

                      func (CodeWithScope) String

                      func (cws CodeWithScope) String() string

                      type D

                      type D []E

                        D is an ordered representation of a BSON document. This type should be used when the order of the elements matters, such as MongoDB command documents. If the order of the elements does not matter, an M should be used instead.

                        Example usage:

                        bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
                        

                        func (D) Map

                        func (d D) Map() M

                          Map creates a map from the elements of the D.

                          type DBPointer

                          type DBPointer struct {
                          	DB      string
                          	Pointer ObjectID
                          }

                            DBPointer represents a BSON dbpointer value.

                            func (DBPointer) Equal

                            func (d DBPointer) Equal(d2 DBPointer) bool

                              Equal compares d to d2 and returns true is the are equal.

                              func (DBPointer) IsZero

                              func (d DBPointer) IsZero() bool

                                IsZero returns if d is the empty DBPointer

                                func (DBPointer) String

                                func (d DBPointer) String() string

                                type DateTime

                                type DateTime int64

                                  DateTime represents the BSON datetime value.

                                  func NewDateTimeFromTime

                                  func NewDateTimeFromTime(t time.Time) DateTime

                                    NewDateTimeFromTime creates a new DateTime from a Time.

                                    func (DateTime) MarshalJSON

                                    func (d DateTime) MarshalJSON() ([]byte, error)

                                      MarshalJSON marshal to time type

                                      func (DateTime) Time

                                      func (d DateTime) Time() time.Time

                                        Time returns the date as a time type.

                                        func (*DateTime) UnmarshalJSON

                                        func (d *DateTime) UnmarshalJSON(data []byte) error

                                          UnmarshalJSON creates a primitive.DateTime from a JSON string.

                                          type Decimal128

                                          type Decimal128 struct {
                                          	// contains filtered or unexported fields
                                          }

                                            Decimal128 holds decimal128 BSON values.

                                            func NewDecimal128

                                            func NewDecimal128(h, l uint64) Decimal128

                                              NewDecimal128 creates a Decimal128 using the provide high and low uint64s.

                                              func ParseDecimal128

                                              func ParseDecimal128(s string) (Decimal128, error)

                                                ParseDecimal128 takes the given string and attempts to parse it into a valid Decimal128 value.

                                                func ParseDecimal128FromBigInt

                                                func ParseDecimal128FromBigInt(bi *big.Int, exp int) (Decimal128, bool)

                                                  ParseDecimal128FromBigInt attempts to parse the given significand and exponent into a valid Decimal128 value.

                                                  func (Decimal128) BigInt

                                                  func (d Decimal128) BigInt() (bi *big.Int, exp int, err error)

                                                    BigInt returns significand as big.Int and exponent, bi * 10 ^ exp.

                                                    func (Decimal128) GetBytes

                                                    func (d Decimal128) GetBytes() (uint64, uint64)

                                                      GetBytes returns the underlying bytes of the BSON decimal value as two uint64 values. The first contains the most first 8 bytes of the value and the second contains the latter.

                                                      func (Decimal128) IsInf

                                                      func (d Decimal128) IsInf() int

                                                        IsInf returns:

                                                        +1 d == Infinity
                                                         0 other case
                                                        -1 d == -Infinity
                                                        

                                                        func (Decimal128) IsNaN

                                                        func (d Decimal128) IsNaN() bool

                                                          IsNaN returns whether d is NaN.

                                                          func (Decimal128) IsZero

                                                          func (d Decimal128) IsZero() bool

                                                            IsZero returns true if d is the empty Decimal128.

                                                            func (Decimal128) String

                                                            func (d Decimal128) String() string

                                                              String returns a string representation of the decimal value.

                                                              type E

                                                              type E struct {
                                                              	Key   string
                                                              	Value interface{}
                                                              }

                                                                E represents a BSON element for a D. It is usually used inside a D.

                                                                type JavaScript

                                                                type JavaScript string

                                                                  JavaScript represents a BSON JavaScript code value.

                                                                  type M

                                                                  type M map[string]interface{}

                                                                    M is an unordered representation of a BSON document. This type should be used when the order of the elements does not matter. This type is handled as a regular map[string]interface{} when encoding and decoding. Elements will be serialized in an undefined, random order. If the order of the elements matters, a D should be used instead.

                                                                    Example usage:

                                                                    bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}.
                                                                    

                                                                    type MaxKey

                                                                    type MaxKey struct{}

                                                                      MaxKey represents the BSON maxkey value.

                                                                      type MinKey

                                                                      type MinKey struct{}

                                                                        MinKey represents the BSON minkey value.

                                                                        type Null

                                                                        type Null struct{}

                                                                          Null represents the BSON null value.

                                                                          type ObjectID

                                                                          type ObjectID [12]byte

                                                                            ObjectID is the BSON ObjectID type.

                                                                            var NilObjectID ObjectID

                                                                              NilObjectID is the zero value for ObjectID.

                                                                              func NewObjectID

                                                                              func NewObjectID() ObjectID

                                                                                NewObjectID generates a new ObjectID.

                                                                                func NewObjectIDFromTimestamp

                                                                                func NewObjectIDFromTimestamp(timestamp time.Time) ObjectID

                                                                                  NewObjectIDFromTimestamp generates a new ObjectID based on the given time.

                                                                                  func ObjectIDFromHex

                                                                                  func ObjectIDFromHex(s string) (ObjectID, error)

                                                                                    ObjectIDFromHex creates a new ObjectID from a hex string. It returns an error if the hex string is not a valid ObjectID.

                                                                                    func (ObjectID) Hex

                                                                                    func (id ObjectID) Hex() string

                                                                                      Hex returns the hex encoding of the ObjectID as a string.

                                                                                      func (ObjectID) IsZero

                                                                                      func (id ObjectID) IsZero() bool

                                                                                        IsZero returns true if id is the empty ObjectID.

                                                                                        func (ObjectID) MarshalJSON

                                                                                        func (id ObjectID) MarshalJSON() ([]byte, error)

                                                                                          MarshalJSON returns the ObjectID as a string

                                                                                          func (ObjectID) String

                                                                                          func (id ObjectID) String() string

                                                                                          func (ObjectID) Timestamp

                                                                                          func (id ObjectID) Timestamp() time.Time

                                                                                            Timestamp extracts the time part of the ObjectId.

                                                                                            func (*ObjectID) UnmarshalJSON

                                                                                            func (id *ObjectID) UnmarshalJSON(b []byte) error

                                                                                              UnmarshalJSON populates the byte slice with the ObjectID. If the byte slice is 24 bytes long, it will be populated with the hex representation of the ObjectID. If the byte slice is twelve bytes long, it will be populated with the BSON representation of the ObjectID. This method also accepts empty strings and decodes them as NilObjectID. For any other inputs, an error will be returned.

                                                                                              type Regex

                                                                                              type Regex struct {
                                                                                              	Pattern string
                                                                                              	Options string
                                                                                              }

                                                                                                Regex represents a BSON regex value.

                                                                                                func (Regex) Equal

                                                                                                func (rp Regex) Equal(rp2 Regex) bool

                                                                                                  Equal compares rp to rp2 and returns true is the are equal.

                                                                                                  func (Regex) IsZero

                                                                                                  func (rp Regex) IsZero() bool

                                                                                                    IsZero returns if rp is the empty Regex

                                                                                                    func (Regex) String

                                                                                                    func (rp Regex) String() string

                                                                                                    type Symbol

                                                                                                    type Symbol string

                                                                                                      Symbol represents a BSON symbol value.

                                                                                                      type Timestamp

                                                                                                      type Timestamp struct {
                                                                                                      	T uint32
                                                                                                      	I uint32
                                                                                                      }

                                                                                                        Timestamp represents a BSON timestamp value.

                                                                                                        func (Timestamp) Equal

                                                                                                        func (tp Timestamp) Equal(tp2 Timestamp) bool

                                                                                                          Equal compares tp to tp2 and returns true is the are equal.

                                                                                                          func (Timestamp) IsZero

                                                                                                          func (tp Timestamp) IsZero() bool

                                                                                                            IsZero returns if tp is the zero Timestamp

                                                                                                            type Undefined

                                                                                                            type Undefined struct{}

                                                                                                              Undefined represents the BSON undefined value type.