Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	// UnknownTransactionCommitResult is an error label for unknown transaction commit results.
	UnknownTransactionCommitResult = "UnknownTransactionCommitResult"
	// TransientTransactionError is an error label for transient errors with transactions.
	TransientTransactionError = "TransientTransactionError"
	// NetworkError is an error label for network errors.
	NetworkError = "NetworkError"
	// RetryableWriteError is an error lable for retryable write errors.
	RetryableWriteError = "RetryableWriteError"
	// ErrCursorNotFound is the cursor not found error for legacy find operations.
	ErrCursorNotFound = errors.New("cursor not found")
	// ErrUnacknowledgedWrite is returned from functions that have an unacknowledged
	// write concern.
	ErrUnacknowledgedWrite = errors.New("unacknowledged write")
	// ErrUnsupportedStorageEngine is returned when a retryable write is attempted against a server
	// that uses a storage engine that does not support retryable writes
	ErrUnsupportedStorageEngine = errors.New("this MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string")
)
View Source
var (
	// ErrNoDocCommandResponse occurs when the server indicated a response existed, but none was found.
	ErrNoDocCommandResponse = errors.New("command returned no documents")
	// ErrMultiDocCommandResponse occurs when the server sent multiple documents in response to a command.
	ErrMultiDocCommandResponse = errors.New("command returned multiple documents")
	// ErrReplyDocumentMismatch occurs when the number of documents returned in an OP_QUERY does not match the numberReturned field.
	ErrReplyDocumentMismatch = errors.New("number of documents returned does not match numberReturned field")
	// ErrNonPrimaryReadPref is returned when a read is attempted in a transaction with a non-primary read preference.
	ErrNonPrimaryReadPref = errors.New("read preference in a transaction must be primary")
)
View Source
var ErrDocumentTooLarge = errors.New("an inserted document is too large")

    ErrDocumentTooLarge occurs when a document that is larger than the maximum size accepted by a server is passed to an insert command.

    View Source
    var (
    
    	// ErrFilterType is returned when the filter for a legacy list collections operation is of the wrong type.
    	ErrFilterType = errors.New("filter for list collections operation must be a string")
    )

    Functions

    func CompressPayload

    func CompressPayload(in []byte, opts CompressionOpts) ([]byte, error)

      CompressPayload takes a byte slice and compresses it according to the options passed

      func DecompressPayload

      func DecompressPayload(in []byte, opts CompressionOpts) ([]byte, error)

        DecompressPayload takes a byte slice that has been compressed and undoes it according to the options passed

        Types

        type BatchCursor

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

          BatchCursor is a batch implementation of a cursor. It returns documents in entire batches instead of one at a time. An individual document cursor can be built on top of this batch cursor.

          func NewBatchCursor

          func NewBatchCursor(cr CursorResponse, clientSession *session.Client, clock *session.ClusterClock, opts CursorOptions) (*BatchCursor, error)

            NewBatchCursor creates a new BatchCursor from the provided parameters.

            func NewEmptyBatchCursor

            func NewEmptyBatchCursor() *BatchCursor

              NewEmptyBatchCursor returns a batch cursor that is empty.

              func (*BatchCursor) Batch

              func (bc *BatchCursor) Batch() *bsoncore.DocumentSequence

                Batch will return a DocumentSequence for the current batch of documents. The returned DocumentSequence is only valid until the next call to Next or Close.

                func (*BatchCursor) Close

                func (bc *BatchCursor) Close(ctx context.Context) error

                  Close closes this batch cursor.

                  func (*BatchCursor) Err

                  func (bc *BatchCursor) Err() error

                    Err returns the latest error encountered.

                    func (*BatchCursor) ID

                    func (bc *BatchCursor) ID() int64

                      ID returns the cursor ID for this batch cursor.

                      func (*BatchCursor) KillCursor

                      func (bc *BatchCursor) KillCursor(ctx context.Context) error

                        KillCursor kills cursor on server without closing batch cursor

                        func (*BatchCursor) Next

                        func (bc *BatchCursor) Next(ctx context.Context) bool

                          Next indicates if there is another batch available. Returning false does not necessarily indicate that the cursor is closed. This method will return false when an empty batch is returned.

                          If Next returns true, there is a valid batch of documents available. If Next returns false, there is not a valid batch of documents available.

                          func (*BatchCursor) PostBatchResumeToken

                          func (bc *BatchCursor) PostBatchResumeToken() bsoncore.Document

                            PostBatchResumeToken returns the latest seen post batch resume token.

                            func (*BatchCursor) Server

                            func (bc *BatchCursor) Server() Server

                              Server returns the server for this cursor.

                              type Batches

                              type Batches struct {
                              	Identifier string
                              	Documents  []bsoncore.Document
                              	Current    []bsoncore.Document
                              	Ordered    *bool
                              }

                                Batches contains the necessary information to batch split an operation. This is only used for write oeprations.

                                func (*Batches) AdvanceBatch

                                func (b *Batches) AdvanceBatch(maxCount, targetBatchSize, maxDocSize int) error

                                  AdvanceBatch splits the next batch using maxCount and targetBatchSize. This method will do nothing if the current batch has not been cleared. We do this so that when this is called during execute we can call it without first needing to check if we already have a batch, which makes the code simpler and makes retrying easier. The maxDocSize parameter is used to check that any one document is not too large. If the first document is bigger than targetBatchSize but smaller than maxDocSize, a batch of size 1 containing that document will be created.

                                  func (*Batches) ClearBatch

                                  func (b *Batches) ClearBatch()

                                    ClearBatch clears the Current batch. This must be called before AdvanceBatch will advance to the next batch.

                                    func (*Batches) Valid

                                    func (b *Batches) Valid() bool

                                      Valid returns true if Batches contains both an identifier and the length of Documents is greater than zero.

                                      type CollectionInfoFn

                                      type CollectionInfoFn func(ctx context.Context, db string, filter bsoncore.Document) (bsoncore.Document, error)

                                        CollectionInfoFn is a callback used to retrieve collection information.

                                        type CompressionOpts

                                        type CompressionOpts struct {
                                        	Compressor       wiremessage.CompressorID
                                        	ZlibLevel        int
                                        	ZstdLevel        int
                                        	UncompressedSize int32
                                        }

                                          CompressionOpts holds settings for how to compress a payload

                                          type Compressor

                                          type Compressor interface {
                                          	CompressWireMessage(src, dst []byte) ([]byte, error)
                                          }

                                            Compressor is an interface used to compress wire messages. If a Connection supports compression it should implement this interface as well. The CompressWireMessage method will be called during the execution of an operation if the wire message is allowed to be compressed.

                                            type Connection

                                            type Connection interface {
                                            	WriteWireMessage(context.Context, []byte) error
                                            	ReadWireMessage(ctx context.Context, dst []byte) ([]byte, error)
                                            	Description() description.Server
                                            	Close() error
                                            	ID() string
                                            	Address() address.Address
                                            	Stale() bool
                                            }

                                              Connection represents a connection to a MongoDB server.

                                              type Connector

                                              type Connector interface {
                                              	Connect() error
                                              }

                                                Connector represents a type that can connect to a server.

                                                type Crypt

                                                type Crypt struct {
                                                	BypassAutoEncryption bool
                                                	// contains filtered or unexported fields
                                                }

                                                  Crypt consumes the libmongocrypt.MongoCrypt type to iterate the mongocrypt state machine and perform encryption and decryption.

                                                  func NewCrypt

                                                  func NewCrypt(opts *CryptOptions) (*Crypt, error)

                                                    NewCrypt creates a new Crypt instance configured with the given AutoEncryptionOptions.

                                                    func (*Crypt) Close

                                                    func (c *Crypt) Close()

                                                      Close cleans up any resources associated with the Crypt instance.

                                                      func (*Crypt) CreateDataKey

                                                      func (c *Crypt) CreateDataKey(ctx context.Context, kmsProvider string, opts *options.DataKeyOptions) (bsoncore.Document, error)

                                                        CreateDataKey creates a data key using the given KMS provider and options.

                                                        func (*Crypt) Decrypt

                                                        func (c *Crypt) Decrypt(ctx context.Context, cmdResponse bsoncore.Document) (bsoncore.Document, error)

                                                          Decrypt decrypts the given command response.

                                                          func (*Crypt) DecryptExplicit

                                                          func (c *Crypt) DecryptExplicit(ctx context.Context, subtype byte, data []byte) (bsoncore.Value, error)

                                                            DecryptExplicit decrypts the given encrypted value.

                                                            func (*Crypt) Encrypt

                                                            func (c *Crypt) Encrypt(ctx context.Context, db string, cmd bsoncore.Document) (bsoncore.Document, error)

                                                              Encrypt encrypts the given command.

                                                              func (*Crypt) EncryptExplicit

                                                              func (c *Crypt) EncryptExplicit(ctx context.Context, val bsoncore.Value, opts *options.ExplicitEncryptionOptions) (byte, []byte, error)

                                                                EncryptExplicit encrypts the given value with the given options.

                                                                type CryptOptions

                                                                type CryptOptions struct {
                                                                	CollInfoFn           CollectionInfoFn
                                                                	KeyFn                KeyRetrieverFn
                                                                	MarkFn               MarkCommandFn
                                                                	KmsProviders         map[string]map[string]interface{}
                                                                	SchemaMap            map[string]bsoncore.Document
                                                                	BypassAutoEncryption bool
                                                                }

                                                                  CryptOptions specifies options to configure a Crypt instance.

                                                                  type CursorOptions

                                                                  type CursorOptions struct {
                                                                  	BatchSize      int32
                                                                  	MaxTimeMS      int64
                                                                  	Limit          int32
                                                                  	CommandMonitor *event.CommandMonitor
                                                                  	Crypt          *Crypt
                                                                  }

                                                                    CursorOptions are extra options that are required to construct a BatchCursor.

                                                                    type CursorResponse

                                                                    type CursorResponse struct {
                                                                    	Server     Server
                                                                    	Desc       description.Server
                                                                    	FirstBatch *bsoncore.DocumentSequence
                                                                    	Database   string
                                                                    	Collection string
                                                                    	ID         int64
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                      CursorResponse represents the response from a command the results in a cursor. A BatchCursor can be constructed from a CursorResponse.

                                                                      func NewCursorResponse

                                                                      func NewCursorResponse(response bsoncore.Document, server Server, desc description.Server) (CursorResponse, error)

                                                                        NewCursorResponse constructs a cursor response from the given response and server. This method can be used within the ProcessResponse method for an operation.

                                                                        type Deployment

                                                                        type Deployment interface {
                                                                        	SelectServer(context.Context, description.ServerSelector) (Server, error)
                                                                        	Kind() description.TopologyKind
                                                                        }

                                                                          Deployment is implemented by types that can select a server from a deployment.

                                                                          type Disconnector

                                                                          type Disconnector interface {
                                                                          	Disconnect(context.Context) error
                                                                          }

                                                                            Disconnector represents a type that can disconnect from a server.

                                                                            type Error

                                                                            type Error struct {
                                                                            	Code            int32
                                                                            	Message         string
                                                                            	Labels          []string
                                                                            	Name            string
                                                                            	Wrapped         error
                                                                            	TopologyVersion *description.TopologyVersion
                                                                            }

                                                                              Error is a command execution error from the database.

                                                                              func (Error) Error

                                                                              func (e Error) Error() string

                                                                                Error implements the error interface.

                                                                                func (Error) HasErrorLabel

                                                                                func (e Error) HasErrorLabel(label string) bool

                                                                                  HasErrorLabel returns true if the error contains the specified label.

                                                                                  func (Error) NamespaceNotFound

                                                                                  func (e Error) NamespaceNotFound() bool

                                                                                    NamespaceNotFound returns true if this errors is a NamespaceNotFound error.

                                                                                    func (Error) NetworkError

                                                                                    func (e Error) NetworkError() bool

                                                                                      NetworkError returns true if the error is a network error.

                                                                                      func (Error) NodeIsRecovering

                                                                                      func (e Error) NodeIsRecovering() bool

                                                                                        NodeIsRecovering returns true if this error is a node is recovering error.

                                                                                        func (Error) NodeIsShuttingDown

                                                                                        func (e Error) NodeIsShuttingDown() bool

                                                                                          NodeIsShuttingDown returns true if this error is a node is shutting down error.

                                                                                          func (Error) NotMaster

                                                                                          func (e Error) NotMaster() bool

                                                                                            NotMaster returns true if this error is a not master error.

                                                                                            func (Error) RetryableRead

                                                                                            func (e Error) RetryableRead() bool

                                                                                              RetryableRead returns true if the error is retryable for a read operation

                                                                                              func (Error) RetryableWrite

                                                                                              func (e Error) RetryableWrite(wireVersion *description.VersionRange) bool

                                                                                                RetryableWrite returns true if the error is retryable for a write operation

                                                                                                func (Error) UnsupportedStorageEngine

                                                                                                func (e Error) UnsupportedStorageEngine() bool

                                                                                                  UnsupportedStorageEngine returns whether e came as a result of an unsupported storage engine

                                                                                                  func (Error) Unwrap

                                                                                                  func (e Error) Unwrap() error

                                                                                                    Unwrap returns the underlying error.

                                                                                                    type ErrorProcessor

                                                                                                    type ErrorProcessor interface {
                                                                                                    	ProcessError(err error, conn Connection)
                                                                                                    }

                                                                                                      ErrorProcessor implementations can handle processing errors, which may modify their internal state. If this type is implemented by a Server, then Operation.Execute will call it's ProcessError method after it decodes a wire message.

                                                                                                      type Expirable

                                                                                                      type Expirable interface {
                                                                                                      	Expire() error
                                                                                                      	Alive() bool
                                                                                                      }

                                                                                                        Expirable represents an expirable object.

                                                                                                        type Handshaker

                                                                                                        type Handshaker interface {
                                                                                                        	GetDescription(context.Context, address.Address, Connection) (description.Server, error)
                                                                                                        	FinishHandshake(context.Context, Connection) error
                                                                                                        }

                                                                                                          Handshaker is the interface implemented by types that can perform a MongoDB handshake over a provided driver.Connection. This is used during connection initialization. Implementations must be goroutine safe.

                                                                                                          type InvalidOperationError

                                                                                                          type InvalidOperationError struct{ MissingField string }

                                                                                                            InvalidOperationError is returned from Validate and indicates that a required field is missing from an instance of Operation.

                                                                                                            func (InvalidOperationError) Error

                                                                                                            func (err InvalidOperationError) Error() string

                                                                                                            type KeyRetrieverFn

                                                                                                            type KeyRetrieverFn func(ctx context.Context, filter bsoncore.Document) ([]bsoncore.Document, error)

                                                                                                              KeyRetrieverFn is a callback used to retrieve keys from the key vault.

                                                                                                              type LegacyOperationKind

                                                                                                              type LegacyOperationKind uint

                                                                                                                LegacyOperationKind indicates if an operation is a legacy find, getMore, or killCursors. This is used in Operation.Execute, which will create legacy OP_QUERY, OP_GET_MORE, or OP_KILL_CURSORS instead of sending them as a command.

                                                                                                                const (
                                                                                                                	LegacyNone LegacyOperationKind = iota
                                                                                                                	LegacyFind
                                                                                                                	LegacyGetMore
                                                                                                                	LegacyKillCursors
                                                                                                                	LegacyListCollections
                                                                                                                	LegacyListIndexes
                                                                                                                )

                                                                                                                  These constants represent the three different kinds of legacy operations.

                                                                                                                  type ListCollectionsBatchCursor

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

                                                                                                                    ListCollectionsBatchCursor is a special batch cursor returned from ListCollections that properly handles current and legacy ListCollections operations.

                                                                                                                    func NewLegacyListCollectionsBatchCursor

                                                                                                                    func NewLegacyListCollectionsBatchCursor(bc *BatchCursor) (*ListCollectionsBatchCursor, error)

                                                                                                                      NewLegacyListCollectionsBatchCursor creates a new legacy ListCollectionsCursor.

                                                                                                                      func NewListCollectionsBatchCursor

                                                                                                                      func NewListCollectionsBatchCursor(bc *BatchCursor) (*ListCollectionsBatchCursor, error)

                                                                                                                        NewListCollectionsBatchCursor creates a new non-legacy ListCollectionsCursor.

                                                                                                                        func (*ListCollectionsBatchCursor) Batch

                                                                                                                          Batch will return a DocumentSequence for the current batch of documents. The returned DocumentSequence is only valid until the next call to Next or Close.

                                                                                                                          func (*ListCollectionsBatchCursor) Close

                                                                                                                            Close closes this batch cursor.

                                                                                                                            func (*ListCollectionsBatchCursor) Err

                                                                                                                            func (lcbc *ListCollectionsBatchCursor) Err() error

                                                                                                                              Err returns the latest error encountered.

                                                                                                                              func (*ListCollectionsBatchCursor) ID

                                                                                                                              func (lcbc *ListCollectionsBatchCursor) ID() int64

                                                                                                                                ID returns the cursor ID for this batch cursor.

                                                                                                                                func (*ListCollectionsBatchCursor) Next

                                                                                                                                  Next indicates if there is another batch available. Returning false does not necessarily indicate that the cursor is closed. This method will return false when an empty batch is returned.

                                                                                                                                  If Next returns true, there is a valid batch of documents available. If Next returns false, there is not a valid batch of documents available.

                                                                                                                                  func (*ListCollectionsBatchCursor) Server

                                                                                                                                  func (lcbc *ListCollectionsBatchCursor) Server() Server

                                                                                                                                    Server returns a pointer to the cursor's server.

                                                                                                                                    type LocalAddresser

                                                                                                                                    type LocalAddresser interface {
                                                                                                                                    	LocalAddress() address.Address
                                                                                                                                    }

                                                                                                                                      LocalAddresser is a type that is able to supply its local address

                                                                                                                                      type MarkCommandFn

                                                                                                                                      type MarkCommandFn func(ctx context.Context, db string, cmd bsoncore.Document) (bsoncore.Document, error)

                                                                                                                                        MarkCommandFn is a callback used to add encryption markings to a command.

                                                                                                                                        type Operation

                                                                                                                                        type Operation struct {
                                                                                                                                        	// CommandFn is used to create the command that will be wrapped in a wire message and sent to
                                                                                                                                        	// the server. This function should only add the elements of the command and not start or end
                                                                                                                                        	// the enclosing BSON document. Per the command API, the first element must be the name of the
                                                                                                                                        	// command to run. This field is required.
                                                                                                                                        	CommandFn func(dst []byte, desc description.SelectedServer) ([]byte, error)
                                                                                                                                        
                                                                                                                                        	// Database is the database that the command will be run against. This field is required.
                                                                                                                                        	Database string
                                                                                                                                        
                                                                                                                                        	// Deployment is the MongoDB Deployment to use. While most of the time this will be multiple
                                                                                                                                        	// servers, commands that need to run against a single, preselected server can use the
                                                                                                                                        	// SingleServerDeployment type. Commands that need to run on a preselected connection can use
                                                                                                                                        	// the SingleConnectionDeployment type.
                                                                                                                                        	Deployment Deployment
                                                                                                                                        
                                                                                                                                        	// ProcessResponseFn is called after a response to the command is returned. The server is
                                                                                                                                        	// provided for types like Cursor that are required to run subsequent commands using the same
                                                                                                                                        	// server.
                                                                                                                                        	ProcessResponseFn func(response bsoncore.Document, srvr Server, desc description.Server, currIndex int) error
                                                                                                                                        
                                                                                                                                        	// Selector is the server selector that's used during both initial server selection and
                                                                                                                                        	// subsequent selection for retries. Depending on the Deployment implementation, the
                                                                                                                                        	// SelectServer method may not actually be called.
                                                                                                                                        	Selector description.ServerSelector
                                                                                                                                        
                                                                                                                                        	// ReadPreference is the read preference that will be attached to the command. If this field is
                                                                                                                                        	// not specified a default read preference of primary will be used.
                                                                                                                                        	ReadPreference *readpref.ReadPref
                                                                                                                                        
                                                                                                                                        	// ReadConcern is the read concern used when running read commands. This field should not be set
                                                                                                                                        	// for write operations. If this field is set, it will be encoded onto the commands sent to the
                                                                                                                                        	// server.
                                                                                                                                        	ReadConcern *readconcern.ReadConcern
                                                                                                                                        
                                                                                                                                        	// MinimumReadConcernWireVersion specifies the minimum wire version to add the read concern to
                                                                                                                                        	// the command being executed.
                                                                                                                                        	MinimumReadConcernWireVersion int32
                                                                                                                                        
                                                                                                                                        	// WriteConcern is the write concern used when running write commands. This field should not be
                                                                                                                                        	// set for read operations. If this field is set, it will be encoded onto the commands sent to
                                                                                                                                        	// the server.
                                                                                                                                        	WriteConcern *writeconcern.WriteConcern
                                                                                                                                        
                                                                                                                                        	// MinimumWriteConcernWireVersion specifies the minimum wire version to add the write concern to
                                                                                                                                        	// the command being executed.
                                                                                                                                        	MinimumWriteConcernWireVersion int32
                                                                                                                                        
                                                                                                                                        	// Client is the session used with this operation. This can be either an implicit or explicit
                                                                                                                                        	// session. If the server selected does not support sessions and Client is specified the
                                                                                                                                        	// behavior depends on the session type. If the session is implicit, the session fields will not
                                                                                                                                        	// be encoded onto the command. If the session is explicit, an error will be returned. The
                                                                                                                                        	// caller is responsible for ensuring that this field is nil if the Deployment does not support
                                                                                                                                        	// sessions.
                                                                                                                                        	Client *session.Client
                                                                                                                                        
                                                                                                                                        	// Clock is a cluster clock, different from the one contained within a session.Client. This
                                                                                                                                        	// allows updating cluster times for a global cluster clock while allowing individual session's
                                                                                                                                        	// cluster clocks to be only updated as far as the last command that's been run.
                                                                                                                                        	Clock *session.ClusterClock
                                                                                                                                        
                                                                                                                                        	// RetryMode specifies how to retry. There are three modes that enable retry: RetryOnce,
                                                                                                                                        	// RetryOncePerCommand, and RetryContext. For more information about what these modes do, please
                                                                                                                                        	// refer to their definitions. Both RetryMode and Type must be set for retryability to be enabled.
                                                                                                                                        	RetryMode *RetryMode
                                                                                                                                        
                                                                                                                                        	// Type specifies the kind of operation this is. There is only one mode that enables retry: Write.
                                                                                                                                        	// For more information about what this mode does, please refer to it's definition. Both Type and
                                                                                                                                        	// RetryMode must be set for retryability to be enabled.
                                                                                                                                        	Type Type
                                                                                                                                        
                                                                                                                                        	// Batches contains the documents that are split when executing a write command that potentially
                                                                                                                                        	// has more documents than can fit in a single command. This should only be specified for
                                                                                                                                        	// commands that are batch compatible. For more information, please refer to the definition of
                                                                                                                                        	// Batches.
                                                                                                                                        	Batches *Batches
                                                                                                                                        
                                                                                                                                        	// Legacy sets the legacy type for this operation. There are only 3 types that require legacy
                                                                                                                                        	// support: find, getMore, and killCursors. For more information about LegacyOperationKind,
                                                                                                                                        	// please refer to it's definition.
                                                                                                                                        	Legacy LegacyOperationKind
                                                                                                                                        
                                                                                                                                        	// CommandMonitor specifies the monitor to use for APM events. If this field is not set,
                                                                                                                                        	// no events will be reported.
                                                                                                                                        	CommandMonitor *event.CommandMonitor
                                                                                                                                        
                                                                                                                                        	// Crypt specifies a Crypt object to use for automatic client side encryption and decryption.
                                                                                                                                        	Crypt *Crypt
                                                                                                                                        }

                                                                                                                                          Operation is used to execute an operation. It contains all of the common code required to select a server, transform an operation into a command, write the command to a connection from the selected server, read a response from that connection, process the response, and potentially retry.

                                                                                                                                          The required fields are Database, CommandFn, and Deployment. All other fields are optional.

                                                                                                                                          While an Operation can be constructed manually, drivergen should be used to generate an implementation of an operation instead. This will ensure that there are helpers for constructing the operation and that this type isn't configured incorrectly.

                                                                                                                                          func (Operation) Execute

                                                                                                                                          func (op Operation) Execute(ctx context.Context, scratch []byte) error

                                                                                                                                            Execute runs this operation. The scratch parameter will be used and overwritten (potentially many times), this should mainly be used to enable pooling of byte slices.

                                                                                                                                            func (Operation) ExecuteExhaust

                                                                                                                                            func (op Operation) ExecuteExhaust(ctx context.Context, conn StreamerConnection, scratch []byte) error

                                                                                                                                              ExecuteExhaust reads a response from the provided StreamerConnection. This will error if the connection's CurrentlyStreaming function returns false.

                                                                                                                                              func (Operation) Validate

                                                                                                                                              func (op Operation) Validate() error

                                                                                                                                                Validate validates this operation, ensuring the fields are set properly.

                                                                                                                                                type QueryFailureError

                                                                                                                                                type QueryFailureError struct {
                                                                                                                                                	Message  string
                                                                                                                                                	Response bsoncore.Document
                                                                                                                                                	Wrapped  error
                                                                                                                                                }

                                                                                                                                                  QueryFailureError is an error representing a command failure as a document.

                                                                                                                                                  func (QueryFailureError) Error

                                                                                                                                                  func (e QueryFailureError) Error() string

                                                                                                                                                    Error implements the error interface.

                                                                                                                                                    func (QueryFailureError) Unwrap

                                                                                                                                                    func (e QueryFailureError) Unwrap() error

                                                                                                                                                      Unwrap returns the underlying error.

                                                                                                                                                      type ResponseError

                                                                                                                                                      type ResponseError struct {
                                                                                                                                                      	Message string
                                                                                                                                                      	Wrapped error
                                                                                                                                                      }

                                                                                                                                                        ResponseError is an error parsing the response to a command.

                                                                                                                                                        func NewCommandResponseError

                                                                                                                                                        func NewCommandResponseError(msg string, err error) ResponseError

                                                                                                                                                          NewCommandResponseError creates a CommandResponseError.

                                                                                                                                                          func (ResponseError) Error

                                                                                                                                                          func (e ResponseError) Error() string

                                                                                                                                                            Error implements the error interface.

                                                                                                                                                            type RetryMode

                                                                                                                                                            type RetryMode uint

                                                                                                                                                              RetryMode specifies the way that retries are handled for retryable operations.

                                                                                                                                                              const (
                                                                                                                                                              	// RetryNone disables retrying.
                                                                                                                                                              	RetryNone RetryMode = iota
                                                                                                                                                              	// RetryOnce will enable retrying the entire operation once.
                                                                                                                                                              	RetryOnce
                                                                                                                                                              	// RetryOncePerCommand will enable retrying each command associated with an operation. For
                                                                                                                                                              	// example, if an insert is batch split into 4 commands then each of those commands is eligible
                                                                                                                                                              	// for one retry.
                                                                                                                                                              	RetryOncePerCommand
                                                                                                                                                              	// RetryContext will enable retrying until the context.Context's deadline is exceeded or it is
                                                                                                                                                              	// cancelled.
                                                                                                                                                              	RetryContext
                                                                                                                                                              )

                                                                                                                                                                These are the modes available for retrying.

                                                                                                                                                                func (RetryMode) Enabled

                                                                                                                                                                func (rm RetryMode) Enabled() bool

                                                                                                                                                                  Enabled returns if this RetryMode enables retrying.

                                                                                                                                                                  type Server

                                                                                                                                                                  type Server interface {
                                                                                                                                                                  	Connection(context.Context) (Connection, error)
                                                                                                                                                                  }

                                                                                                                                                                    Server represents a MongoDB server. Implementations should pool connections and handle the retrieving and returning of connections.

                                                                                                                                                                    type SingleConnectionDeployment

                                                                                                                                                                    type SingleConnectionDeployment struct{ C Connection }

                                                                                                                                                                      SingleConnectionDeployment is an implementation of Deployment that always returns the same Connection. This implementation should only be used for connection handshakes and server heartbeats as it does not implement ErrorProcessor, which is necessary for application operations and wraps the connection in nopCloserConnection, which does not implement Compressor.

                                                                                                                                                                      func (SingleConnectionDeployment) Connection

                                                                                                                                                                        Connection implements the Server interface. It always returns the embedded connection.

                                                                                                                                                                        func (SingleConnectionDeployment) Kind

                                                                                                                                                                          Kind implements the Deployment interface. It always returns description.Single.

                                                                                                                                                                          func (SingleConnectionDeployment) SelectServer

                                                                                                                                                                            SelectServer implements the Deployment interface. This method does not use the description.SelectedServer provided and instead returns itself. The Connections returned from the Connection method have a no-op Close method.

                                                                                                                                                                            type SingleServerDeployment

                                                                                                                                                                            type SingleServerDeployment struct{ Server }

                                                                                                                                                                              SingleServerDeployment is an implementation of Deployment that always returns a single server.

                                                                                                                                                                              func (SingleServerDeployment) Kind

                                                                                                                                                                                Kind implements the Deployment interface. It always returns description.Single.

                                                                                                                                                                                func (SingleServerDeployment) SelectServer

                                                                                                                                                                                  SelectServer implements the Deployment interface. This method does not use the description.SelectedServer provided and instead returns the embedded Server.

                                                                                                                                                                                  type StreamerConnection

                                                                                                                                                                                  type StreamerConnection interface {
                                                                                                                                                                                  	Connection
                                                                                                                                                                                  	SetStreaming(bool)
                                                                                                                                                                                  	CurrentlyStreaming() bool
                                                                                                                                                                                  	SupportsStreaming() bool
                                                                                                                                                                                  }

                                                                                                                                                                                    StreamerConnection represents a Connection that supports streaming wire protocol messages using the moreToCome and exhaustAllowed flags.

                                                                                                                                                                                    The SetStreaming and CurrentlyStreaming functions correspond to the moreToCome flag on server responses. If a response has moreToCome set, SetStreaming(true) will be called and CurrentlyStreaming() should return true.

                                                                                                                                                                                    CanStream corresponds to the exhaustAllowed flag. The operations layer will set exhaustAllowed on outgoing wire messages to inform the server that the driver supports streaming.

                                                                                                                                                                                    type Subscriber

                                                                                                                                                                                    type Subscriber interface {
                                                                                                                                                                                    	Subscribe() (*Subscription, error)
                                                                                                                                                                                    	Unsubscribe(*Subscription) error
                                                                                                                                                                                    }

                                                                                                                                                                                      Subscriber represents a type to which another type can subscribe. A subscription contains a channel that is updated with topology descriptions.

                                                                                                                                                                                      type Subscription

                                                                                                                                                                                      type Subscription struct {
                                                                                                                                                                                      	Updates <-chan description.Topology
                                                                                                                                                                                      	ID      uint64
                                                                                                                                                                                      }

                                                                                                                                                                                        Subscription represents a subscription to topology updates. A subscriber can receive updates through the Updates field.

                                                                                                                                                                                        type Type

                                                                                                                                                                                        type Type uint

                                                                                                                                                                                          Type specifies whether an operation is a read, write, or unknown.

                                                                                                                                                                                          const (
                                                                                                                                                                                          	Write Type
                                                                                                                                                                                          	Read
                                                                                                                                                                                          )

                                                                                                                                                                                            THese are the availables types of Type.

                                                                                                                                                                                            type WriteCommandError

                                                                                                                                                                                            type WriteCommandError struct {
                                                                                                                                                                                            	WriteConcernError *WriteConcernError
                                                                                                                                                                                            	WriteErrors       WriteErrors
                                                                                                                                                                                            	Labels            []string
                                                                                                                                                                                            }

                                                                                                                                                                                              WriteCommandError is an error for a write command.

                                                                                                                                                                                              func (WriteCommandError) Error

                                                                                                                                                                                              func (wce WriteCommandError) Error() string

                                                                                                                                                                                              func (WriteCommandError) Retryable

                                                                                                                                                                                              func (wce WriteCommandError) Retryable(wireVersion *description.VersionRange) bool

                                                                                                                                                                                                Retryable returns true if the error is retryable

                                                                                                                                                                                                func (WriteCommandError) UnsupportedStorageEngine

                                                                                                                                                                                                func (wce WriteCommandError) UnsupportedStorageEngine() bool

                                                                                                                                                                                                  UnsupportedStorageEngine returns whether or not the WriteCommandError comes from a retryable write being attempted against a server that has a storage engine where they are not supported

                                                                                                                                                                                                  type WriteConcernError

                                                                                                                                                                                                  type WriteConcernError struct {
                                                                                                                                                                                                  	Name            string
                                                                                                                                                                                                  	Code            int64
                                                                                                                                                                                                  	Message         string
                                                                                                                                                                                                  	Details         bsoncore.Document
                                                                                                                                                                                                  	Labels          []string
                                                                                                                                                                                                  	TopologyVersion *description.TopologyVersion
                                                                                                                                                                                                  }

                                                                                                                                                                                                    WriteConcernError is a write concern failure that occurred as a result of a write operation.

                                                                                                                                                                                                    func (WriteConcernError) Error

                                                                                                                                                                                                    func (wce WriteConcernError) Error() string

                                                                                                                                                                                                    func (WriteConcernError) NodeIsRecovering

                                                                                                                                                                                                    func (wce WriteConcernError) NodeIsRecovering() bool

                                                                                                                                                                                                      NodeIsRecovering returns true if this error is a node is recovering error.

                                                                                                                                                                                                      func (WriteConcernError) NodeIsShuttingDown

                                                                                                                                                                                                      func (wce WriteConcernError) NodeIsShuttingDown() bool

                                                                                                                                                                                                        NodeIsShuttingDown returns true if this error is a node is shutting down error.

                                                                                                                                                                                                        func (WriteConcernError) NotMaster

                                                                                                                                                                                                        func (wce WriteConcernError) NotMaster() bool

                                                                                                                                                                                                          NotMaster returns true if this error is a not master error.

                                                                                                                                                                                                          func (WriteConcernError) Retryable

                                                                                                                                                                                                          func (wce WriteConcernError) Retryable() bool

                                                                                                                                                                                                            Retryable returns true if the error is retryable

                                                                                                                                                                                                            type WriteError

                                                                                                                                                                                                            type WriteError struct {
                                                                                                                                                                                                            	Index   int64
                                                                                                                                                                                                            	Code    int64
                                                                                                                                                                                                            	Message string
                                                                                                                                                                                                            }

                                                                                                                                                                                                              WriteError is a non-write concern failure that occurred as a result of a write operation.

                                                                                                                                                                                                              func (WriteError) Error

                                                                                                                                                                                                              func (we WriteError) Error() string

                                                                                                                                                                                                              type WriteErrors

                                                                                                                                                                                                              type WriteErrors []WriteError

                                                                                                                                                                                                                WriteErrors is a group of non-write concern failures that occurred as a result of a write operation.

                                                                                                                                                                                                                func (WriteErrors) Error

                                                                                                                                                                                                                func (we WriteErrors) Error() string

                                                                                                                                                                                                                Directories

                                                                                                                                                                                                                Path Synopsis
                                                                                                                                                                                                                Package auth is not for public use.
                                                                                                                                                                                                                Package auth is not for public use.
                                                                                                                                                                                                                examples
                                                                                                                                                                                                                Package topology contains types that handles the discovery, monitoring, and selection of servers.
                                                                                                                                                                                                                Package topology contains types that handles the discovery, monitoring, and selection of servers.