Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 aggregateoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "time" "go.mongodb.org/mongo-driver/bson" ) // AggregateOptions represents options that can be used to configure an Aggregate operation. type AggregateOptions struct { // If true, the operation can write to temporary files in the _tmp subdirectory of the database directory path on // the server. The default value is false. AllowDiskUse bool // The maximum number of documents to be included in each batch returned by the server. BatchSize int32 // If true, writes executed as part of the operation will opt out of document-level validation on the server. This // option is valid for MongoDB versions >= 3.2 and is ignored for previous server versions. The default value is // false. See https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about document // validation. BypassDocumentValidation bool // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration // The maximum amount of time that the server should wait for new documents to satisfy a tailable cursor query. // This option is only valid for MongoDB versions >= 3.2 and is ignored for previous server versions. MaxAwaitTime time.Duration // A string that will be included in server logs, profiling logs, and currentOp queries to help trace the operation. // The default is nil, which means that no comment will be included in the logs. Comment string // The index to use for the aggregation. This should either be the index name as a string or the index specification // as a document. The hint does not apply to $lookup and $graphLookup aggregation stages. The driver will return an // error if the hint parameter is a multi-key map. The default value is nil, which means that no hint will be sent. Hint interface{} // Specifies parameters for the aggregate expression. This option is only valid for MongoDB versions >= 5.0. Older // servers will report an error for using this option. This must be a document mapping parameter names to values. // Values must be constant or closed expressions that do not reference document fields. Parameters can then be // accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} // Custom options to be added to aggregate expression. Key-value pairs of the BSON map should correlate with desired // option names and values. Values must be Marshalable. Custom options may conflict with non-custom options, and custom // options bypass client-side validation. Prefer using non-custom options where possible. Custom bson.M } // Aggregate creates a new AggregateOptions instance. func Aggregate() AggregateOptions { return &AggregateOptions{} } // SetAllowDiskUse sets the value for the AllowDiskUse field. func (ao AggregateOptions) SetAllowDiskUse(b bool) AggregateOptions { ao.AllowDiskUse = &b return ao } // SetBatchSize sets the value for the BatchSize field. func (ao AggregateOptions) SetBatchSize(i int32) AggregateOptions { ao.BatchSize = &i return ao } // SetBypassDocumentValidation sets the value for the BypassDocumentValidation field. func (ao AggregateOptions) SetBypassDocumentValidation(b bool) AggregateOptions { ao.BypassDocumentValidation = &b return ao } // SetCollation sets the value for the Collation field. func (ao AggregateOptions) SetCollation(c Collation) AggregateOptions { ao.Collation = c return ao } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (ao AggregateOptions) SetMaxTime(d time.Duration) AggregateOptions { ao.MaxTime = &d return ao } // SetMaxAwaitTime sets the value for the MaxAwaitTime field. func (ao AggregateOptions) SetMaxAwaitTime(d time.Duration) AggregateOptions { ao.MaxAwaitTime = &d return ao } // SetComment sets the value for the Comment field. func (ao AggregateOptions) SetComment(s string) AggregateOptions { ao.Comment = &s return ao } // SetHint sets the value for the Hint field. func (ao AggregateOptions) SetHint(h interface{}) AggregateOptions { ao.Hint = h return ao } // SetLet sets the value for the Let field. func (ao AggregateOptions) SetLet(let interface{}) AggregateOptions { ao.Let = let return ao } // SetCustom sets the value for the Custom field. Key-value pairs of the BSON map should correlate // with desired option names and values. Values must be Marshalable. Custom options may conflict // with non-custom options, and custom options bypass client-side validation. Prefer using non-custom // options where possible. func (ao AggregateOptions) SetCustom(c bson.M) AggregateOptions { ao.Custom = c return ao } // MergeAggregateOptions combines the given AggregateOptions instances into a single AggregateOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeAggregateOptions(opts ...AggregateOptions) *AggregateOptions { aggOpts := Aggregate() for _, ao := range opts { if ao == nil { continue } if ao.AllowDiskUse != nil { aggOpts.AllowDiskUse = ao.AllowDiskUse } if ao.BatchSize != nil { aggOpts.BatchSize = ao.BatchSize } if ao.BypassDocumentValidation != nil { aggOpts.BypassDocumentValidation = ao.BypassDocumentValidation } if ao.Collation != nil { aggOpts.Collation = ao.Collation } if ao.MaxTime != nil { aggOpts.MaxTime = ao.MaxTime } if ao.MaxAwaitTime != nil { aggOpts.MaxAwaitTime = ao.MaxAwaitTime } if ao.Comment != nil { aggOpts.Comment = ao.Comment } if ao.Hint != nil { aggOpts.Hint = ao.Hint } if ao.Let != nil { aggOpts.Let = ao.Let } if ao.Custom != nil { aggOpts.Custom = ao.Custom } } return aggOpts }	6.84 KB	2025-05-25 12:27
📄 autoencryptionoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "crypto/tls" "net/http" "go.mongodb.org/mongo-driver/internal/httputil" ) // AutoEncryptionOptions represents options used to configure auto encryption/decryption behavior for a mongo.Client // instance. // // Automatic encryption is an enterprise only feature that only applies to operations on a collection. Automatic // encryption is not supported for operations on a database or view, and operations that are not bypassed will result // in error. Too bypass automatic encryption for all operations, set BypassAutoEncryption=true. // // Auto encryption requires the authenticated user to have the listCollections privilege action. // // If automatic encryption fails on an operation, use a MongoClient configured with bypassAutoEncryption=true and use // ClientEncryption.encrypt() to manually encrypt values. // // Enabling Client Side Encryption reduces the maximum document and message size (using a maxBsonObjectSize of 2MiB and // maxMessageSizeBytes of 6MB) and may have a negative performance impact. type AutoEncryptionOptions struct { KeyVaultClientOptions ClientOptions KeyVaultNamespace string KmsProviders map[string]map[string]interface{} SchemaMap map[string]interface{} BypassAutoEncryption bool ExtraOptions map[string]interface{} TLSConfig map[string]tls.Config HTTPClient http.Client EncryptedFieldsMap map[string]interface{} BypassQueryAnalysis bool } // AutoEncryption creates a new AutoEncryptionOptions configured with default values. func AutoEncryption() AutoEncryptionOptions { return &AutoEncryptionOptions{ HTTPClient: httputil.DefaultHTTPClient, } } // SetKeyVaultClientOptions specifies options for the client used to communicate with the key vault collection. // // If this is set, it is used to create an internal mongo.Client. // Otherwise, if the target mongo.Client being configured has an unlimited connection pool size (i.e. maxPoolSize=0), // it is reused to interact with the key vault collection. // Otherwise, if the target mongo.Client has a limited connection pool size, a separate internal mongo.Client is used // (and created if necessary). The internal mongo.Client may be shared during automatic encryption (if // BypassAutomaticEncryption is false). The internal mongo.Client is configured with the same options as the target // mongo.Client except minPoolSize is set to 0 and AutoEncryptionOptions is omitted. func (a AutoEncryptionOptions) SetKeyVaultClientOptions(opts ClientOptions) AutoEncryptionOptions { a.KeyVaultClientOptions = opts return a } // SetKeyVaultNamespace specifies the namespace of the key vault collection. This is required. func (a AutoEncryptionOptions) SetKeyVaultNamespace(ns string) AutoEncryptionOptions { a.KeyVaultNamespace = ns return a } // SetKmsProviders specifies options for KMS providers. This is required. func (a AutoEncryptionOptions) SetKmsProviders(providers map[string]map[string]interface{}) AutoEncryptionOptions { a.KmsProviders = providers return a } // SetSchemaMap specifies a map from namespace to local schema document. Schemas supplied in the schemaMap only apply // to configuring automatic encryption for client side encryption. Other validation rules in the JSON schema will not // be enforced by the driver and will result in an error. // // Supplying a schemaMap provides more security than relying on JSON Schemas obtained from the server. It protects // against a malicious server advertising a false JSON Schema, which could trick the client into sending unencrypted // data that should be encrypted. func (a AutoEncryptionOptions) SetSchemaMap(schemaMap map[string]interface{}) AutoEncryptionOptions { a.SchemaMap = schemaMap return a } // SetBypassAutoEncryption specifies whether or not auto encryption should be done. // // If this is unset or false and target mongo.Client being configured has an unlimited connection pool size // (i.e. maxPoolSize=0), it is reused in the process of auto encryption. // Otherwise, if the target mongo.Client has a limited connection pool size, a separate internal mongo.Client is used // (and created if necessary). The internal mongo.Client may be shared for key vault operations (if KeyVaultClient is // unset). The internal mongo.Client is configured with the same options as the target mongo.Client except minPoolSize // is set to 0 and AutoEncryptionOptions is omitted. func (a AutoEncryptionOptions) SetBypassAutoEncryption(bypass bool) AutoEncryptionOptions { a.BypassAutoEncryption = &bypass return a } // SetExtraOptions specifies a map of options to configure the mongocryptd process or mongo_crypt shared library. // // # Supported Extra Options // // "mongocryptdURI" - The mongocryptd URI. Allows setting a custom URI used to communicate with the // mongocryptd process. The default is "mongodb://localhost:27020", which works with the default // mongocryptd process spawned by the Client. Must be a string. // // "mongocryptdBypassSpawn" - If set to true, the Client will not attempt to spawn a mongocryptd // process. Must be a bool. // // "mongocryptdSpawnPath" - The path used when spawning mongocryptd. // Defaults to empty string and spawns mongocryptd from system path. Must be a string. // // "mongocryptdSpawnArgs" - Command line arguments passed when spawning mongocryptd. // Defaults to ["--idleShutdownTimeoutSecs=60"]. Must be an array of strings. // // "cryptSharedLibRequired" - If set to true, Client creation will return an error if the // crypt_shared library is not loaded. If unset or set to false, Client creation will not return an // error if the crypt_shared library is not loaded. The default is unset. Must be a bool. // // "cryptSharedLibPath" - The crypt_shared library override path. This must be the path to the // crypt_shared dynamic library file (for example, a .so, .dll, or .dylib file), not the directory // that contains it. If the override path is a relative path, it will be resolved relative to the // working directory of the process. If the override path is a relative path and the first path // component is the literal string "$ORIGIN", the "$ORIGIN" component will be replaced by the // absolute path to the directory containing the linked libmongocrypt library. Setting an override // path disables the default system library search path. If an override path is specified but the // crypt_shared library cannot be loaded, Client creation will return an error. Must be a string. func (a AutoEncryptionOptions) SetExtraOptions(extraOpts map[string]interface{}) AutoEncryptionOptions { a.ExtraOptions = extraOpts return a } // SetTLSConfig specifies tls.Config instances for each KMS provider to use to configure TLS on all connections created // to the KMS provider. // // This should only be used to set custom TLS configurations. By default, the connection will use an empty tls.Config{} with MinVersion set to tls.VersionTLS12. func (a AutoEncryptionOptions) SetTLSConfig(tlsOpts map[string]tls.Config) AutoEncryptionOptions { tlsConfigs := make(map[string]tls.Config) for provider, config := range tlsOpts { // use TLS min version 1.2 to enforce more secure hash algorithms and advanced cipher suites if config.MinVersion == 0 { config.MinVersion = tls.VersionTLS12 } tlsConfigs[provider] = config } a.TLSConfig = tlsConfigs return a } // SetEncryptedFieldsMap specifies a map from namespace to local EncryptedFieldsMap document. // EncryptedFieldsMap is used for Queryable Encryption. func (a AutoEncryptionOptions) SetEncryptedFieldsMap(ef map[string]interface{}) AutoEncryptionOptions { a.EncryptedFieldsMap = ef return a } // SetBypassQueryAnalysis specifies whether or not query analysis should be used for automatic encryption. // Use this option when using explicit encryption with Queryable Encryption. func (a AutoEncryptionOptions) SetBypassQueryAnalysis(bypass bool) AutoEncryptionOptions { a.BypassQueryAnalysis = &bypass return a } // MergeAutoEncryptionOptions combines the argued AutoEncryptionOptions in a last-one wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeAutoEncryptionOptions(opts ...AutoEncryptionOptions) *AutoEncryptionOptions { aeo := AutoEncryption() for _, opt := range opts { if opt == nil { continue } if opt.KeyVaultClientOptions != nil { aeo.KeyVaultClientOptions = opt.KeyVaultClientOptions } if opt.KeyVaultNamespace != "" { aeo.KeyVaultNamespace = opt.KeyVaultNamespace } if opt.KmsProviders != nil { aeo.KmsProviders = opt.KmsProviders } if opt.SchemaMap != nil { aeo.SchemaMap = opt.SchemaMap } if opt.BypassAutoEncryption != nil { aeo.BypassAutoEncryption = opt.BypassAutoEncryption } if opt.ExtraOptions != nil { aeo.ExtraOptions = opt.ExtraOptions } if opt.TLSConfig != nil { aeo.TLSConfig = opt.TLSConfig } if opt.EncryptedFieldsMap != nil { aeo.EncryptedFieldsMap = opt.EncryptedFieldsMap } if opt.BypassQueryAnalysis != nil { aeo.BypassQueryAnalysis = opt.BypassQueryAnalysis } if opt.HTTPClient != nil { aeo.HTTPClient = opt.HTTPClient } } return aeo }	9.33 KB	2025-05-25 12:27
📄 bulkwriteoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // DefaultOrdered is the default value for the Ordered option in BulkWriteOptions. var DefaultOrdered = true // BulkWriteOptions represents options that can be used to configure a BulkWrite operation. type BulkWriteOptions struct { // If true, writes executed as part of the operation will opt out of document-level validation on the server. This // option is valid for MongoDB versions >= 3.2 and is ignored for previous server versions. The default value is // false. See https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about document // validation. BypassDocumentValidation bool // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // If true, no writes will be executed after one fails. The default value is true. Ordered bool // Specifies parameters for all update and delete commands in the BulkWrite. This option is only valid for MongoDB // versions >= 5.0. Older servers will report an error for using this option. This must be a document mapping // parameter names to values. Values must be constant or closed expressions that do not reference document fields. // Parameters can then be accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} } // BulkWrite creates a new BulkWriteOptions instance. func BulkWrite() BulkWriteOptions { return &BulkWriteOptions{ Ordered: &DefaultOrdered, } } // SetComment sets the value for the Comment field. func (b BulkWriteOptions) SetComment(comment interface{}) BulkWriteOptions { b.Comment = comment return b } // SetOrdered sets the value for the Ordered field. func (b BulkWriteOptions) SetOrdered(ordered bool) BulkWriteOptions { b.Ordered = &ordered return b } // SetBypassDocumentValidation sets the value for the BypassDocumentValidation field. func (b BulkWriteOptions) SetBypassDocumentValidation(bypass bool) BulkWriteOptions { b.BypassDocumentValidation = &bypass return b } // SetLet sets the value for the Let field. Let specifies parameters for all update and delete commands in the BulkWrite. // This option is only valid for MongoDB versions >= 5.0. Older servers will report an error for using this option. // This must be a document mapping parameter names to values. Values must be constant or closed expressions that do not // reference document fields. Parameters can then be accessed as variables in an aggregate expression context (e.g. "$$var"). func (b BulkWriteOptions) SetLet(let interface{}) BulkWriteOptions { b.Let = &let return b } // MergeBulkWriteOptions combines the given BulkWriteOptions instances into a single BulkWriteOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeBulkWriteOptions(opts ...BulkWriteOptions) BulkWriteOptions { b := BulkWrite() for _, opt := range opts { if opt == nil { continue } if opt.Comment != nil { b.Comment = opt.Comment } if opt.Ordered != nil { b.Ordered = opt.Ordered } if opt.BypassDocumentValidation != nil { b.BypassDocumentValidation = opt.BypassDocumentValidation } if opt.Let != nil { b.Let = opt.Let } } return b }	3.62 KB	2025-05-25 12:27
📄 changestreamoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/primitive" ) // ChangeStreamOptions represents options that can be used to configure a Watch operation. type ChangeStreamOptions struct { // The maximum number of documents to be included in each batch returned by the server. BatchSize int32 // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string that will be included in server logs, profiling logs, and currentOp queries to help trace the operation. // The default is nil, which means that no comment will be included in the logs. Comment string // Specifies how the updated document should be returned in change notifications for update operations. The default // is options.Default, which means that only partial update deltas will be included in the change notification. FullDocument FullDocument // Specifies how the pre-update document should be returned in change notifications for update operations. The default // is options.Off, which means that the pre-update document will not be included in the change notification. FullDocumentBeforeChange FullDocument // The maximum amount of time that the server should wait for new documents to satisfy a tailable cursor query. MaxAwaitTime time.Duration // A document specifying the logical starting point for the change stream. Only changes corresponding to an oplog // entry immediately after the resume token will be returned. If this is specified, StartAtOperationTime and // StartAfter must not be set. ResumeAfter interface{} // ShowExpandedEvents specifies whether the server will return an expanded list of change stream events. Additional // events include: createIndexes, dropIndexes, modify, create, shardCollection, reshardCollection and // refineCollectionShardKey. This option is only valid for MongoDB versions >= 6.0. ShowExpandedEvents bool // If specified, the change stream will only return changes that occurred at or after the given timestamp. This // option is only valid for MongoDB versions >= 4.0. If this is specified, ResumeAfter and StartAfter must not be // set. StartAtOperationTime primitive.Timestamp // A document specifying the logical starting point for the change stream. This is similar to the ResumeAfter // option, but allows a resume token from an "invalidate" notification to be used. This allows a change stream on a // collection to be resumed after the collection has been dropped and recreated or renamed. Only changes // corresponding to an oplog entry immediately after the specified token will be returned. If this is specified, // ResumeAfter and StartAtOperationTime must not be set. This option is only valid for MongoDB versions >= 4.1.1. StartAfter interface{} // Custom options to be added to the initial aggregate for the change stream. Key-value pairs of the BSON map should // correlate with desired option names and values. Values must be Marshalable. Custom options may conflict with // non-custom options, and custom options bypass client-side validation. Prefer using non-custom options where possible. Custom bson.M // Custom options to be added to the $changeStream stage in the initial aggregate. Key-value pairs of the BSON map should // correlate with desired option names and values. Values must be Marshalable. Custom pipeline options bypass client-side // validation. Prefer using non-custom options where possible. CustomPipeline bson.M } // ChangeStream creates a new ChangeStreamOptions instance. func ChangeStream() ChangeStreamOptions { cso := &ChangeStreamOptions{} return cso } // SetBatchSize sets the value for the BatchSize field. func (cso ChangeStreamOptions) SetBatchSize(i int32) ChangeStreamOptions { cso.BatchSize = &i return cso } // SetCollation sets the value for the Collation field. func (cso ChangeStreamOptions) SetCollation(c Collation) ChangeStreamOptions { cso.Collation = &c return cso } // SetComment sets the value for the Comment field. func (cso ChangeStreamOptions) SetComment(comment string) ChangeStreamOptions { cso.Comment = &comment return cso } // SetFullDocument sets the value for the FullDocument field. func (cso ChangeStreamOptions) SetFullDocument(fd FullDocument) ChangeStreamOptions { cso.FullDocument = &fd return cso } // SetFullDocumentBeforeChange sets the value for the FullDocumentBeforeChange field. func (cso ChangeStreamOptions) SetFullDocumentBeforeChange(fdbc FullDocument) ChangeStreamOptions { cso.FullDocumentBeforeChange = &fdbc return cso } // SetMaxAwaitTime sets the value for the MaxAwaitTime field. func (cso ChangeStreamOptions) SetMaxAwaitTime(d time.Duration) ChangeStreamOptions { cso.MaxAwaitTime = &d return cso } // SetResumeAfter sets the value for the ResumeAfter field. func (cso ChangeStreamOptions) SetResumeAfter(rt interface{}) ChangeStreamOptions { cso.ResumeAfter = rt return cso } // SetShowExpandedEvents sets the value for the ShowExpandedEvents field. func (cso ChangeStreamOptions) SetShowExpandedEvents(see bool) ChangeStreamOptions { cso.ShowExpandedEvents = &see return cso } // SetStartAtOperationTime sets the value for the StartAtOperationTime field. func (cso ChangeStreamOptions) SetStartAtOperationTime(t primitive.Timestamp) ChangeStreamOptions { cso.StartAtOperationTime = t return cso } // SetStartAfter sets the value for the StartAfter field. func (cso ChangeStreamOptions) SetStartAfter(sa interface{}) ChangeStreamOptions { cso.StartAfter = sa return cso } // SetCustom sets the value for the Custom field. Key-value pairs of the BSON map should correlate // with desired option names and values. Values must be Marshalable. Custom options may conflict // with non-custom options, and custom options bypass client-side validation. Prefer using non-custom // options where possible. func (cso ChangeStreamOptions) SetCustom(c bson.M) ChangeStreamOptions { cso.Custom = c return cso } // SetCustomPipeline sets the value for the CustomPipeline field. Key-value pairs of the BSON map // should correlate with desired option names and values. Values must be Marshalable. Custom pipeline // options bypass client-side validation. Prefer using non-custom options where possible. func (cso ChangeStreamOptions) SetCustomPipeline(cp bson.M) ChangeStreamOptions { cso.CustomPipeline = cp return cso } // MergeChangeStreamOptions combines the given ChangeStreamOptions instances into a single ChangeStreamOptions in a // last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeChangeStreamOptions(opts ...ChangeStreamOptions) ChangeStreamOptions { csOpts := ChangeStream() for _, cso := range opts { if cso == nil { continue } if cso.BatchSize != nil { csOpts.BatchSize = cso.BatchSize } if cso.Collation != nil { csOpts.Collation = cso.Collation } if cso.Comment != nil { csOpts.Comment = cso.Comment } if cso.FullDocument != nil { csOpts.FullDocument = cso.FullDocument } if cso.FullDocumentBeforeChange != nil { csOpts.FullDocumentBeforeChange = cso.FullDocumentBeforeChange } if cso.MaxAwaitTime != nil { csOpts.MaxAwaitTime = cso.MaxAwaitTime } if cso.ResumeAfter != nil { csOpts.ResumeAfter = cso.ResumeAfter } if cso.ShowExpandedEvents != nil { csOpts.ShowExpandedEvents = cso.ShowExpandedEvents } if cso.StartAtOperationTime != nil { csOpts.StartAtOperationTime = cso.StartAtOperationTime } if cso.StartAfter != nil { csOpts.StartAfter = cso.StartAfter } if cso.Custom != nil { csOpts.Custom = cso.Custom } if cso.CustomPipeline != nil { csOpts.CustomPipeline = cso.CustomPipeline } } return csOpts }	8.19 KB	2025-05-25 12:27
📄 changestreamoptions_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "testing" "go.mongodb.org/mongo-driver/internal/assert" ) func TestMergeChangeStreamOptions(t testing.T) { t.Parallel() fullDocumentP := func(x FullDocument) FullDocument { return &x } int32P := func(x int32) int32 { return &x } testCases := []struct { description string input []ChangeStreamOptions want ChangeStreamOptions }{ { description: "empty", input: []ChangeStreamOptions{}, want: &ChangeStreamOptions{}, }, { description: "many ChangeStreamOptions with one configuration each", input: []ChangeStreamOptions{ ChangeStream().SetFullDocumentBeforeChange(Required), ChangeStream().SetFullDocument(Required), ChangeStream().SetBatchSize(10), }, want: &ChangeStreamOptions{ FullDocument: fullDocumentP(Required), FullDocumentBeforeChange: fullDocumentP(Required), BatchSize: int32P(10), }, }, { description: "single ChangeStreamOptions with many configurations", input: []ChangeStreamOptions{ ChangeStream(). SetFullDocumentBeforeChange(Required). SetFullDocument(Required). SetBatchSize(10), }, want: &ChangeStreamOptions{ FullDocument: fullDocumentP(Required), FullDocumentBeforeChange: fullDocumentP(Required), BatchSize: int32P(10), }, }, } for _, tc := range testCases { tc := tc // Capture range variable. t.Run(tc.description, func(t *testing.T) { t.Parallel() got := MergeChangeStreamOptions(tc.input...) assert.Equal(t, tc.want, got, "expected and actual ChangeStreamOptions are different") }) } }	1.89 KB	2025-05-25 12:27
📄 clientencryptionoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "crypto/tls" "fmt" "net/http" "go.mongodb.org/mongo-driver/internal/httputil" ) // ClientEncryptionOptions represents all possible options used to configure a ClientEncryption instance. type ClientEncryptionOptions struct { KeyVaultNamespace string KmsProviders map[string]map[string]interface{} TLSConfig map[string]tls.Config HTTPClient http.Client } // ClientEncryption creates a new ClientEncryptionOptions instance. func ClientEncryption() ClientEncryptionOptions { return &ClientEncryptionOptions{ HTTPClient: httputil.DefaultHTTPClient, } } // SetKeyVaultNamespace specifies the namespace of the key vault collection. This is required. func (c ClientEncryptionOptions) SetKeyVaultNamespace(ns string) ClientEncryptionOptions { c.KeyVaultNamespace = ns return c } // SetKmsProviders specifies options for KMS providers. This is required. func (c ClientEncryptionOptions) SetKmsProviders(providers map[string]map[string]interface{}) ClientEncryptionOptions { c.KmsProviders = providers return c } // SetTLSConfig specifies tls.Config instances for each KMS provider to use to configure TLS on all connections created // to the KMS provider. // // This should only be used to set custom TLS configurations. By default, the connection will use an empty tls.Config{} with MinVersion set to tls.VersionTLS12. func (c ClientEncryptionOptions) SetTLSConfig(tlsOpts map[string]tls.Config) ClientEncryptionOptions { tlsConfigs := make(map[string]tls.Config) for provider, config := range tlsOpts { // use TLS min version 1.2 to enforce more secure hash algorithms and advanced cipher suites if config.MinVersion == 0 { config.MinVersion = tls.VersionTLS12 } tlsConfigs[provider] = config } c.TLSConfig = tlsConfigs return c } // BuildTLSConfig specifies tls.Config options for each KMS provider to use to configure TLS on all connections created // to the KMS provider. The input map should contain a mapping from each KMS provider to a document containing the necessary // options, as follows: // // { // "kmip": { // "tlsCertificateKeyFile": "foo.pem", // "tlsCAFile": "fooCA.pem" // } // } // // Currently, the following TLS options are supported: // // 1. "tlsCertificateKeyFile" (or "sslClientCertificateKeyFile"): The "tlsCertificateKeyFile" option specifies a path to // the client certificate and private key, which must be concatenated into one file. // // 2. "tlsCertificateKeyFilePassword" (or "sslClientCertificateKeyPassword"): Specify the password to decrypt the client // private key file (e.g. "tlsCertificateKeyFilePassword=password"). // // 3. "tlsCaFile" (or "sslCertificateAuthorityFile"): Specify the path to a single or bundle of certificate authorities // to be considered trusted when making a TLS connection (e.g. "tlsCaFile=/path/to/caFile"). // // This should only be used to set custom TLS options. By default, the connection will use an empty tls.Config{} with MinVersion set to tls.VersionTLS12. func BuildTLSConfig(tlsOpts map[string]interface{}) (tls.Config, error) { // use TLS min version 1.2 to enforce more secure hash algorithms and advanced cipher suites cfg := &tls.Config{MinVersion: tls.VersionTLS12} for name := range tlsOpts { var err error switch name { case "tlsCertificateKeyFile", "sslClientCertificateKeyFile": clientCertPath, ok := tlsOpts[name].(string) if !ok { return nil, fmt.Errorf("expected %q value to be of type string, got %T", name, tlsOpts[name]) } // apply custom key file password if found, otherwise use empty string if keyPwd, found := tlsOpts["tlsCertificateKeyFilePassword"].(string); found { _, err = addClientCertFromConcatenatedFile(cfg, clientCertPath, keyPwd) } else if keyPwd, found := tlsOpts["sslClientCertificateKeyPassword"].(string); found { _, err = addClientCertFromConcatenatedFile(cfg, clientCertPath, keyPwd) } else { _, err = addClientCertFromConcatenatedFile(cfg, clientCertPath, "") } case "tlsCertificateKeyFilePassword", "sslClientCertificateKeyPassword": continue case "tlsCAFile", "sslCertificateAuthorityFile": caPath, ok := tlsOpts[name].(string) if !ok { return nil, fmt.Errorf("expected %q value to be of type string, got %T", name, tlsOpts[name]) } err = addCACertFromFile(cfg, caPath) default: return nil, fmt.Errorf("unrecognized TLS option %v", name) } if err != nil { return nil, err } } return cfg, nil } // MergeClientEncryptionOptions combines the argued ClientEncryptionOptions in a last-one wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeClientEncryptionOptions(opts ...ClientEncryptionOptions) ClientEncryptionOptions { ceo := ClientEncryption() for _, opt := range opts { if opt == nil { continue } if opt.KeyVaultNamespace != "" { ceo.KeyVaultNamespace = opt.KeyVaultNamespace } if opt.KmsProviders != nil { ceo.KmsProviders = opt.KmsProviders } if opt.TLSConfig != nil { ceo.TLSConfig = opt.TLSConfig } if opt.HTTPClient != nil { ceo.HTTPClient = opt.HTTPClient } } return ceo }	5.38 KB	2025-05-25 12:27
📄 clientoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // import "go.mongodb.org/mongo-driver/mongo/options" import ( "bytes" "context" "crypto/tls" "crypto/x509" "encoding/pem" "errors" "fmt" "io/ioutil" "net" "net/http" "strings" "time" "github.com/youmark/pkcs8" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/httputil" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" "go.mongodb.org/mongo-driver/tag" "go.mongodb.org/mongo-driver/x/mongo/driver" "go.mongodb.org/mongo-driver/x/mongo/driver/connstring" "go.mongodb.org/mongo-driver/x/mongo/driver/wiremessage" ) const ( // ServerMonitoringModeAuto indicates that the client will behave like "poll" // mode when running on a FaaS (Function as a Service) platform, or like // "stream" mode otherwise. The client detects its execution environment by // following the rules for generating the "client.env" handshake metadata field // as specified in the MongoDB Handshake specification. This is the default // mode. ServerMonitoringModeAuto = connstring.ServerMonitoringModeAuto // ServerMonitoringModePoll indicates that the client will periodically check // the server using a hello or legacy hello command and then sleep for // heartbeatFrequencyMS milliseconds before running another check. ServerMonitoringModePoll = connstring.ServerMonitoringModePoll // ServerMonitoringModeStream indicates that the client will use a streaming // protocol when the server supports it. The streaming protocol optimally // reduces the time it takes for a client to discover server state changes. ServerMonitoringModeStream = connstring.ServerMonitoringModeStream ) // ContextDialer is an interface that can be implemented by types that can create connections. It should be used to // provide a custom dialer when configuring a Client. // // DialContext should return a connection to the provided address on the given network. type ContextDialer interface { DialContext(ctx context.Context, network, address string) (net.Conn, error) } // Credential can be used to provide authentication options when configuring a Client. // // AuthMechanism: the mechanism to use for authentication. Supported values include "SCRAM-SHA-256", "SCRAM-SHA-1", // "MONGODB-CR", "PLAIN", "GSSAPI", "MONGODB-X509", and "MONGODB-AWS". This can also be set through the "authMechanism" // URI option. (e.g. "authMechanism=PLAIN"). For more information, see // https://www.mongodb.com/docs/manual/core/authentication-mechanisms/. // // AuthMechanismProperties can be used to specify additional configuration options for certain mechanisms. They can also // be set through the "authMechanismProperites" URI option // (e.g. "authMechanismProperties=SERVICE_NAME:service,CANONICALIZE_HOST_NAME:true"). Supported properties are: // // 1. SERVICE_NAME: The service name to use for GSSAPI authentication. The default is "mongodb". // // 2. CANONICALIZE_HOST_NAME: If "true", the driver will canonicalize the host name for GSSAPI authentication. The default // is "false". // // 3. SERVICE_REALM: The service realm for GSSAPI authentication. // // 4. SERVICE_HOST: The host name to use for GSSAPI authentication. This should be specified if the host name to use for // authentication is different than the one given for Client construction. // // 4. AWS_SESSION_TOKEN: The AWS token for MONGODB-AWS authentication. This is optional and used for authentication with // temporary credentials. // // The SERVICE_HOST and CANONICALIZE_HOST_NAME properties must not be used at the same time on Linux and Darwin // systems. // // AuthSource: the name of the database to use for authentication. This defaults to "$external" for MONGODB-X509, // GSSAPI, and PLAIN and "admin" for all other mechanisms. This can also be set through the "authSource" URI option // (e.g. "authSource=otherDb"). // // Username: the username for authentication. This can also be set through the URI as a username:password pair before // the first @ character. For example, a URI for user "user", password "pwd", and host "localhost:27017" would be // "mongodb://user:pwd@localhost:27017". This is optional for X509 authentication and will be extracted from the // client certificate if not specified. // // Password: the password for authentication. This must not be specified for X509 and is optional for GSSAPI // authentication. // // PasswordSet: For GSSAPI, this must be true if a password is specified, even if the password is the empty string, and // false if no password is specified, indicating that the password should be taken from the context of the running // process. For other mechanisms, this field is ignored. type Credential struct { AuthMechanism string AuthMechanismProperties map[string]string AuthSource string Username string Password string PasswordSet bool } // BSONOptions are optional BSON marshaling and unmarshaling behaviors. type BSONOptions struct { // UseJSONStructTags causes the driver to fall back to using the "json" // struct tag if a "bson" struct tag is not specified. UseJSONStructTags bool // ErrorOnInlineDuplicates causes the driver to return an error if there is // a duplicate field in the marshaled BSON when the "inline" struct tag // option is set. ErrorOnInlineDuplicates bool // IntMinSize causes the driver to marshal Go integer values (int, int8, // int16, int32, int64, uint, uint8, uint16, uint32, or uint64) as the // minimum BSON int size (either 32 or 64 bits) that can represent the // integer value. IntMinSize bool // NilMapAsEmpty causes the driver to marshal nil Go maps as empty BSON // documents instead of BSON null. // // Empty BSON documents take up slightly more space than BSON null, but // preserve the ability to use document update operations like "$set" that // do not work on BSON null. NilMapAsEmpty bool // NilSliceAsEmpty causes the driver to marshal nil Go slices as empty BSON // arrays instead of BSON null. // // Empty BSON arrays take up slightly more space than BSON null, but // preserve the ability to use array update operations like "$push" or // "$addToSet" that do not work on BSON null. NilSliceAsEmpty bool // NilByteSliceAsEmpty causes the driver to marshal nil Go byte slices as // empty BSON binary values instead of BSON null. NilByteSliceAsEmpty bool // OmitZeroStruct causes the driver to consider the zero value for a struct // (e.g. MyStruct{}) as empty and omit it from the marshaled BSON when the // "omitempty" struct tag option is set. OmitZeroStruct bool // StringifyMapKeysWithFmt causes the driver to convert Go map keys to BSON // document field name strings using fmt.Sprint instead of the default // string conversion logic. StringifyMapKeysWithFmt bool // AllowTruncatingDoubles causes the driver to truncate the fractional part // of BSON "double" values when attempting to unmarshal them into a Go // integer (int, int8, int16, int32, or int64) struct field. The truncation // logic does not apply to BSON "decimal128" values. AllowTruncatingDoubles bool // BinaryAsSlice causes the driver to unmarshal BSON binary field values // that are the "Generic" or "Old" BSON binary subtype as a Go byte slice // instead of a primitive.Binary. BinaryAsSlice bool // DefaultDocumentD causes the driver to always unmarshal documents into the // primitive.D type. This behavior is restricted to data typed as // "interface{}" or "map[string]interface{}". DefaultDocumentD bool // DefaultDocumentM causes the driver to always unmarshal documents into the // primitive.M type. This behavior is restricted to data typed as // "interface{}" or "map[string]interface{}". DefaultDocumentM bool // UseLocalTimeZone causes the driver to unmarshal time.Time values in the // local timezone instead of the UTC timezone. UseLocalTimeZone bool // ZeroMaps causes the driver to delete any existing values from Go maps in // the destination value before unmarshaling BSON documents into them. ZeroMaps bool // ZeroStructs causes the driver to delete any existing values from Go // structs in the destination value before unmarshaling BSON documents into // them. ZeroStructs bool } // ClientOptions contains options to configure a Client instance. Each option can be set through setter functions. See // documentation for each setter function for an explanation of the option. type ClientOptions struct { AppName string Auth Credential AutoEncryptionOptions AutoEncryptionOptions ConnectTimeout time.Duration Compressors []string Dialer ContextDialer Direct bool DisableOCSPEndpointCheck bool HeartbeatInterval time.Duration Hosts []string HTTPClient http.Client LoadBalanced bool LocalThreshold time.Duration LoggerOptions LoggerOptions MaxConnIdleTime time.Duration MaxPoolSize uint64 MinPoolSize uint64 MaxConnecting uint64 PoolMonitor event.PoolMonitor Monitor event.CommandMonitor ServerMonitor event.ServerMonitor ReadConcern readconcern.ReadConcern ReadPreference readpref.ReadPref BSONOptions BSONOptions Registry bsoncodec.Registry ReplicaSet string RetryReads bool RetryWrites bool ServerAPIOptions ServerAPIOptions ServerMonitoringMode string ServerSelectionTimeout time.Duration SRVMaxHosts int SRVServiceName string Timeout time.Duration TLSConfig tls.Config WriteConcern writeconcern.WriteConcern ZlibLevel int ZstdLevel int err error cs connstring.ConnString // AuthenticateToAnything skips server type checks when deciding if authentication is possible. // // Deprecated: This option is for internal use only and should not be set. It may be changed or removed in any // release. AuthenticateToAnything bool // Crypt specifies a custom driver.Crypt to be used to encrypt and decrypt documents. The default is no // encryption. // // Deprecated: This option is for internal use only and should not be set (see GODRIVER-2149). It may be // changed or removed in any release. Crypt driver.Crypt // Deployment specifies a custom deployment to use for the new Client. // // Deprecated: This option is for internal use only and should not be set. It may be changed or removed in any // release. Deployment driver.Deployment // SocketTimeout specifies the timeout to be used for the Client's socket reads and writes. // // NOTE(benjirewis): SocketTimeout will be deprecated in a future release. The more general Timeout option // may be used in its place to control the amount of time that a single operation can run before returning // an error. Setting SocketTimeout and Timeout on a single client will result in undefined behavior. SocketTimeout time.Duration } // Client creates a new ClientOptions instance. func Client() ClientOptions { return &ClientOptions{ HTTPClient: httputil.DefaultHTTPClient, } } // Validate validates the client options. This method will return the first error found. func (c ClientOptions) Validate() error { if c.err != nil { return c.err } c.err = c.validate() return c.err } func (c ClientOptions) validate() error { // Direct connections cannot be made if multiple hosts are specified or an SRV URI is used. if c.Direct != nil && c.Direct { if len(c.Hosts) > 1 { return errors.New("a direct connection cannot be made if multiple hosts are specified") } if c.cs != nil && c.cs.Scheme == connstring.SchemeMongoDBSRV { return errors.New("a direct connection cannot be made if an SRV URI is used") } } if c.MaxPoolSize != nil && c.MinPoolSize != nil && c.MaxPoolSize != 0 && c.MinPoolSize > c.MaxPoolSize { return fmt.Errorf("minPoolSize must be less than or equal to maxPoolSize, got minPoolSize=%d maxPoolSize=%d", c.MinPoolSize, c.MaxPoolSize) } // verify server API version if ServerAPIOptions are passed in. if c.ServerAPIOptions != nil { if err := c.ServerAPIOptions.ServerAPIVersion.Validate(); err != nil { return err } } // Validation for load-balanced mode. if c.LoadBalanced != nil && c.LoadBalanced { if len(c.Hosts) > 1 { return connstring.ErrLoadBalancedWithMultipleHosts } if c.ReplicaSet != nil { return connstring.ErrLoadBalancedWithReplicaSet } if c.Direct != nil && c.Direct { return connstring.ErrLoadBalancedWithDirectConnection } } // Validation for srvMaxHosts. if c.SRVMaxHosts != nil && c.SRVMaxHosts > 0 { if c.ReplicaSet != nil { return connstring.ErrSRVMaxHostsWithReplicaSet } if c.LoadBalanced != nil && c.LoadBalanced { return connstring.ErrSRVMaxHostsWithLoadBalanced } } if mode := c.ServerMonitoringMode; mode != nil && !connstring.IsValidServerMonitoringMode(mode) { return fmt.Errorf("invalid server monitoring mode: %q", mode) } return nil } // GetURI returns the original URI used to configure the ClientOptions instance. If ApplyURI was not called during // construction, this returns "". func (c ClientOptions) GetURI() string { if c.cs == nil { return "" } return c.cs.Original } // ApplyURI parses the given URI and sets options accordingly. The URI can contain host names, IPv4/IPv6 literals, or // an SRV record that will be resolved when the Client is created. When using an SRV record, TLS support is // implicitly enabled. Specify the "tls=false" URI option to override this. // // If the connection string contains any options that have previously been set, it will overwrite them. Options that // correspond to multiple URI parameters, such as WriteConcern, will be completely overwritten if any of the query // parameters are specified. If an option is set on ClientOptions after this method is called, that option will override // any option applied via the connection string. // // If the URI format is incorrect or there are conflicting options specified in the URI an error will be recorded and // can be retrieved by calling Validate. // // For more information about the URI format, see https://www.mongodb.com/docs/manual/reference/connection-string/. See // mongo.Connect documentation for examples of using URIs for different Client configurations. func (c ClientOptions) ApplyURI(uri string) ClientOptions { if c.err != nil { return c } cs, err := connstring.ParseAndValidate(uri) if err != nil { c.err = err return c } c.cs = cs if cs.AppName != "" { c.AppName = &cs.AppName } // Only create a Credential if there is a request for authentication via non-empty credentials in the URI. if cs.HasAuthParameters() { c.Auth = &Credential{ AuthMechanism: cs.AuthMechanism, AuthMechanismProperties: cs.AuthMechanismProperties, AuthSource: cs.AuthSource, Username: cs.Username, Password: cs.Password, PasswordSet: cs.PasswordSet, } } if cs.ConnectSet { direct := cs.Connect == connstring.SingleConnect c.Direct = &direct } if cs.DirectConnectionSet { c.Direct = &cs.DirectConnection } if cs.ConnectTimeoutSet { c.ConnectTimeout = &cs.ConnectTimeout } if len(cs.Compressors) > 0 { c.Compressors = cs.Compressors if stringSliceContains(c.Compressors, "zlib") { defaultLevel := wiremessage.DefaultZlibLevel c.ZlibLevel = &defaultLevel } if stringSliceContains(c.Compressors, "zstd") { defaultLevel := wiremessage.DefaultZstdLevel c.ZstdLevel = &defaultLevel } } if cs.HeartbeatIntervalSet { c.HeartbeatInterval = &cs.HeartbeatInterval } c.Hosts = cs.Hosts if cs.LoadBalancedSet { c.LoadBalanced = &cs.LoadBalanced } if cs.LocalThresholdSet { c.LocalThreshold = &cs.LocalThreshold } if cs.MaxConnIdleTimeSet { c.MaxConnIdleTime = &cs.MaxConnIdleTime } if cs.MaxPoolSizeSet { c.MaxPoolSize = &cs.MaxPoolSize } if cs.MinPoolSizeSet { c.MinPoolSize = &cs.MinPoolSize } if cs.MaxConnectingSet { c.MaxConnecting = &cs.MaxConnecting } if cs.ReadConcernLevel != "" { c.ReadConcern = readconcern.New(readconcern.Level(cs.ReadConcernLevel)) } if cs.ReadPreference != "" \|\| len(cs.ReadPreferenceTagSets) > 0 \|\| cs.MaxStalenessSet { opts := make([]readpref.Option, 0, 1) tagSets := tag.NewTagSetsFromMaps(cs.ReadPreferenceTagSets) if len(tagSets) > 0 { opts = append(opts, readpref.WithTagSets(tagSets...)) } if cs.MaxStaleness != 0 { opts = append(opts, readpref.WithMaxStaleness(cs.MaxStaleness)) } mode, err := readpref.ModeFromString(cs.ReadPreference) if err != nil { c.err = err return c } c.ReadPreference, c.err = readpref.New(mode, opts...) if c.err != nil { return c } } if cs.RetryWritesSet { c.RetryWrites = &cs.RetryWrites } if cs.RetryReadsSet { c.RetryReads = &cs.RetryReads } if cs.ReplicaSet != "" { c.ReplicaSet = &cs.ReplicaSet } if cs.ServerSelectionTimeoutSet { c.ServerSelectionTimeout = &cs.ServerSelectionTimeout } if cs.SocketTimeoutSet { c.SocketTimeout = &cs.SocketTimeout } if cs.SRVMaxHosts != 0 { c.SRVMaxHosts = &cs.SRVMaxHosts } if cs.SRVServiceName != "" { c.SRVServiceName = &cs.SRVServiceName } if cs.SSL { tlsConfig := new(tls.Config) if cs.SSLCaFileSet { c.err = addCACertFromFile(tlsConfig, cs.SSLCaFile) if c.err != nil { return c } } if cs.SSLInsecure { tlsConfig.InsecureSkipVerify = true } var x509Subject string var keyPasswd string if cs.SSLClientCertificateKeyPasswordSet && cs.SSLClientCertificateKeyPassword != nil { keyPasswd = cs.SSLClientCertificateKeyPassword() } if cs.SSLClientCertificateKeyFileSet { x509Subject, err = addClientCertFromConcatenatedFile(tlsConfig, cs.SSLClientCertificateKeyFile, keyPasswd) } else if cs.SSLCertificateFileSet \|\| cs.SSLPrivateKeyFileSet { x509Subject, err = addClientCertFromSeparateFiles(tlsConfig, cs.SSLCertificateFile, cs.SSLPrivateKeyFile, keyPasswd) } if err != nil { c.err = err return c } // If a username wasn't specified fork x509, add one from the certificate. if c.Auth != nil && strings.ToLower(c.Auth.AuthMechanism) == "mongodb-x509" && c.Auth.Username == "" { // The Go x509 package gives the subject with the pairs in reverse order that we want. c.Auth.Username = extractX509UsernameFromSubject(x509Subject) } c.TLSConfig = tlsConfig } if cs.JSet \|\| cs.WString != "" \|\| cs.WNumberSet \|\| cs.WTimeoutSet { opts := make([]writeconcern.Option, 0, 1) if len(cs.WString) > 0 { opts = append(opts, writeconcern.WTagSet(cs.WString)) } else if cs.WNumberSet { opts = append(opts, writeconcern.W(cs.WNumber)) } if cs.JSet { opts = append(opts, writeconcern.J(cs.J)) } if cs.WTimeoutSet { opts = append(opts, writeconcern.WTimeout(cs.WTimeout)) } c.WriteConcern = writeconcern.New(opts...) } if cs.ZlibLevelSet { c.ZlibLevel = &cs.ZlibLevel } if cs.ZstdLevelSet { c.ZstdLevel = &cs.ZstdLevel } if cs.SSLDisableOCSPEndpointCheckSet { c.DisableOCSPEndpointCheck = &cs.SSLDisableOCSPEndpointCheck } if cs.TimeoutSet { c.Timeout = &cs.Timeout } return c } // SetAppName specifies an application name that is sent to the server when creating new connections. It is used by the // server to log connection and profiling information (e.g. slow query logs). This can also be set through the "appName" // URI option (e.g "appName=example_application"). The default is empty, meaning no app name will be sent. func (c ClientOptions) SetAppName(s string) ClientOptions { c.AppName = &s return c } // SetAuth specifies a Credential containing options for configuring authentication. See the options.Credential // documentation for more information about Credential fields. The default is an empty Credential, meaning no // authentication will be configured. func (c ClientOptions) SetAuth(auth Credential) ClientOptions { c.Auth = &auth return c } // SetCompressors sets the compressors that can be used when communicating with a server. Valid values are: // // 1. "snappy" - requires server version >= 3.4 // // 2. "zlib" - requires server version >= 3.6 // // 3. "zstd" - requires server version >= 4.2, and driver version >= 1.2.0 with cgo support enabled or driver // version >= 1.3.0 without cgo. // // If this option is specified, the driver will perform a negotiation with the server to determine a common list of // compressors and will use the first one in that list when performing operations. See // https://www.mongodb.com/docs/manual/reference/program/mongod/#cmdoption-mongod-networkmessagecompressors for more // information about configuring compression on the server and the server-side defaults. // // This can also be set through the "compressors" URI option (e.g. "compressors=zstd,zlib,snappy"). The default is // an empty slice, meaning no compression will be enabled. func (c ClientOptions) SetCompressors(comps []string) ClientOptions { c.Compressors = comps return c } // SetConnectTimeout specifies a timeout that is used for creating connections to the server. This can be set through // ApplyURI with the "connectTimeoutMS" (e.g "connectTimeoutMS=30") option. If set to 0, no timeout will be used. The // default is 30 seconds. func (c ClientOptions) SetConnectTimeout(d time.Duration) ClientOptions { c.ConnectTimeout = &d return c } // SetDialer specifies a custom ContextDialer to be used to create new connections to the server. This method overrides // the default net.Dialer, so dialer options such as Timeout, KeepAlive, Resolver, etc can be set. // See https://golang.org/pkg/net/#Dialer for more information about the net.Dialer type. func (c ClientOptions) SetDialer(d ContextDialer) ClientOptions { c.Dialer = d return c } // SetDirect specifies whether or not a direct connect should be made. If set to true, the driver will only connect to // the host provided in the URI and will not discover other hosts in the cluster. This can also be set through the // "directConnection" URI option. This option cannot be set to true if multiple hosts are specified, either through // ApplyURI or SetHosts, or an SRV URI is used. // // As of driver version 1.4, the "connect" URI option has been deprecated and replaced with "directConnection". The // "connect" URI option has two values: // // 1. "connect=direct" for direct connections. This corresponds to "directConnection=true". // // 2. "connect=automatic" for automatic discovery. This corresponds to "directConnection=false" // // If the "connect" and "directConnection" URI options are both specified in the connection string, their values must // not conflict. Direct connections are not valid if multiple hosts are specified or an SRV URI is used. The default // value for this option is false. func (c ClientOptions) SetDirect(b bool) ClientOptions { c.Direct = &b return c } // SetHeartbeatInterval specifies the amount of time to wait between periodic background server checks. This can also be // set through the "heartbeatIntervalMS" URI option (e.g. "heartbeatIntervalMS=10000"). The default is 10 seconds. func (c ClientOptions) SetHeartbeatInterval(d time.Duration) ClientOptions { c.HeartbeatInterval = &d return c } // SetHosts specifies a list of host names or IP addresses for servers in a cluster. Both IPv4 and IPv6 addresses are // supported. IPv6 literals must be enclosed in '[]' following RFC-2732 syntax. // // Hosts can also be specified as a comma-separated list in a URI. For example, to include "localhost:27017" and // "localhost:27018", a URI could be "mongodb://localhost:27017,localhost:27018". The default is ["localhost:27017"] func (c ClientOptions) SetHosts(s []string) ClientOptions { c.Hosts = s return c } // SetLoadBalanced specifies whether or not the MongoDB deployment is hosted behind a load balancer. This can also be // set through the "loadBalanced" URI option. The driver will error during Client configuration if this option is set // to true and one of the following conditions are met: // // 1. Multiple hosts are specified, either via the ApplyURI or SetHosts methods. This includes the case where an SRV // URI is used and the SRV record resolves to multiple hostnames. // 2. A replica set name is specified, either via the URI or the SetReplicaSet method. // 3. The options specify whether or not a direct connection should be made, either via the URI or the SetDirect method. // // The default value is false. func (c ClientOptions) SetLoadBalanced(lb bool) ClientOptions { c.LoadBalanced = &lb return c } // SetLocalThreshold specifies the width of the 'latency window': when choosing between multiple suitable servers for an // operation, this is the acceptable non-negative delta between shortest and longest average round-trip times. A server // within the latency window is selected randomly. This can also be set through the "localThresholdMS" URI option (e.g. // "localThresholdMS=15000"). The default is 15 milliseconds. func (c ClientOptions) SetLocalThreshold(d time.Duration) ClientOptions { c.LocalThreshold = &d return c } // SetLoggerOptions specifies a LoggerOptions containing options for // configuring a logger. func (c ClientOptions) SetLoggerOptions(opts LoggerOptions) ClientOptions { c.LoggerOptions = opts return c } // SetMaxConnIdleTime specifies the maximum amount of time that a connection will remain idle in a connection pool // before it is removed from the pool and closed. This can also be set through the "maxIdleTimeMS" URI option (e.g. // "maxIdleTimeMS=10000"). The default is 0, meaning a connection can remain unused indefinitely. func (c ClientOptions) SetMaxConnIdleTime(d time.Duration) ClientOptions { c.MaxConnIdleTime = &d return c } // SetMaxPoolSize specifies that maximum number of connections allowed in the driver's connection pool to each server. // Requests to a server will block if this maximum is reached. This can also be set through the "maxPoolSize" URI option // (e.g. "maxPoolSize=100"). If this is 0, maximum connection pool size is not limited. The default is 100. func (c ClientOptions) SetMaxPoolSize(u uint64) ClientOptions { c.MaxPoolSize = &u return c } // SetMinPoolSize specifies the minimum number of connections allowed in the driver's connection pool to each server. If // this is non-zero, each server's pool will be maintained in the background to ensure that the size does not fall below // the minimum. This can also be set through the "minPoolSize" URI option (e.g. "minPoolSize=100"). The default is 0. func (c ClientOptions) SetMinPoolSize(u uint64) ClientOptions { c.MinPoolSize = &u return c } // SetMaxConnecting specifies the maximum number of connections a connection pool may establish simultaneously. This can // also be set through the "maxConnecting" URI option (e.g. "maxConnecting=2"). If this is 0, the default is used. The // default is 2. Values greater than 100 are not recommended. func (c ClientOptions) SetMaxConnecting(u uint64) ClientOptions { c.MaxConnecting = &u return c } // SetPoolMonitor specifies a PoolMonitor to receive connection pool events. See the event.PoolMonitor documentation // for more information about the structure of the monitor and events that can be received. func (c ClientOptions) SetPoolMonitor(m event.PoolMonitor) ClientOptions { c.PoolMonitor = m return c } // SetMonitor specifies a CommandMonitor to receive command events. See the event.CommandMonitor documentation for more // information about the structure of the monitor and events that can be received. func (c ClientOptions) SetMonitor(m event.CommandMonitor) ClientOptions { c.Monitor = m return c } // SetServerMonitor specifies an SDAM monitor used to monitor SDAM events. func (c ClientOptions) SetServerMonitor(m event.ServerMonitor) ClientOptions { c.ServerMonitor = m return c } // SetReadConcern specifies the read concern to use for read operations. A read concern level can also be set through // the "readConcernLevel" URI option (e.g. "readConcernLevel=majority"). The default is nil, meaning the server will use // its configured default. func (c ClientOptions) SetReadConcern(rc readconcern.ReadConcern) ClientOptions { c.ReadConcern = rc return c } // SetReadPreference specifies the read preference to use for read operations. This can also be set through the // following URI options: // // 1. "readPreference" - Specify the read preference mode (e.g. "readPreference=primary"). // // 2. "readPreferenceTags": Specify one or more read preference tags // (e.g. "readPreferenceTags=region:south,datacenter:A"). // // 3. "maxStalenessSeconds" (or "maxStaleness"): Specify a maximum replication lag for reads from secondaries in a // replica set (e.g. "maxStalenessSeconds=10"). // // The default is readpref.Primary(). See https://www.mongodb.com/docs/manual/core/read-preference/#read-preference for // more information about read preferences. func (c ClientOptions) SetReadPreference(rp readpref.ReadPref) ClientOptions { c.ReadPreference = rp return c } // SetBSONOptions configures optional BSON marshaling and unmarshaling behavior. func (c ClientOptions) SetBSONOptions(opts BSONOptions) ClientOptions { c.BSONOptions = opts return c } // SetRegistry specifies the BSON registry to use for BSON marshalling/unmarshalling operations. The default is // bson.DefaultRegistry. func (c ClientOptions) SetRegistry(registry bsoncodec.Registry) ClientOptions { c.Registry = registry return c } // SetReplicaSet specifies the replica set name for the cluster. If specified, the cluster will be treated as a replica // set and the driver will automatically discover all servers in the set, starting with the nodes specified through // ApplyURI or SetHosts. All nodes in the replica set must have the same replica set name, or they will not be // considered as part of the set by the Client. This can also be set through the "replicaSet" URI option (e.g. // "replicaSet=replset"). The default is empty. func (c ClientOptions) SetReplicaSet(s string) ClientOptions { c.ReplicaSet = &s return c } // SetRetryWrites specifies whether supported write operations should be retried once on certain errors, such as network // errors. // // Supported operations are InsertOne, UpdateOne, ReplaceOne, DeleteOne, FindOneAndDelete, FindOneAndReplace, // FindOneAndDelete, InsertMany, and BulkWrite. Note that BulkWrite requests must not include UpdateManyModel or // DeleteManyModel instances to be considered retryable. Unacknowledged writes will not be retried, even if this option // is set to true. // // This option requires server version >= 3.6 and a replica set or sharded cluster and will be ignored for any other // cluster type. This can also be set through the "retryWrites" URI option (e.g. "retryWrites=true"). The default is // true. func (c ClientOptions) SetRetryWrites(b bool) ClientOptions { c.RetryWrites = &b return c } // SetRetryReads specifies whether supported read operations should be retried once on certain errors, such as network // errors. // // Supported operations are Find, FindOne, Aggregate without a $out stage, Distinct, CountDocuments, // EstimatedDocumentCount, Watch (for Client, Database, and Collection), ListCollections, and ListDatabases. Note that // operations run through RunCommand are not retried. // // This option requires server version >= 3.6 and driver version >= 1.1.0. The default is true. func (c ClientOptions) SetRetryReads(b bool) ClientOptions { c.RetryReads = &b return c } // SetServerSelectionTimeout specifies how long the driver will wait to find an available, suitable server to execute an // operation. This can also be set through the "serverSelectionTimeoutMS" URI option (e.g. // "serverSelectionTimeoutMS=30000"). The default value is 30 seconds. func (c ClientOptions) SetServerSelectionTimeout(d time.Duration) ClientOptions { c.ServerSelectionTimeout = &d return c } // SetSocketTimeout specifies how long the driver will wait for a socket read or write to return before returning a // network error. This can also be set through the "socketTimeoutMS" URI option (e.g. "socketTimeoutMS=1000"). The // default value is 0, meaning no timeout is used and socket operations can block indefinitely. // // NOTE(benjirewis): SocketTimeout will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. Setting // SocketTimeout and Timeout on a single client will result in undefined behavior. func (c ClientOptions) SetSocketTimeout(d time.Duration) ClientOptions { c.SocketTimeout = &d return c } // SetTimeout specifies the amount of time that a single operation run on this Client can execute before returning an error. // The deadline of any operation run through the Client will be honored above any Timeout set on the Client; Timeout will only // be honored if there is no deadline on the operation Context. Timeout can also be set through the "timeoutMS" URI option // (e.g. "timeoutMS=1000"). The default value is nil, meaning operations do not inherit a timeout from the Client. // // If any Timeout is set (even 0) on the Client, the values of MaxTime on operation options, TransactionOptions.MaxCommitTime and // SessionOptions.DefaultMaxCommitTime will be ignored. Setting Timeout and SocketTimeout or WriteConcern.wTimeout will result // in undefined behavior. // // NOTE(benjirewis): SetTimeout represents unstable, provisional API. The behavior of the driver when a Timeout is specified is // subject to change. func (c ClientOptions) SetTimeout(d time.Duration) ClientOptions { c.Timeout = &d return c } // SetTLSConfig specifies a tls.Config instance to use use to configure TLS on all connections created to the cluster. // This can also be set through the following URI options: // // 1. "tls" (or "ssl"): Specify if TLS should be used (e.g. "tls=true"). // // 2. Either "tlsCertificateKeyFile" (or "sslClientCertificateKeyFile") or a combination of "tlsCertificateFile" and // "tlsPrivateKeyFile". The "tlsCertificateKeyFile" option specifies a path to the client certificate and private key, // which must be concatenated into one file. The "tlsCertificateFile" and "tlsPrivateKey" combination specifies separate // paths to the client certificate and private key, respectively. Note that if "tlsCertificateKeyFile" is used, the // other two options must not be specified. Only the subject name of the first certificate is honored as the username // for X509 auth in a file with multiple certs. // // 3. "tlsCertificateKeyFilePassword" (or "sslClientCertificateKeyPassword"): Specify the password to decrypt the client // private key file (e.g. "tlsCertificateKeyFilePassword=password"). // // 4. "tlsCaFile" (or "sslCertificateAuthorityFile"): Specify the path to a single or bundle of certificate authorities // to be considered trusted when making a TLS connection (e.g. "tlsCaFile=/path/to/caFile"). // // 5. "tlsInsecure" (or "sslInsecure"): Specifies whether or not certificates and hostnames received from the server // should be validated. If true (e.g. "tlsInsecure=true"), the TLS library will accept any certificate presented by the // server and any host name in that certificate. Note that setting this to true makes TLS susceptible to // man-in-the-middle attacks and should only be done for testing. // // The default is nil, meaning no TLS will be enabled. func (c ClientOptions) SetTLSConfig(cfg tls.Config) ClientOptions { c.TLSConfig = cfg return c } // SetHTTPClient specifies the http.Client to be used for any HTTP requests. // // This should only be used to set custom HTTP client configurations. By default, the connection will use an httputil.DefaultHTTPClient. func (c ClientOptions) SetHTTPClient(client http.Client) ClientOptions { c.HTTPClient = client return c } // SetWriteConcern specifies the write concern to use to for write operations. This can also be set through the following // URI options: // // 1. "w": Specify the number of nodes in the cluster that must acknowledge write operations before the operation // returns or "majority" to specify that a majority of the nodes must acknowledge writes. This can either be an integer // (e.g. "w=10") or the string "majority" (e.g. "w=majority"). // // 2. "wTimeoutMS": Specify how long write operations should wait for the correct number of nodes to acknowledge the // operation (e.g. "wTimeoutMS=1000"). // // 3. "journal": Specifies whether or not write operations should be written to an on-disk journal on the server before // returning (e.g. "journal=true"). // // The default is nil, meaning the server will use its configured default. func (c ClientOptions) SetWriteConcern(wc writeconcern.WriteConcern) ClientOptions { c.WriteConcern = wc return c } // SetZlibLevel specifies the level for the zlib compressor. This option is ignored if zlib is not specified as a // compressor through ApplyURI or SetCompressors. Supported values are -1 through 9, inclusive. -1 tells the zlib // library to use its default, 0 means no compression, 1 means best speed, and 9 means best compression. // This can also be set through the "zlibCompressionLevel" URI option (e.g. "zlibCompressionLevel=-1"). Defaults to -1. func (c ClientOptions) SetZlibLevel(level int) ClientOptions { c.ZlibLevel = &level return c } // SetZstdLevel sets the level for the zstd compressor. This option is ignored if zstd is not specified as a compressor // through ApplyURI or SetCompressors. Supported values are 1 through 20, inclusive. 1 means best speed and 20 means // best compression. This can also be set through the "zstdCompressionLevel" URI option. Defaults to 6. func (c ClientOptions) SetZstdLevel(level int) ClientOptions { c.ZstdLevel = &level return c } // SetAutoEncryptionOptions specifies an AutoEncryptionOptions instance to automatically encrypt and decrypt commands // and their results. See the options.AutoEncryptionOptions documentation for more information about the supported // options. func (c ClientOptions) SetAutoEncryptionOptions(opts AutoEncryptionOptions) ClientOptions { c.AutoEncryptionOptions = opts return c } // SetDisableOCSPEndpointCheck specifies whether or not the driver should reach out to OCSP responders to verify the // certificate status for certificates presented by the server that contain a list of OCSP responders. // // If set to true, the driver will verify the status of the certificate using a response stapled by the server, if there // is one, but will not send an HTTP request to any responders if there is no staple. In this case, the driver will // continue the connection even though the certificate status is not known. // // This can also be set through the tlsDisableOCSPEndpointCheck URI option. Both this URI option and tlsInsecure must // not be set at the same time and will error if they are. The default value is false. func (c ClientOptions) SetDisableOCSPEndpointCheck(disableCheck bool) ClientOptions { c.DisableOCSPEndpointCheck = &disableCheck return c } // SetServerAPIOptions specifies a ServerAPIOptions instance used to configure the API version sent to the server // when running commands. See the options.ServerAPIOptions documentation for more information about the supported // options. func (c ClientOptions) SetServerAPIOptions(opts ServerAPIOptions) ClientOptions { c.ServerAPIOptions = opts return c } // SetServerMonitoringMode specifies the server monitoring protocol to use. See // the helper constants ServerMonitoringModeAuto, ServerMonitoringModePoll, and // ServerMonitoringModeStream for more information about valid server // monitoring modes. func (c ClientOptions) SetServerMonitoringMode(mode string) ClientOptions { c.ServerMonitoringMode = &mode return c } // SetSRVMaxHosts specifies the maximum number of SRV results to randomly select during polling. To limit the number // of hosts selected in SRV discovery, this function must be called before ApplyURI. This can also be set through // the "srvMaxHosts" URI option. func (c ClientOptions) SetSRVMaxHosts(srvMaxHosts int) ClientOptions { c.SRVMaxHosts = &srvMaxHosts return c } // SetSRVServiceName specifies a custom SRV service name to use in SRV polling. To use a custom SRV service name // in SRV discovery, this function must be called before ApplyURI. This can also be set through the "srvServiceName" // URI option. func (c ClientOptions) SetSRVServiceName(srvName string) ClientOptions { c.SRVServiceName = &srvName return c } // MergeClientOptions combines the given ClientOptions into a single ClientOptions in a last one wins fashion. // The specified options are merged with the existing options on the client, with the specified options taking // precedence. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeClientOptions(opts ...ClientOptions) ClientOptions { c := Client() for _, opt := range opts { if opt == nil { continue } if opt.Dialer != nil { c.Dialer = opt.Dialer } if opt.AppName != nil { c.AppName = opt.AppName } if opt.Auth != nil { c.Auth = opt.Auth } if opt.AuthenticateToAnything != nil { c.AuthenticateToAnything = opt.AuthenticateToAnything } if opt.Compressors != nil { c.Compressors = opt.Compressors } if opt.ConnectTimeout != nil { c.ConnectTimeout = opt.ConnectTimeout } if opt.Crypt != nil { c.Crypt = opt.Crypt } if opt.HeartbeatInterval != nil { c.HeartbeatInterval = opt.HeartbeatInterval } if len(opt.Hosts) > 0 { c.Hosts = opt.Hosts } if opt.HTTPClient != nil { c.HTTPClient = opt.HTTPClient } if opt.LoadBalanced != nil { c.LoadBalanced = opt.LoadBalanced } if opt.LocalThreshold != nil { c.LocalThreshold = opt.LocalThreshold } if opt.MaxConnIdleTime != nil { c.MaxConnIdleTime = opt.MaxConnIdleTime } if opt.MaxPoolSize != nil { c.MaxPoolSize = opt.MaxPoolSize } if opt.MinPoolSize != nil { c.MinPoolSize = opt.MinPoolSize } if opt.MaxConnecting != nil { c.MaxConnecting = opt.MaxConnecting } if opt.PoolMonitor != nil { c.PoolMonitor = opt.PoolMonitor } if opt.Monitor != nil { c.Monitor = opt.Monitor } if opt.ServerAPIOptions != nil { c.ServerAPIOptions = opt.ServerAPIOptions } if opt.ServerMonitor != nil { c.ServerMonitor = opt.ServerMonitor } if opt.ReadConcern != nil { c.ReadConcern = opt.ReadConcern } if opt.ReadPreference != nil { c.ReadPreference = opt.ReadPreference } if opt.BSONOptions != nil { c.BSONOptions = opt.BSONOptions } if opt.Registry != nil { c.Registry = opt.Registry } if opt.ReplicaSet != nil { c.ReplicaSet = opt.ReplicaSet } if opt.RetryWrites != nil { c.RetryWrites = opt.RetryWrites } if opt.RetryReads != nil { c.RetryReads = opt.RetryReads } if opt.ServerSelectionTimeout != nil { c.ServerSelectionTimeout = opt.ServerSelectionTimeout } if opt.Direct != nil { c.Direct = opt.Direct } if opt.SocketTimeout != nil { c.SocketTimeout = opt.SocketTimeout } if opt.SRVMaxHosts != nil { c.SRVMaxHosts = opt.SRVMaxHosts } if opt.SRVServiceName != nil { c.SRVServiceName = opt.SRVServiceName } if opt.Timeout != nil { c.Timeout = opt.Timeout } if opt.TLSConfig != nil { c.TLSConfig = opt.TLSConfig } if opt.WriteConcern != nil { c.WriteConcern = opt.WriteConcern } if opt.ZlibLevel != nil { c.ZlibLevel = opt.ZlibLevel } if opt.ZstdLevel != nil { c.ZstdLevel = opt.ZstdLevel } if opt.AutoEncryptionOptions != nil { c.AutoEncryptionOptions = opt.AutoEncryptionOptions } if opt.Deployment != nil { c.Deployment = opt.Deployment } if opt.DisableOCSPEndpointCheck != nil { c.DisableOCSPEndpointCheck = opt.DisableOCSPEndpointCheck } if opt.err != nil { c.err = opt.err } if opt.cs != nil { c.cs = opt.cs } if opt.LoggerOptions != nil { c.LoggerOptions = opt.LoggerOptions } if opt.ServerMonitoringMode != nil { c.ServerMonitoringMode = opt.ServerMonitoringMode } } return c } // addCACertFromFile adds a root CA certificate to the configuration given a path // to the containing file. func addCACertFromFile(cfg tls.Config, file string) error { data, err := ioutil.ReadFile(file) if err != nil { return err } if cfg.RootCAs == nil { cfg.RootCAs = x509.NewCertPool() } if !cfg.RootCAs.AppendCertsFromPEM(data) { return errors.New("the specified CA file does not contain any valid certificates") } return nil } func addClientCertFromSeparateFiles(cfg tls.Config, keyFile, certFile, keyPassword string) (string, error) { keyData, err := ioutil.ReadFile(keyFile) if err != nil { return "", err } certData, err := ioutil.ReadFile(certFile) if err != nil { return "", err } data := make([]byte, 0, len(keyData)+len(certData)+1) data = append(data, keyData...) data = append(data, '\n') data = append(data, certData...) return addClientCertFromBytes(cfg, data, keyPassword) } func addClientCertFromConcatenatedFile(cfg tls.Config, certKeyFile, keyPassword string) (string, error) { data, err := ioutil.ReadFile(certKeyFile) if err != nil { return "", err } return addClientCertFromBytes(cfg, data, keyPassword) } // addClientCertFromBytes adds client certificates to the configuration given a path to the // containing file and returns the subject name in the first certificate. func addClientCertFromBytes(cfg tls.Config, data []byte, keyPasswd string) (string, error) { var currentBlock pem.Block var certDecodedBlock []byte var certBlocks, keyBlocks [][]byte remaining := data start := 0 for { currentBlock, remaining = pem.Decode(remaining) if currentBlock == nil { break } if currentBlock.Type == "CERTIFICATE" { certBlock := data[start : len(data)-len(remaining)] certBlocks = append(certBlocks, certBlock) // Assign the certDecodedBlock when it is never set, // so only the first certificate is honored in a file with multiple certs. if certDecodedBlock == nil { certDecodedBlock = currentBlock.Bytes } start += len(certBlock) } else if strings.HasSuffix(currentBlock.Type, "PRIVATE KEY") { isEncrypted := x509.IsEncryptedPEMBlock(currentBlock) \|\| strings.Contains(currentBlock.Type, "ENCRYPTED PRIVATE KEY") if isEncrypted { if keyPasswd == "" { return "", fmt.Errorf("no password provided to decrypt private key") } var keyBytes []byte var err error // Process the X.509-encrypted or PKCS-encrypted PEM block. if x509.IsEncryptedPEMBlock(currentBlock) { // Only covers encrypted PEM data with a DEK-Info header. keyBytes, err = x509.DecryptPEMBlock(currentBlock, []byte(keyPasswd)) if err != nil { return "", err } } else if strings.Contains(currentBlock.Type, "ENCRYPTED") { // The pkcs8 package only handles the PKCS #5 v2.0 scheme. decrypted, err := pkcs8.ParsePKCS8PrivateKey(currentBlock.Bytes, []byte(keyPasswd)) if err != nil { return "", err } keyBytes, err = x509.MarshalPKCS8PrivateKey(decrypted) if err != nil { return "", err } } var encoded bytes.Buffer pem.Encode(&encoded, &pem.Block{Type: currentBlock.Type, Bytes: keyBytes}) keyBlock := encoded.Bytes() keyBlocks = append(keyBlocks, keyBlock) start = len(data) - len(remaining) } else { keyBlock := data[start : len(data)-len(remaining)] keyBlocks = append(keyBlocks, keyBlock) start += len(keyBlock) } } } if len(certBlocks) == 0 { return "", fmt.Errorf("failed to find CERTIFICATE") } if len(keyBlocks) == 0 { return "", fmt.Errorf("failed to find PRIVATE KEY") } cert, err := tls.X509KeyPair(bytes.Join(certBlocks, []byte("\n")), bytes.Join(keyBlocks, []byte("\n"))) if err != nil { return "", err } cfg.Certificates = append(cfg.Certificates, cert) // The documentation for the tls.X509KeyPair indicates that the Leaf certificate is not // retained. crt, err := x509.ParseCertificate(certDecodedBlock) if err != nil { return "", err } return crt.Subject.String(), nil } func stringSliceContains(source []string, target string) bool { for _, str := range source { if str == target { return true } } return false } // create a username for x509 authentication from an x509 certificate subject. func extractX509UsernameFromSubject(subject string) string { // the Go x509 package gives the subject with the pairs in the reverse order from what we want. pairs := strings.Split(subject, ",") for left, right := 0, len(pairs)-1; left < right; left, right = left+1, right-1 { pairs[left], pairs[right] = pairs[right], pairs[left] } return strings.Join(pairs, ",") }	48.56 KB	2025-05-25 12:27
📄 clientoptions_test.go // Copyright (C) MongoDB, Inc. 2022-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "bytes" "context" "crypto/tls" "crypto/x509" "encoding/pem" "errors" "fmt" "io/ioutil" "net" "net/http" "os" "reflect" "testing" "time" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/httputil" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" "go.mongodb.org/mongo-driver/x/mongo/driver/connstring" ) var tClientOptions = reflect.TypeOf(&ClientOptions{}) func TestClientOptions(t testing.T) { t.Run("ApplyURI/doesn't overwrite previous errors", func(t testing.T) { uri := "not-mongo-db-uri://" want := fmt.Errorf( "error parsing uri: %w", errors.New(`scheme must be "mongodb" or "mongodb+srv"`)) co := Client().ApplyURI(uri).ApplyURI("mongodb://localhost/") got := co.Validate() if !cmp.Equal(got, want, cmp.Comparer(compareErrors)) { t.Errorf("Did not received expected error. got %v; want %v", got, want) } }) t.Run("Validate/returns error", func(t testing.T) { want := errors.New("validate error") co := &ClientOptions{err: want} got := co.Validate() if !cmp.Equal(got, want, cmp.Comparer(compareErrors)) { t.Errorf("Did not receive expected error. got %v; want %v", got, want) } }) t.Run("Set", func(t testing.T) { testCases := []struct { name string fn interface{} // method to be run arg interface{} // argument for method field string // field to be set dereference bool // Should we compare a pointer or the field }{ {"AppName", (ClientOptions).SetAppName, "example-application", "AppName", true}, {"Auth", (ClientOptions).SetAuth, Credential{Username: "foo", Password: "bar"}, "Auth", true}, {"Compressors", (ClientOptions).SetCompressors, []string{"zstd", "snappy", "zlib"}, "Compressors", true}, {"ConnectTimeout", (ClientOptions).SetConnectTimeout, 5 * time.Second, "ConnectTimeout", true}, {"Dialer", (ClientOptions).SetDialer, testDialer{Num: 12345}, "Dialer", true}, {"HeartbeatInterval", (ClientOptions).SetHeartbeatInterval, 5 * time.Second, "HeartbeatInterval", true}, {"Hosts", (ClientOptions).SetHosts, []string{"localhost:27017", "localhost:27018", "localhost:27019"}, "Hosts", true}, {"LocalThreshold", (ClientOptions).SetLocalThreshold, 5 * time.Second, "LocalThreshold", true}, {"MaxConnIdleTime", (ClientOptions).SetMaxConnIdleTime, 5 time.Second, "MaxConnIdleTime", true}, {"MaxPoolSize", (ClientOptions).SetMaxPoolSize, uint64(250), "MaxPoolSize", true}, {"MinPoolSize", (ClientOptions).SetMinPoolSize, uint64(10), "MinPoolSize", true}, {"MaxConnecting", (ClientOptions).SetMaxConnecting, uint64(10), "MaxConnecting", true}, {"PoolMonitor", (ClientOptions).SetPoolMonitor, &event.PoolMonitor{}, "PoolMonitor", false}, {"Monitor", (ClientOptions).SetMonitor, &event.CommandMonitor{}, "Monitor", false}, {"ReadConcern", (ClientOptions).SetReadConcern, readconcern.Majority(), "ReadConcern", false}, {"ReadPreference", (ClientOptions).SetReadPreference, readpref.SecondaryPreferred(), "ReadPreference", false}, {"Registry", (ClientOptions).SetRegistry, bson.NewRegistryBuilder().Build(), "Registry", false}, {"ReplicaSet", (ClientOptions).SetReplicaSet, "example-replicaset", "ReplicaSet", true}, {"RetryWrites", (ClientOptions).SetRetryWrites, true, "RetryWrites", true}, {"ServerSelectionTimeout", (ClientOptions).SetServerSelectionTimeout, 5 time.Second, "ServerSelectionTimeout", true}, {"Direct", (ClientOptions).SetDirect, true, "Direct", true}, {"SocketTimeout", (ClientOptions).SetSocketTimeout, 5 * time.Second, "SocketTimeout", true}, {"TLSConfig", (ClientOptions).SetTLSConfig, &tls.Config{}, "TLSConfig", false}, {"WriteConcern", (ClientOptions).SetWriteConcern, writeconcern.New(writeconcern.WMajority()), "WriteConcern", false}, {"ZlibLevel", (ClientOptions).SetZlibLevel, 6, "ZlibLevel", true}, {"DisableOCSPEndpointCheck", (ClientOptions).SetDisableOCSPEndpointCheck, true, "DisableOCSPEndpointCheck", true}, {"LoadBalanced", (ClientOptions).SetLoadBalanced, true, "LoadBalanced", true}, } opt1, opt2, optResult := Client(), Client(), Client() for idx, tc := range testCases { t.Run(tc.name, func(t testing.T) { fn := reflect.ValueOf(tc.fn) if fn.Kind() != reflect.Func { t.Fatal("fn argument must be a function") } if fn.Type().NumIn() < 2 \|\| fn.Type().In(0) != tClientOptions { t.Fatal("fn argument must have a ClientOptions as the first argument and one other argument") } if _, exists := tClientOptions.Elem().FieldByName(tc.field); !exists { t.Fatalf("field (%s) does not exist in ClientOptions", tc.field) } args := make([]reflect.Value, 2) client := reflect.New(tClientOptions.Elem()) args[0] = client want := reflect.ValueOf(tc.arg) args[1] = want if !want.IsValid() \|\| !want.CanInterface() { t.Fatal("arg property of test case must be valid") } _ = fn.Call(args) // To avoid duplication we're piggybacking on the Set tests to make the // MergeClientOptions test simpler and more thorough. // To do this we set the odd numbered test cases to the first opt, the even and // divisible by three test cases to the second, and the result of merging the two to // the result option. This gives us coverage of options set by the first option, by // the second, and by both. if idx%2 != 0 { args[0] = reflect.ValueOf(opt1) _ = fn.Call(args) } if idx%2 == 0 \|\| idx%3 == 0 { args[0] = reflect.ValueOf(opt2) _ = fn.Call(args) } args[0] = reflect.ValueOf(optResult) _ = fn.Call(args) got := client.Elem().FieldByName(tc.field) if !got.IsValid() \|\| !got.CanInterface() { t.Fatal("cannot create concrete instance from retrieved field") } if got.Kind() == reflect.Ptr && tc.dereference { got = got.Elem() } if !cmp.Equal( got.Interface(), want.Interface(), cmp.AllowUnexported(readconcern.ReadConcern{}, writeconcern.WriteConcern{}, readpref.ReadPref{}), cmp.Comparer(func(r1, r2 bsoncodec.Registry) bool { return r1 == r2 }), cmp.Comparer(func(cfg1, cfg2 tls.Config) bool { return cfg1 == cfg2 }), cmp.Comparer(func(fp1, fp2 event.PoolMonitor) bool { return fp1 == fp2 }), ) { t.Errorf("Field not set properly. got %v; want %v", got.Interface(), want.Interface()) } }) } t.Run("MergeClientOptions/all set", func(t testing.T) { want := optResult got := MergeClientOptions(nil, opt1, opt2) if diff := cmp.Diff( got, want, cmp.AllowUnexported(readconcern.ReadConcern{}, writeconcern.WriteConcern{}, readpref.ReadPref{}), cmp.Comparer(func(r1, r2 bsoncodec.Registry) bool { return r1 == r2 }), cmp.Comparer(func(cfg1, cfg2 tls.Config) bool { return cfg1 == cfg2 }), cmp.Comparer(func(fp1, fp2 event.PoolMonitor) bool { return fp1 == fp2 }), cmp.AllowUnexported(ClientOptions{}), cmpopts.IgnoreFields(http.Client{}, "Transport"), ); diff != "" { t.Errorf("diff:\n%s", diff) t.Errorf("Merged client options do not match. got %v; want %v", got, want) } }) // go-cmp dont support error comparisons (https://github.com/google/go-cmp/issues/24) // Use specifique test for this t.Run("MergeClientOptions/err", func(t testing.T) { opt1, opt2 := Client(), Client() opt1.err = errors.New("Test error") got := MergeClientOptions(nil, opt1, opt2) if got.err.Error() != "Test error" { t.Errorf("Merged client options do not match. got %v; want %v", got.err.Error(), opt1.err.Error()) } }) }) t.Run("ApplyURI", func(t testing.T) { baseClient := func() ClientOptions { return Client().SetHosts([]string{"localhost"}) } testCases := []struct { name string uri string result ClientOptions }{ { "ParseError", "not-mongo-db-uri://", &ClientOptions{ err: fmt.Errorf( "error parsing uri: %w", errors.New(`scheme must be "mongodb" or "mongodb+srv"`)), HTTPClient: httputil.DefaultHTTPClient, }, }, { "ReadPreference Invalid Mode", "mongodb://localhost/?maxStaleness=200", &ClientOptions{ err: fmt.Errorf("unknown read preference %v", ""), Hosts: []string{"localhost"}, HTTPClient: httputil.DefaultHTTPClient, }, }, { "ReadPreference Primary With Options", "mongodb://localhost/?readPreference=Primary&maxStaleness=200", &ClientOptions{ err: errors.New("can not specify tags, max staleness, or hedge with mode primary"), Hosts: []string{"localhost"}, HTTPClient: httputil.DefaultHTTPClient, }, }, { "TLS addCertFromFile error", "mongodb://localhost/?ssl=true&sslCertificateAuthorityFile=testdata/doesntexist", &ClientOptions{ err: &os.PathError{Op: "open", Path: "testdata/doesntexist"}, Hosts: []string{"localhost"}, HTTPClient: httputil.DefaultHTTPClient, }, }, { "TLS ClientCertificateKey", "mongodb://localhost/?ssl=true&sslClientCertificateKeyFile=testdata/doesntexist", &ClientOptions{ err: &os.PathError{Op: "open", Path: "testdata/doesntexist"}, Hosts: []string{"localhost"}, HTTPClient: httputil.DefaultHTTPClient, }, }, { "AppName", "mongodb://localhost/?appName=awesome-example-application", baseClient().SetAppName("awesome-example-application"), }, { "AuthMechanism", "mongodb://localhost/?authMechanism=mongodb-x509", baseClient().SetAuth(Credential{AuthSource: "$external", AuthMechanism: "mongodb-x509"}), }, { "AuthMechanismProperties", "mongodb://foo@localhost/?authMechanism=gssapi&authMechanismProperties=SERVICE_NAME:mongodb-fake", baseClient().SetAuth(Credential{ AuthSource: "$external", AuthMechanism: "gssapi", AuthMechanismProperties: map[string]string{"SERVICE_NAME": "mongodb-fake"}, Username: "foo", }), }, { "AuthSource", "mongodb://foo@localhost/?authSource=random-database-example", baseClient().SetAuth(Credential{AuthSource: "random-database-example", Username: "foo"}), }, { "Username", "mongodb://foo@localhost/", baseClient().SetAuth(Credential{AuthSource: "admin", Username: "foo"}), }, { "Unescaped slash in username", "mongodb:///:pwd@localhost", &ClientOptions{ err: fmt.Errorf( "error parsing uri: %w", errors.New("unescaped slash in username")), HTTPClient: httputil.DefaultHTTPClient, }, }, { "Password", "mongodb://foo:bar@localhost/", baseClient().SetAuth(Credential{ AuthSource: "admin", Username: "foo", Password: "bar", PasswordSet: true, }), }, { "Single character username and password", "mongodb://f:b@localhost/", baseClient().SetAuth(Credential{ AuthSource: "admin", Username: "f", Password: "b", PasswordSet: true, }), }, { "Connect", "mongodb://localhost/?connect=direct", baseClient().SetDirect(true), }, { "ConnectTimeout", "mongodb://localhost/?connectTimeoutms=5000", baseClient().SetConnectTimeout(5 time.Second), }, { "Compressors", "mongodb://localhost/?compressors=zlib,snappy", baseClient().SetCompressors([]string{"zlib", "snappy"}).SetZlibLevel(6), }, { "DatabaseNoAuth", "mongodb://localhost/example-database", baseClient(), }, { "DatabaseAsDefault", "mongodb://foo@localhost/example-database", baseClient().SetAuth(Credential{AuthSource: "example-database", Username: "foo"}), }, { "HeartbeatInterval", "mongodb://localhost/?heartbeatIntervalms=12000", baseClient().SetHeartbeatInterval(12 * time.Second), }, { "Hosts", "mongodb://localhost:27017,localhost:27018,localhost:27019/", baseClient().SetHosts([]string{"localhost:27017", "localhost:27018", "localhost:27019"}), }, { "LocalThreshold", "mongodb://localhost/?localThresholdMS=200", baseClient().SetLocalThreshold(200 * time.Millisecond), }, { "MaxConnIdleTime", "mongodb://localhost/?maxIdleTimeMS=300000", baseClient().SetMaxConnIdleTime(5 * time.Minute), }, { "MaxPoolSize", "mongodb://localhost/?maxPoolSize=256", baseClient().SetMaxPoolSize(256), }, { "MinPoolSize", "mongodb://localhost/?minPoolSize=256", baseClient().SetMinPoolSize(256), }, { "MaxConnecting", "mongodb://localhost/?maxConnecting=10", baseClient().SetMaxConnecting(10), }, { "ReadConcern", "mongodb://localhost/?readConcernLevel=linearizable", baseClient().SetReadConcern(readconcern.Linearizable()), }, { "ReadPreference", "mongodb://localhost/?readPreference=secondaryPreferred", baseClient().SetReadPreference(readpref.SecondaryPreferred()), }, { "ReadPreferenceTagSets", "mongodb://localhost/?readPreference=secondaryPreferred&readPreferenceTags=foo:bar", baseClient().SetReadPreference(readpref.SecondaryPreferred(readpref.WithTags("foo", "bar"))), }, { "MaxStaleness", "mongodb://localhost/?readPreference=secondaryPreferred&maxStaleness=250", baseClient().SetReadPreference(readpref.SecondaryPreferred(readpref.WithMaxStaleness(250 * time.Second))), }, { "RetryWrites", "mongodb://localhost/?retryWrites=true", baseClient().SetRetryWrites(true), }, { "ReplicaSet", "mongodb://localhost/?replicaSet=rs01", baseClient().SetReplicaSet("rs01"), }, { "ServerSelectionTimeout", "mongodb://localhost/?serverSelectionTimeoutMS=45000", baseClient().SetServerSelectionTimeout(45 * time.Second), }, { "SocketTimeout", "mongodb://localhost/?socketTimeoutMS=15000", baseClient().SetSocketTimeout(15 * time.Second), }, { "TLS CACertificate", "mongodb://localhost/?ssl=true&sslCertificateAuthorityFile=testdata/ca.pem", baseClient().SetTLSConfig(&tls.Config{ RootCAs: createCertPool(t, "testdata/ca.pem"), }), }, { "TLS Insecure", "mongodb://localhost/?ssl=true&sslInsecure=true", baseClient().SetTLSConfig(&tls.Config{InsecureSkipVerify: true}), }, { "TLS ClientCertificateKey", "mongodb://localhost/?ssl=true&sslClientCertificateKeyFile=testdata/nopass/certificate.pem", baseClient().SetTLSConfig(&tls.Config{Certificates: make([]tls.Certificate, 1)}), }, { "TLS ClientCertificateKey with password", "mongodb://localhost/?ssl=true&sslClientCertificateKeyFile=testdata/certificate.pem&sslClientCertificateKeyPassword=passphrase", baseClient().SetTLSConfig(&tls.Config{Certificates: make([]tls.Certificate, 1)}), }, { "TLS Username", "mongodb://localhost/?ssl=true&authMechanism=mongodb-x509&sslClientCertificateKeyFile=testdata/nopass/certificate.pem", baseClient().SetAuth(Credential{ AuthMechanism: "mongodb-x509", AuthSource: "$external", Username: `C=US,ST=New York,L=New York City, Inc,O=MongoDB\,OU=WWW`, }), }, { "WriteConcern J", "mongodb://localhost/?journal=true", baseClient().SetWriteConcern(writeconcern.New(writeconcern.J(true))), }, { "WriteConcern WString", "mongodb://localhost/?w=majority", baseClient().SetWriteConcern(writeconcern.New(writeconcern.WMajority())), }, { "WriteConcern W", "mongodb://localhost/?w=3", baseClient().SetWriteConcern(writeconcern.New(writeconcern.W(3))), }, { "WriteConcern WTimeout", "mongodb://localhost/?wTimeoutMS=45000", baseClient().SetWriteConcern(writeconcern.New(writeconcern.WTimeout(45 * time.Second))), }, { "ZLibLevel", "mongodb://localhost/?zlibCompressionLevel=4", baseClient().SetZlibLevel(4), }, { "TLS tlsCertificateFile and tlsPrivateKeyFile", "mongodb://localhost/?tlsCertificateFile=testdata/nopass/cert.pem&tlsPrivateKeyFile=testdata/nopass/key.pem", baseClient().SetTLSConfig(&tls.Config{Certificates: make([]tls.Certificate, 1)}), }, { "TLS only tlsCertificateFile", "mongodb://localhost/?tlsCertificateFile=testdata/nopass/cert.pem", &ClientOptions{ err: fmt.Errorf( "error validating uri: %w", errors.New("the tlsPrivateKeyFile URI option must be provided if the tlsCertificateFile option is specified")), HTTPClient: httputil.DefaultHTTPClient, }, }, { "TLS only tlsPrivateKeyFile", "mongodb://localhost/?tlsPrivateKeyFile=testdata/nopass/key.pem", &ClientOptions{ err: fmt.Errorf( "error validating uri: %w", errors.New("the tlsCertificateFile URI option must be provided if the tlsPrivateKeyFile option is specified")), HTTPClient: httputil.DefaultHTTPClient, }, }, { "TLS tlsCertificateFile and tlsPrivateKeyFile and tlsCertificateKeyFile", "mongodb://localhost/?tlsCertificateFile=testdata/nopass/cert.pem&tlsPrivateKeyFile=testdata/nopass/key.pem&tlsCertificateKeyFile=testdata/nopass/certificate.pem", &ClientOptions{ err: fmt.Errorf( "error validating uri: %w", errors.New("the sslClientCertificateKeyFile/tlsCertificateKeyFile URI option cannot be provided "+ "along with tlsCertificateFile or tlsPrivateKeyFile")), HTTPClient: httputil.DefaultHTTPClient, }, }, { "disable OCSP endpoint check", "mongodb://localhost/?tlsDisableOCSPEndpointCheck=true", baseClient().SetDisableOCSPEndpointCheck(true), }, { "directConnection", "mongodb://localhost/?directConnection=true", baseClient().SetDirect(true), }, { "TLS CA file with multiple certificiates", "mongodb://localhost/?tlsCAFile=testdata/ca-with-intermediates.pem", baseClient().SetTLSConfig(&tls.Config{ RootCAs: createCertPool(t, "testdata/ca-with-intermediates-first.pem", "testdata/ca-with-intermediates-second.pem", "testdata/ca-with-intermediates-third.pem"), }), }, { "TLS empty CA file", "mongodb://localhost/?tlsCAFile=testdata/empty-ca.pem", &ClientOptions{ Hosts: []string{"localhost"}, HTTPClient: httputil.DefaultHTTPClient, err: errors.New("the specified CA file does not contain any valid certificates"), }, }, { "TLS CA file with no certificates", "mongodb://localhost/?tlsCAFile=testdata/ca-key.pem", &ClientOptions{ Hosts: []string{"localhost"}, HTTPClient: httputil.DefaultHTTPClient, err: errors.New("the specified CA file does not contain any valid certificates"), }, }, { "TLS malformed CA file", "mongodb://localhost/?tlsCAFile=testdata/malformed-ca.pem", &ClientOptions{ Hosts: []string{"localhost"}, HTTPClient: httputil.DefaultHTTPClient, err: errors.New("the specified CA file does not contain any valid certificates"), }, }, { "loadBalanced=true", "mongodb://localhost/?loadBalanced=true", baseClient().SetLoadBalanced(true), }, { "loadBalanced=false", "mongodb://localhost/?loadBalanced=false", baseClient().SetLoadBalanced(false), }, { "srvServiceName", "mongodb+srv://test22.test.build.10gen.cc/?srvServiceName=customname", baseClient().SetSRVServiceName("customname"). SetHosts([]string{"localhost.test.build.10gen.cc:27017", "localhost.test.build.10gen.cc:27018"}), }, { "srvMaxHosts", "mongodb+srv://test1.test.build.10gen.cc/?srvMaxHosts=2", baseClient().SetSRVMaxHosts(2). SetHosts([]string{"localhost.test.build.10gen.cc:27017", "localhost.test.build.10gen.cc:27018"}), }, { "GODRIVER-2263 regression test", "mongodb://localhost/?tlsCertificateKeyFile=testdata/one-pk-multiple-certs.pem", baseClient().SetTLSConfig(&tls.Config{Certificates: make([]tls.Certificate, 1)}), }, { "GODRIVER-2650 X509 certificate", "mongodb://localhost/?ssl=true&authMechanism=mongodb-x509&sslClientCertificateKeyFile=testdata/one-pk-multiple-certs.pem", baseClient().SetAuth(Credential{ AuthMechanism: "mongodb-x509", AuthSource: "$external", // Subject name in the first certificate is used as the username for X509 auth. Username: `C=US,ST=New York,L=New York City,O=MongoDB,OU=Drivers,CN=localhost`, }).SetTLSConfig(&tls.Config{Certificates: make([]tls.Certificate, 1)}), }, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { result := Client().ApplyURI(tc.uri) // Manually add the URI and ConnString to the test expectations to avoid adding them in each test // definition. The ConnString should only be recorded if there was no error while parsing. cs, err := connstring.ParseAndValidate(tc.uri) if err == nil { tc.result.cs = cs } // We have to sort string slices in comparison, as Hosts resolved from SRV URIs do not have a set order. stringLess := func(a, b string) bool { return a < b } if diff := cmp.Diff( tc.result, result, cmp.AllowUnexported(ClientOptions{}, readconcern.ReadConcern{}, writeconcern.WriteConcern{}, readpref.ReadPref{}), cmp.Comparer(func(r1, r2 bsoncodec.Registry) bool { return r1 == r2 }), cmp.Comparer(compareTLSConfig), cmp.Comparer(compareErrors), cmpopts.SortSlices(stringLess), cmpopts.IgnoreFields(connstring.ConnString{}, "SSLClientCertificateKeyPassword"), cmpopts.IgnoreFields(http.Client{}, "Transport"), ); diff != "" { t.Errorf("URI did not apply correctly: (-want +got)\n%s", diff) } }) } }) t.Run("direct connection validation", func(t testing.T) { t.Run("multiple hosts", func(t testing.T) { expectedErr := errors.New("a direct connection cannot be made if multiple hosts are specified") testCases := []struct { name string opts ClientOptions }{ {"hosts in URI", Client().ApplyURI("mongodb://localhost,localhost2")}, {"hosts in options", Client().SetHosts([]string{"localhost", "localhost2"})}, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { err := tc.opts.SetDirect(true).Validate() assert.NotNil(t, err, "expected error, got nil") assert.Equal(t, expectedErr.Error(), err.Error(), "expected error %v, got %v", expectedErr, err) }) } }) t.Run("srv", func(t testing.T) { expectedErr := errors.New("a direct connection cannot be made if an SRV URI is used") // Use a non-SRV URI and manually set the scheme because using an SRV URI would force an SRV lookup. opts := Client().ApplyURI("mongodb://localhost:27017") opts.cs.Scheme = connstring.SchemeMongoDBSRV err := opts.SetDirect(true).Validate() assert.NotNil(t, err, "expected error, got nil") assert.Equal(t, expectedErr.Error(), err.Error(), "expected error %v, got %v", expectedErr, err) }) }) t.Run("loadBalanced validation", func(t testing.T) { testCases := []struct { name string opts ClientOptions err error }{ {"multiple hosts in URI", Client().ApplyURI("mongodb://foo,bar"), connstring.ErrLoadBalancedWithMultipleHosts}, {"multiple hosts in options", Client().SetHosts([]string{"foo", "bar"}), connstring.ErrLoadBalancedWithMultipleHosts}, {"replica set name", Client().SetReplicaSet("foo"), connstring.ErrLoadBalancedWithReplicaSet}, {"directConnection=true", Client().SetDirect(true), connstring.ErrLoadBalancedWithDirectConnection}, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { // The loadBalanced option should not be validated if it is unset or false. err := tc.opts.Validate() assert.Nil(t, err, "Validate error when loadBalanced is unset: %v", err) tc.opts.SetLoadBalanced(false) err = tc.opts.Validate() assert.Nil(t, err, "Validate error when loadBalanced=false: %v", err) tc.opts.SetLoadBalanced(true) err = tc.opts.Validate() assert.Equal(t, tc.err, err, "expected error %v when loadBalanced=true, got %v", tc.err, err) }) } }) t.Run("minPoolSize validation", func(t testing.T) { testCases := []struct { name string opts ClientOptions err error }{ { "minPoolSize < maxPoolSize", Client().SetMinPoolSize(128).SetMaxPoolSize(256), nil, }, { "minPoolSize == maxPoolSize", Client().SetMinPoolSize(128).SetMaxPoolSize(128), nil, }, { "minPoolSize > maxPoolSize", Client().SetMinPoolSize(64).SetMaxPoolSize(32), errors.New("minPoolSize must be less than or equal to maxPoolSize, got minPoolSize=64 maxPoolSize=32"), }, { "maxPoolSize == 0", Client().SetMinPoolSize(128).SetMaxPoolSize(0), nil, }, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { err := tc.opts.Validate() assert.Equal(t, tc.err, err, "expected error %v, got %v", tc.err, err) }) } }) t.Run("srvMaxHosts validation", func(t testing.T) { testCases := []struct { name string opts ClientOptions err error }{ {"replica set name", Client().SetReplicaSet("foo"), connstring.ErrSRVMaxHostsWithReplicaSet}, {"loadBalanced=true", Client().SetLoadBalanced(true), connstring.ErrSRVMaxHostsWithLoadBalanced}, {"loadBalanced=false", Client().SetLoadBalanced(false), nil}, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { err := tc.opts.Validate() assert.Nil(t, err, "Validate error when srvMxaHosts is unset: %v", err) tc.opts.SetSRVMaxHosts(0) err = tc.opts.Validate() assert.Nil(t, err, "Validate error when srvMaxHosts is 0: %v", err) tc.opts.SetSRVMaxHosts(2) err = tc.opts.Validate() assert.Equal(t, tc.err, err, "expected error %v when srvMaxHosts > 0, got %v", tc.err, err) }) } }) t.Run("srvMaxHosts validation", func(t testing.T) { t.Parallel() testCases := []struct { name string opts ClientOptions err error }{ { name: "valid ServerAPI", opts: Client().SetServerAPIOptions(ServerAPI(ServerAPIVersion1)), err: nil, }, { name: "invalid ServerAPI", opts: Client().SetServerAPIOptions(ServerAPI("nope")), err: errors.New(`api version "nope" not supported; this driver version only supports API version "1"`), }, { name: "invalid ServerAPI with other invalid options", opts: Client().SetServerAPIOptions(ServerAPI("nope")).SetSRVMaxHosts(1).SetReplicaSet("foo"), err: errors.New(`api version "nope" not supported; this driver version only supports API version "1"`), }, } for _, tc := range testCases { tc := tc // Capture range variable. t.Run(tc.name, func(t testing.T) { t.Parallel() err := tc.opts.Validate() assert.Equal(t, tc.err, err, "want error %v, got error %v", tc.err, err) }) } }) t.Run("server monitoring mode validation", func(t testing.T) { t.Parallel() testCases := []struct { name string opts ClientOptions err error }{ { name: "undefined", opts: Client(), err: nil, }, { name: "auto", opts: Client().SetServerMonitoringMode(ServerMonitoringModeAuto), err: nil, }, { name: "poll", opts: Client().SetServerMonitoringMode(ServerMonitoringModePoll), err: nil, }, { name: "stream", opts: Client().SetServerMonitoringMode(ServerMonitoringModeStream), err: nil, }, { name: "invalid", opts: Client().SetServerMonitoringMode("invalid"), err: errors.New("invalid server monitoring mode: \"invalid\""), }, } for _, tc := range testCases { tc := tc // Capture the range variable t.Run(tc.name, func(t testing.T) { t.Parallel() err := tc.opts.Validate() assert.Equal(t, tc.err, err, "expected error %v, got %v", tc.err, err) }) } }) } func createCertPool(t testing.T, paths ...string) x509.CertPool { t.Helper() pool := x509.NewCertPool() for _, path := range paths { pool.AddCert(loadCert(t, path)) } return pool } func loadCert(t testing.T, file string) x509.Certificate { t.Helper() data := readFile(t, file) block, _ := pem.Decode(data) cert, err := x509.ParseCertificate(block.Bytes) assert.Nil(t, err, "ParseCertificate error for %s: %v", file, err) return cert } func readFile(t testing.T, path string) []byte { data, err := ioutil.ReadFile(path) assert.Nil(t, err, "ReadFile error for %s: %v", path, err) return data } type testDialer struct { Num int } func (testDialer) DialContext(context.Context, string, string) (net.Conn, error) { return nil, nil } func compareTLSConfig(cfg1, cfg2 tls.Config) bool { if cfg1 == nil && cfg2 == nil { return true } if cfg1 == nil \|\| cfg2 == nil { return true } if (cfg1.RootCAs == nil && cfg1.RootCAs != nil) \|\| (cfg1.RootCAs != nil && cfg1.RootCAs == nil) { return false } if cfg1.RootCAs != nil { cfg1Subjects := cfg1.RootCAs.Subjects() cfg2Subjects := cfg2.RootCAs.Subjects() if len(cfg1Subjects) != len(cfg2Subjects) { return false } for idx, firstSubject := range cfg1Subjects { if !bytes.Equal(firstSubject, cfg2Subjects[idx]) { return false } } } if len(cfg1.Certificates) != len(cfg2.Certificates) { return false } if cfg1.InsecureSkipVerify != cfg2.InsecureSkipVerify { return false } return true } func compareErrors(err1, err2 error) bool { if err1 == nil && err2 == nil { return true } if err1 == nil \|\| err2 == nil { return false } var ospe1, ospe2 *os.PathError if errors.As(err1, &ospe1) && errors.As(err2, &ospe2) { return ospe1.Op == ospe2.Op && ospe1.Path == ospe2.Path } if err1.Error() != err2.Error() { return false } return true }	29.55 KB	2025-05-25 12:27
📄 collation_test.go // Copyright (C) MongoDB, Inc. 2022-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "bytes" "testing" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func TestCollation(t testing.T) { t.Run("TestCollationToDocument", func(t testing.T) { c := &Collation{ Locale: "locale", CaseLevel: true, CaseFirst: "first", Strength: 1, NumericOrdering: true, Alternate: "alternate", MaxVariable: "maxVariable", Normalization: true, Backwards: true, } doc := c.ToDocument() expected := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendStringElement(nil, "locale", "locale"), bsoncore.AppendBooleanElement(nil, "caseLevel", (true)), bsoncore.AppendStringElement(nil, "caseFirst", ("first")), bsoncore.AppendInt32Element(nil, "strength", (1)), bsoncore.AppendBooleanElement(nil, "numericOrdering", (true)), bsoncore.AppendStringElement(nil, "alternate", ("alternate")), bsoncore.AppendStringElement(nil, "maxVariable", ("maxVariable")), bsoncore.AppendBooleanElement(nil, "normalization", (true)), bsoncore.AppendBooleanElement(nil, "backwards", (true)), ) if !bytes.Equal(doc, expected) { t.Fatalf("collation did not match expected. got %v; wanted %v", doc, expected) } }) }	1.47 KB	2025-05-25 12:27
📄 collectionoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" ) // CollectionOptions represents options that can be used to configure a Collection. type CollectionOptions struct { // ReadConcern is the read concern to use for operations executed on the Collection. The default value is nil, which means that // the read concern of the Database used to configure the Collection will be used. ReadConcern readconcern.ReadConcern // WriteConcern is the write concern to use for operations executed on the Collection. The default value is nil, which means that // the write concern of the Database used to configure the Collection will be used. WriteConcern writeconcern.WriteConcern // ReadPreference is the read preference to use for operations executed on the Collection. The default value is nil, which means that // the read preference of the Database used to configure the Collection will be used. ReadPreference readpref.ReadPref // BSONOptions configures optional BSON marshaling and unmarshaling // behavior. BSONOptions BSONOptions // Registry is the BSON registry to marshal and unmarshal documents for operations executed on the Collection. The default value // is nil, which means that the registry of the Database used to configure the Collection will be used. Registry bsoncodec.Registry } // Collection creates a new CollectionOptions instance. func Collection() CollectionOptions { return &CollectionOptions{} } // SetReadConcern sets the value for the ReadConcern field. func (c CollectionOptions) SetReadConcern(rc readconcern.ReadConcern) CollectionOptions { c.ReadConcern = rc return c } // SetWriteConcern sets the value for the WriteConcern field. func (c CollectionOptions) SetWriteConcern(wc writeconcern.WriteConcern) CollectionOptions { c.WriteConcern = wc return c } // SetReadPreference sets the value for the ReadPreference field. func (c CollectionOptions) SetReadPreference(rp readpref.ReadPref) CollectionOptions { c.ReadPreference = rp return c } // SetBSONOptions configures optional BSON marshaling and unmarshaling behavior. func (c CollectionOptions) SetBSONOptions(opts BSONOptions) CollectionOptions { c.BSONOptions = opts return c } // SetRegistry sets the value for the Registry field. func (c CollectionOptions) SetRegistry(r bsoncodec.Registry) CollectionOptions { c.Registry = r return c } // MergeCollectionOptions combines the given CollectionOptions instances into a single CollectionOptions in a // last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeCollectionOptions(opts ...CollectionOptions) CollectionOptions { c := Collection() for _, opt := range opts { if opt == nil { continue } if opt.ReadConcern != nil { c.ReadConcern = opt.ReadConcern } if opt.WriteConcern != nil { c.WriteConcern = opt.WriteConcern } if opt.ReadPreference != nil { c.ReadPreference = opt.ReadPreference } if opt.Registry != nil { c.Registry = opt.Registry } if opt.BSONOptions != nil { c.BSONOptions = opt.BSONOptions } } return c }	3.53 KB	2025-05-25 12:27
📄 countoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import "time" // CountOptions represents options that can be used to configure a CountDocuments operation. type CountOptions struct { // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // TODO(GODRIVER-2386): CountOptions executor uses aggregation under the hood, which means this type has to be // TODO a string for now. This can be replaced with `Comment interface{}` once 2386 is implemented. // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default is nil, which means that no comment will be included in the logs. Comment string // The index to use for the aggregation. This should either be the index name as a string or the index specification // as a document. The driver will return an error if the hint parameter is a multi-key map. The default value is nil, // which means that no hint will be sent. Hint interface{} // The maximum number of documents to count. The default value is 0, which means that there is no limit and all // documents matching the filter will be counted. Limit int64 // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there is // no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used in // its place to control the amount of time that a single operation can run before returning an error. MaxTime is // ignored if Timeout is set on the client. MaxTime time.Duration // The number of documents to skip before counting. The default value is 0. Skip int64 } // Count creates a new CountOptions instance. func Count() CountOptions { return &CountOptions{} } // SetCollation sets the value for the Collation field. func (co CountOptions) SetCollation(c Collation) CountOptions { co.Collation = c return co } // SetComment sets the value for the Comment field. func (co CountOptions) SetComment(c string) CountOptions { co.Comment = &c return co } // SetHint sets the value for the Hint field. func (co CountOptions) SetHint(h interface{}) CountOptions { co.Hint = h return co } // SetLimit sets the value for the Limit field. func (co CountOptions) SetLimit(i int64) CountOptions { co.Limit = &i return co } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (co CountOptions) SetMaxTime(d time.Duration) CountOptions { co.MaxTime = &d return co } // SetSkip sets the value for the Skip field. func (co CountOptions) SetSkip(i int64) CountOptions { co.Skip = &i return co } // MergeCountOptions combines the given CountOptions instances into a single CountOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeCountOptions(opts ...CountOptions) *CountOptions { countOpts := Count() for _, co := range opts { if co == nil { continue } if co.Collation != nil { countOpts.Collation = co.Collation } if co.Comment != nil { countOpts.Comment = co.Comment } if co.Hint != nil { countOpts.Hint = co.Hint } if co.Limit != nil { countOpts.Limit = co.Limit } if co.MaxTime != nil { countOpts.MaxTime = co.MaxTime } if co.Skip != nil { countOpts.Skip = co.Skip } } return countOpts }	4.16 KB	2025-05-25 12:27
📄 createcollectionoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import "time" // DefaultIndexOptions represents the default options for a collection to apply on new indexes. This type can be used // when creating a new collection through the CreateCollectionOptions.SetDefaultIndexOptions method. type DefaultIndexOptions struct { // Specifies the storage engine to use for the index. The value must be a document in the form // {<storage engine name>: <options>}. The default value is nil, which means that the default storage engine // will be used. StorageEngine interface{} } // DefaultIndex creates a new DefaultIndexOptions instance. func DefaultIndex() DefaultIndexOptions { return &DefaultIndexOptions{} } // SetStorageEngine sets the value for the StorageEngine field. func (d DefaultIndexOptions) SetStorageEngine(storageEngine interface{}) DefaultIndexOptions { d.StorageEngine = storageEngine return d } // TimeSeriesOptions specifies options on a time-series collection. type TimeSeriesOptions struct { // TimeField is the top-level field to be used for time. Inserted documents must have this field, // and the field must be of the BSON UTC datetime type (0x9). TimeField string // MetaField is the name of the top-level field describing the series. This field is used to group // related data and may be of any BSON type, except for array. This name may not be the same // as the TimeField or _id. This field is optional. MetaField string // Granularity is the granularity of time-series data. Allowed granularity options are // "seconds", "minutes" and "hours". This field is optional. Granularity string // BucketMaxSpan is the maximum range of time values for a bucket. The // time.Duration is rounded down to the nearest second and applied as // the command option: "bucketRoundingSeconds". This field is optional. BucketMaxSpan time.Duration // BucketRounding is used to determine the minimum time boundary when // opening a new bucket by rounding the first timestamp down to the next // multiple of this value. The time.Duration is rounded down to the // nearest second and applied as the command option: // "bucketRoundingSeconds". This field is optional. BucketRounding time.Duration } // TimeSeries creates a new TimeSeriesOptions instance. func TimeSeries() TimeSeriesOptions { return &TimeSeriesOptions{} } // SetTimeField sets the value for the TimeField. func (tso TimeSeriesOptions) SetTimeField(timeField string) TimeSeriesOptions { tso.TimeField = timeField return tso } // SetMetaField sets the value for the MetaField. func (tso TimeSeriesOptions) SetMetaField(metaField string) TimeSeriesOptions { tso.MetaField = &metaField return tso } // SetGranularity sets the value for Granularity. func (tso TimeSeriesOptions) SetGranularity(granularity string) TimeSeriesOptions { tso.Granularity = &granularity return tso } // SetBucketMaxSpan sets the value for BucketMaxSpan. func (tso TimeSeriesOptions) SetBucketMaxSpan(dur time.Duration) TimeSeriesOptions { tso.BucketMaxSpan = &dur return tso } // SetBucketRounding sets the value for BucketRounding. func (tso TimeSeriesOptions) SetBucketRounding(dur time.Duration) TimeSeriesOptions { tso.BucketRounding = &dur return tso } // CreateCollectionOptions represents options that can be used to configure a CreateCollection operation. type CreateCollectionOptions struct { // Specifies if the collection is capped (see https://www.mongodb.com/docs/manual/core/capped-collections/). If true, // the SizeInBytes option must also be specified. The default value is false. Capped bool // Specifies the default collation for the new collection. This option is only valid for MongoDB versions >= 3.4. // For previous server versions, the driver will return an error if this option is used. The default value is nil. Collation Collation // Specifies how change streams opened against the collection can return pre- and post-images of updated // documents. The value must be a document in the form {<option name>: <options>}. This option is only valid for // MongoDB versions >= 6.0. The default value is nil, which means that change streams opened against the collection // will not return pre- and post-images of updated documents in any way. ChangeStreamPreAndPostImages interface{} // Specifies a default configuration for indexes on the collection. This option is only valid for MongoDB versions // >= 3.4. The default value is nil, meaning indexes will be configured using server defaults. DefaultIndexOptions DefaultIndexOptions // Specifies the maximum number of documents allowed in a capped collection. The limit specified by the SizeInBytes // option takes precedence over this option. If a capped collection reaches its size limit, old documents will be // removed, regardless of the number of documents in the collection. The default value is 0, meaning the maximum // number of documents is unbounded. MaxDocuments int64 // Specifies the maximum size in bytes for a capped collection. The default value is 0. SizeInBytes int64 // Specifies the storage engine to use for the index. The value must be a document in the form // {<storage engine name>: <options>}. The default value is nil, which means that the default storage engine // will be used. StorageEngine interface{} // Specifies what should happen if a document being inserted does not pass validation. Valid values are "error" and // "warn". See https://www.mongodb.com/docs/manual/core/schema-validation/#accept-or-reject-invalid-documents for more // information. This option is only valid for MongoDB versions >= 3.2. The default value is "error". ValidationAction string // Specifies how strictly the server applies validation rules to existing documents in the collection during update // operations. Valid values are "off", "strict", and "moderate". See // https://www.mongodb.com/docs/manual/core/schema-validation/#existing-documents for more information. This option is // only valid for MongoDB versions >= 3.2. The default value is "strict". ValidationLevel string // A document specifying validation rules for the collection. See // https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about schema validation. This option // is only valid for MongoDB versions >= 3.2. The default value is nil, meaning no validator will be used for the // collection. Validator interface{} // Value indicating after how many seconds old time-series data should be deleted. See // https://www.mongodb.com/docs/manual/reference/command/create/ for supported options, and // https://www.mongodb.com/docs/manual/core/timeseries-collections/ for more information on time-series // collections. // // This option is only valid for MongoDB versions >= 5.0 ExpireAfterSeconds int64 // Options for specifying a time-series collection. See // https://www.mongodb.com/docs/manual/reference/command/create/ for supported options, and // https://www.mongodb.com/docs/manual/core/timeseries-collections/ for more information on time-series // collections. // // This option is only valid for MongoDB versions >= 5.0 TimeSeriesOptions TimeSeriesOptions // EncryptedFields configures encrypted fields. // // This option is only valid for MongoDB versions >= 6.0 EncryptedFields interface{} // ClusteredIndex is used to create a collection with a clustered index. // // This option is only valid for MongoDB versions >= 5.3 ClusteredIndex interface{} } // CreateCollection creates a new CreateCollectionOptions instance. func CreateCollection() CreateCollectionOptions { return &CreateCollectionOptions{} } // SetCapped sets the value for the Capped field. func (c CreateCollectionOptions) SetCapped(capped bool) CreateCollectionOptions { c.Capped = &capped return c } // SetCollation sets the value for the Collation field. func (c CreateCollectionOptions) SetCollation(collation Collation) CreateCollectionOptions { c.Collation = collation return c } // SetChangeStreamPreAndPostImages sets the value for the ChangeStreamPreAndPostImages field. func (c CreateCollectionOptions) SetChangeStreamPreAndPostImages(csppi interface{}) CreateCollectionOptions { c.ChangeStreamPreAndPostImages = &csppi return c } // SetDefaultIndexOptions sets the value for the DefaultIndexOptions field. func (c CreateCollectionOptions) SetDefaultIndexOptions(opts DefaultIndexOptions) CreateCollectionOptions { c.DefaultIndexOptions = opts return c } // SetMaxDocuments sets the value for the MaxDocuments field. func (c CreateCollectionOptions) SetMaxDocuments(max int64) CreateCollectionOptions { c.MaxDocuments = &max return c } // SetSizeInBytes sets the value for the SizeInBytes field. func (c CreateCollectionOptions) SetSizeInBytes(size int64) CreateCollectionOptions { c.SizeInBytes = &size return c } // SetStorageEngine sets the value for the StorageEngine field. func (c CreateCollectionOptions) SetStorageEngine(storageEngine interface{}) CreateCollectionOptions { c.StorageEngine = &storageEngine return c } // SetValidationAction sets the value for the ValidationAction field. func (c CreateCollectionOptions) SetValidationAction(action string) CreateCollectionOptions { c.ValidationAction = &action return c } // SetValidationLevel sets the value for the ValidationLevel field. func (c CreateCollectionOptions) SetValidationLevel(level string) CreateCollectionOptions { c.ValidationLevel = &level return c } // SetValidator sets the value for the Validator field. func (c CreateCollectionOptions) SetValidator(validator interface{}) CreateCollectionOptions { c.Validator = validator return c } // SetExpireAfterSeconds sets the value for the ExpireAfterSeconds field. func (c CreateCollectionOptions) SetExpireAfterSeconds(eas int64) CreateCollectionOptions { c.ExpireAfterSeconds = &eas return c } // SetTimeSeriesOptions sets the options for time-series collections. func (c CreateCollectionOptions) SetTimeSeriesOptions(timeSeriesOpts TimeSeriesOptions) CreateCollectionOptions { c.TimeSeriesOptions = timeSeriesOpts return c } // SetEncryptedFields sets the encrypted fields for encrypted collections. func (c CreateCollectionOptions) SetEncryptedFields(encryptedFields interface{}) CreateCollectionOptions { c.EncryptedFields = encryptedFields return c } // SetClusteredIndex sets the value for the ClusteredIndex field. func (c CreateCollectionOptions) SetClusteredIndex(clusteredIndex interface{}) CreateCollectionOptions { c.ClusteredIndex = clusteredIndex return c } // MergeCreateCollectionOptions combines the given CreateCollectionOptions instances into a single // CreateCollectionOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeCreateCollectionOptions(opts ...CreateCollectionOptions) CreateCollectionOptions { cc := CreateCollection() for _, opt := range opts { if opt == nil { continue } if opt.Capped != nil { cc.Capped = opt.Capped } if opt.Collation != nil { cc.Collation = opt.Collation } if opt.ChangeStreamPreAndPostImages != nil { cc.ChangeStreamPreAndPostImages = opt.ChangeStreamPreAndPostImages } if opt.DefaultIndexOptions != nil { cc.DefaultIndexOptions = opt.DefaultIndexOptions } if opt.MaxDocuments != nil { cc.MaxDocuments = opt.MaxDocuments } if opt.SizeInBytes != nil { cc.SizeInBytes = opt.SizeInBytes } if opt.StorageEngine != nil { cc.StorageEngine = opt.StorageEngine } if opt.ValidationAction != nil { cc.ValidationAction = opt.ValidationAction } if opt.ValidationLevel != nil { cc.ValidationLevel = opt.ValidationLevel } if opt.Validator != nil { cc.Validator = opt.Validator } if opt.ExpireAfterSeconds != nil { cc.ExpireAfterSeconds = opt.ExpireAfterSeconds } if opt.TimeSeriesOptions != nil { cc.TimeSeriesOptions = opt.TimeSeriesOptions } if opt.EncryptedFields != nil { cc.EncryptedFields = opt.EncryptedFields } if opt.ClusteredIndex != nil { cc.ClusteredIndex = opt.ClusteredIndex } } return cc } // CreateViewOptions represents options that can be used to configure a CreateView operation. type CreateViewOptions struct { // Specifies the default collation for the new collection. This option is only valid for MongoDB versions >= 3.4. // For previous server versions, the driver will return an error if this option is used. The default value is nil. Collation Collation } // CreateView creates an new CreateViewOptions instance. func CreateView() CreateViewOptions { return &CreateViewOptions{} } // SetCollation sets the value for the Collation field. func (c CreateViewOptions) SetCollation(collation Collation) CreateViewOptions { c.Collation = collation return c } // MergeCreateViewOptions combines the given CreateViewOptions instances into a single CreateViewOptions in a // last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeCreateViewOptions(opts ...CreateViewOptions) CreateViewOptions { cv := CreateView() for _, opt := range opts { if opt == nil { continue } if opt.Collation != nil { cv.Collation = opt.Collation } } return cv }	13.38 KB	2025-05-25 12:27
📄 datakeyoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // DataKeyOptions represents all possible options used to create a new data key. type DataKeyOptions struct { MasterKey interface{} KeyAltNames []string // KeyMaterial is used to encrypt data. If omitted, keyMaterial is generated form a cryptographically secure random // source. "Key Material" is used interchangeably with "dataKey" and "Data Encryption Key" (DEK). KeyMaterial []byte } // DataKey creates a new DataKeyOptions instance. func DataKey() DataKeyOptions { return &DataKeyOptions{} } // SetMasterKey specifies a KMS-specific key used to encrypt the new data key. // // If being used with a local KMS provider, this option is not applicable and should not be specified. // // For the AWS, Azure, and GCP KMS providers, this option is required and must be a document. For each, the value of the // "endpoint" or "keyVaultEndpoint" must be a host name with an optional port number (e.g. "foo.com" or "foo.com:443"). // // When using AWS, the document must have the format: // // { // region: <string>, // key: <string>, // The Amazon Resource Name (ARN) to the AWS customer master key (CMK). // endpoint: Optional<string> // An alternate host identifier to send KMS requests to. // } // // If unset, the "endpoint" defaults to "kms.<region>.amazonaws.com". // // When using Azure, the document must have the format: // // { // keyVaultEndpoint: <string>, // A host identifier to send KMS requests to. // keyName: <string>, // keyVersion: Optional<string> // A specific version of the named key. // } // // If unset, "keyVersion" defaults to the key's primary version. // // When using GCP, the document must have the format: // // { // projectId: <string>, // location: <string>, // keyRing: <string>, // keyName: <string>, // keyVersion: Optional<string>, // A specific version of the named key. // endpoint: Optional<string> // An alternate host identifier to send KMS requests to. // } // // If unset, "keyVersion" defaults to the key's primary version and "endpoint" defaults to "cloudkms.googleapis.com". func (dk DataKeyOptions) SetMasterKey(masterKey interface{}) DataKeyOptions { dk.MasterKey = masterKey return dk } // SetKeyAltNames specifies an optional list of string alternate names used to reference a key. If a key is created' // with alternate names, encryption may refer to the key by a unique alternate name instead of by _id. func (dk DataKeyOptions) SetKeyAltNames(keyAltNames []string) DataKeyOptions { dk.KeyAltNames = keyAltNames return dk } // SetKeyMaterial will set a custom keyMaterial to DataKeyOptions which can be used to encrypt data. func (dk DataKeyOptions) SetKeyMaterial(keyMaterial []byte) DataKeyOptions { dk.KeyMaterial = keyMaterial return dk } // MergeDataKeyOptions combines the argued DataKeyOptions in a last-one wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeDataKeyOptions(opts ...DataKeyOptions) *DataKeyOptions { dko := DataKey() for _, opt := range opts { if opt == nil { continue } if opt.MasterKey != nil { dko.MasterKey = opt.MasterKey } if opt.KeyAltNames != nil { dko.KeyAltNames = opt.KeyAltNames } if opt.KeyMaterial != nil { dko.KeyMaterial = opt.KeyMaterial } } return dko }	3.56 KB	2025-05-25 12:27
📄 dboptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" ) // DatabaseOptions represents options that can be used to configure a Database. type DatabaseOptions struct { // ReadConcern is the read concern to use for operations executed on the Database. The default value is nil, which means that // the read concern of the Client used to configure the Database will be used. ReadConcern readconcern.ReadConcern // WriteConcern is the write concern to use for operations executed on the Database. The default value is nil, which means that the // write concern of the Client used to configure the Database will be used. WriteConcern writeconcern.WriteConcern // ReadPreference is the read preference to use for operations executed on the Database. The default value is nil, which means that // the read preference of the Client used to configure the Database will be used. ReadPreference readpref.ReadPref // BSONOptions configures optional BSON marshaling and unmarshaling // behavior. BSONOptions BSONOptions // Registry is the BSON registry to marshal and unmarshal documents for operations executed on the Database. The default value // is nil, which means that the registry of the Client used to configure the Database will be used. Registry bsoncodec.Registry } // Database creates a new DatabaseOptions instance. func Database() DatabaseOptions { return &DatabaseOptions{} } // SetReadConcern sets the value for the ReadConcern field. func (d DatabaseOptions) SetReadConcern(rc readconcern.ReadConcern) DatabaseOptions { d.ReadConcern = rc return d } // SetWriteConcern sets the value for the WriteConcern field. func (d DatabaseOptions) SetWriteConcern(wc writeconcern.WriteConcern) DatabaseOptions { d.WriteConcern = wc return d } // SetReadPreference sets the value for the ReadPreference field. func (d DatabaseOptions) SetReadPreference(rp readpref.ReadPref) DatabaseOptions { d.ReadPreference = rp return d } // SetBSONOptions configures optional BSON marshaling and unmarshaling behavior. func (d DatabaseOptions) SetBSONOptions(opts BSONOptions) DatabaseOptions { d.BSONOptions = opts return d } // SetRegistry sets the value for the Registry field. func (d DatabaseOptions) SetRegistry(r bsoncodec.Registry) DatabaseOptions { d.Registry = r return d } // MergeDatabaseOptions combines the given DatabaseOptions instances into a single DatabaseOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeDatabaseOptions(opts ...DatabaseOptions) *DatabaseOptions { d := Database() for _, opt := range opts { if opt == nil { continue } if opt.ReadConcern != nil { d.ReadConcern = opt.ReadConcern } if opt.WriteConcern != nil { d.WriteConcern = opt.WriteConcern } if opt.ReadPreference != nil { d.ReadPreference = opt.ReadPreference } if opt.Registry != nil { d.Registry = opt.Registry } if opt.BSONOptions != nil { d.BSONOptions = opt.BSONOptions } } return d }	3.46 KB	2025-05-25 12:27
📄 deleteoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // DeleteOptions represents options that can be used to configure DeleteOne and DeleteMany operations. type DeleteOptions struct { // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // The index to use for the operation. This should either be the index name as a string or the index specification // as a document. This option is only valid for MongoDB versions >= 4.4. Server versions >= 3.4 will return an error // if this option is specified. For server versions < 3.4, the driver will return a client-side error if this option // is specified. The driver will return an error if this option is specified during an unacknowledged write // operation. The driver will return an error if the hint parameter is a multi-key map. The default value is nil, // which means that no hint will be sent. Hint interface{} // Specifies parameters for the delete expression. This option is only valid for MongoDB versions >= 5.0. Older // servers will report an error for using this option. This must be a document mapping parameter names to values. // Values must be constant or closed expressions that do not reference document fields. Parameters can then be // accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} } // Delete creates a new DeleteOptions instance. func Delete() DeleteOptions { return &DeleteOptions{} } // SetCollation sets the value for the Collation field. func (do DeleteOptions) SetCollation(c Collation) DeleteOptions { do.Collation = c return do } // SetComment sets the value for the Comment field. func (do DeleteOptions) SetComment(comment interface{}) DeleteOptions { do.Comment = comment return do } // SetHint sets the value for the Hint field. func (do DeleteOptions) SetHint(hint interface{}) DeleteOptions { do.Hint = hint return do } // SetLet sets the value for the Let field. func (do DeleteOptions) SetLet(let interface{}) DeleteOptions { do.Let = let return do } // MergeDeleteOptions combines the given DeleteOptions instances into a single DeleteOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeDeleteOptions(opts ...DeleteOptions) *DeleteOptions { dOpts := Delete() for _, do := range opts { if do == nil { continue } if do.Collation != nil { dOpts.Collation = do.Collation } if do.Comment != nil { dOpts.Comment = do.Comment } if do.Hint != nil { dOpts.Hint = do.Hint } if do.Let != nil { dOpts.Let = do.Let } } return dOpts }	3.35 KB	2025-05-25 12:27
📄 distinctoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import "time" // DistinctOptions represents options that can be used to configure a Distinct operation. type DistinctOptions struct { // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be // used in its place to control the amount of time that a single operation can run before returning an error. // MaxTime is ignored if Timeout is set on the client. MaxTime time.Duration } // Distinct creates a new DistinctOptions instance. func Distinct() DistinctOptions { return &DistinctOptions{} } // SetCollation sets the value for the Collation field. func (do DistinctOptions) SetCollation(c Collation) DistinctOptions { do.Collation = c return do } // SetComment sets the value for the Comment field. func (do DistinctOptions) SetComment(comment interface{}) DistinctOptions { do.Comment = comment return do } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (do DistinctOptions) SetMaxTime(d time.Duration) DistinctOptions { do.MaxTime = &d return do } // MergeDistinctOptions combines the given DistinctOptions instances into a single DistinctOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeDistinctOptions(opts ...DistinctOptions) DistinctOptions { distinctOpts := Distinct() for _, do := range opts { if do == nil { continue } if do.Collation != nil { distinctOpts.Collation = do.Collation } if do.Comment != nil { distinctOpts.Comment = do.Comment } if do.MaxTime != nil { distinctOpts.MaxTime = do.MaxTime } } return distinctOpts }	2.93 KB	2025-05-25 12:27
📄 doc.go // Copyright (C) MongoDB, Inc. 2022-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 // Package options defines the optional configurations for the MongoDB Go Driver. package options	368 B	2025-05-25 12:27
📄 encryptoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/primitive" ) // These constants specify valid values for QueryType // QueryType is used for Queryable Encryption. const ( QueryTypeEquality string = "equality" ) // RangeOptions specifies index options for a Queryable Encryption field supporting "rangePreview" queries. // Beta: The Range algorithm is experimental only. It is not intended for public use. It is subject to breaking changes. type RangeOptions struct { Min bson.RawValue Max bson.RawValue Sparsity int64 Precision int32 } // EncryptOptions represents options to explicitly encrypt a value. type EncryptOptions struct { KeyID primitive.Binary KeyAltName string Algorithm string QueryType string ContentionFactor int64 RangeOptions RangeOptions } // Encrypt creates a new EncryptOptions instance. func Encrypt() EncryptOptions { return &EncryptOptions{} } // SetKeyID specifies an _id of a data key. This should be a UUID (a primitive.Binary with subtype 4). func (e EncryptOptions) SetKeyID(keyID primitive.Binary) EncryptOptions { e.KeyID = &keyID return e } // SetKeyAltName identifies a key vault document by 'keyAltName'. func (e EncryptOptions) SetKeyAltName(keyAltName string) EncryptOptions { e.KeyAltName = &keyAltName return e } // SetAlgorithm specifies an algorithm to use for encryption. This should be one of the following: // - AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic // - AEAD_AES_256_CBC_HMAC_SHA_512-Random // - Indexed // - Unindexed // This is required. // Indexed and Unindexed are used for Queryable Encryption. func (e EncryptOptions) SetAlgorithm(algorithm string) EncryptOptions { e.Algorithm = algorithm return e } // SetQueryType specifies the intended query type. It is only valid to set if algorithm is "Indexed". // This should be one of the following: // - equality // QueryType is used for Queryable Encryption. func (e EncryptOptions) SetQueryType(queryType string) EncryptOptions { e.QueryType = queryType return e } // SetContentionFactor specifies the contention factor. It is only valid to set if algorithm is "Indexed". // ContentionFactor is used for Queryable Encryption. func (e EncryptOptions) SetContentionFactor(contentionFactor int64) EncryptOptions { e.ContentionFactor = &contentionFactor return e } // SetRangeOptions specifies the options to use for explicit encryption with range. It is only valid to set if algorithm is "rangePreview". // Beta: The Range algorithm is experimental only. It is not intended for public use. It is subject to breaking changes. func (e EncryptOptions) SetRangeOptions(ro RangeOptions) EncryptOptions { e.RangeOptions = &ro return e } // SetMin sets the range index minimum value. // Beta: The Range algorithm is experimental only. It is not intended for public use. It is subject to breaking changes. func (ro RangeOptions) SetMin(min bson.RawValue) RangeOptions { ro.Min = &min return ro } // SetMax sets the range index maximum value. // Beta: The Range algorithm is experimental only. It is not intended for public use. It is subject to breaking changes. func (ro RangeOptions) SetMax(max bson.RawValue) RangeOptions { ro.Max = &max return ro } // SetSparsity sets the range index sparsity. // Beta: The Range algorithm is experimental only. It is not intended for public use. It is subject to breaking changes. func (ro RangeOptions) SetSparsity(sparsity int64) RangeOptions { ro.Sparsity = sparsity return ro } // SetPrecision sets the range index precision. // Beta: The Range algorithm is experimental only. It is not intended for public use. It is subject to breaking changes. func (ro RangeOptions) SetPrecision(precision int32) RangeOptions { ro.Precision = &precision return ro } // MergeEncryptOptions combines the argued EncryptOptions in a last-one wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeEncryptOptions(opts ...EncryptOptions) EncryptOptions { eo := Encrypt() for _, opt := range opts { if opt == nil { continue } if opt.KeyID != nil { eo.KeyID = opt.KeyID } if opt.KeyAltName != nil { eo.KeyAltName = opt.KeyAltName } if opt.Algorithm != "" { eo.Algorithm = opt.Algorithm } if opt.QueryType != "" { eo.QueryType = opt.QueryType } if opt.ContentionFactor != nil { eo.ContentionFactor = opt.ContentionFactor } if opt.RangeOptions != nil { eo.RangeOptions = opt.RangeOptions } } return eo }	4.8 KB	2025-05-25 12:27
📄 estimatedcountoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import "time" // EstimatedDocumentCountOptions represents options that can be used to configure an EstimatedDocumentCount operation. type EstimatedDocumentCountOptions struct { // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default is nil, which means that no comment will be included in the logs. Comment interface{} // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration } // EstimatedDocumentCount creates a new EstimatedDocumentCountOptions instance. func EstimatedDocumentCount() EstimatedDocumentCountOptions { return &EstimatedDocumentCountOptions{} } // SetComment sets the value for the Comment field. func (eco EstimatedDocumentCountOptions) SetComment(comment interface{}) EstimatedDocumentCountOptions { eco.Comment = comment return eco } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option // may be used in its place to control the amount of time that a single operation can run before // returning an error. MaxTime is ignored if Timeout is set on the client. func (eco EstimatedDocumentCountOptions) SetMaxTime(d time.Duration) EstimatedDocumentCountOptions { eco.MaxTime = &d return eco } // MergeEstimatedDocumentCountOptions combines the given EstimatedDocumentCountOptions instances into a single // EstimatedDocumentCountOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeEstimatedDocumentCountOptions(opts ...EstimatedDocumentCountOptions) EstimatedDocumentCountOptions { e := EstimatedDocumentCount() for _, opt := range opts { if opt == nil { continue } if opt.Comment != nil { e.Comment = opt.Comment } if opt.MaxTime != nil { e.MaxTime = opt.MaxTime } } return e }	2.59 KB	2025-05-25 12:27
📄 example_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options_test import ( "bytes" "context" "fmt" "io" "log" "sync" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" ) type CustomLogger struct { io.Writer mu sync.Mutex } func (logger CustomLogger) Info(level int, msg string, _ ...interface{}) { logger.mu.Lock() defer logger.mu.Unlock() fmt.Fprintf(logger, "level=%d msg=%s\n", level, msg) } func (logger CustomLogger) Error(err error, msg string, _ ...interface{}) { logger.mu.Lock() defer logger.mu.Unlock() fmt.Fprintf(logger, "err=%v msg=%s\n", err, msg) } func ExampleClientOptions_SetLoggerOptions_customLogger() { buf := bytes.NewBuffer(nil) sink := &CustomLogger{Writer: buf} // Create a client with our logger options. loggerOptions := options. Logger(). SetSink(sink). SetMaxDocumentLength(25). SetComponentLevel(options.LogComponentCommand, options.LogLevelDebug) clientOptions := options. Client(). ApplyURI("mongodb://localhost:27017"). SetLoggerOptions(loggerOptions) client, err := mongo.Connect(context.TODO(), clientOptions) if err != nil { log.Fatalf("error connecting to MongoDB: %v", err) } defer func() { _ = client.Disconnect(context.TODO()) }() // Make a database request to test our logging solution. coll := client.Database("test").Collection("test") _, err = coll.InsertOne(context.TODO(), map[string]string{"foo": "bar"}) if err != nil { log.Fatalf("InsertOne failed: %v", err) } // Print the logs. fmt.Println(buf.String()) }	1.74 KB	2025-05-25 12:27
📄 findoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "time" ) // FindOptions represents options that can be used to configure a Find operation. type FindOptions struct { // AllowDiskUse specifies whether the server can write temporary data to disk while executing the Find operation. // This option is only valid for MongoDB versions >= 4.4. Server versions >= 3.2 will report an error if this option // is specified. For server versions < 3.2, the driver will return a client-side error if this option is specified. // The default value is false. AllowDiskUse bool // AllowPartial results specifies whether the Find operation on a sharded cluster can return partial results if some // shards are down rather than returning an error. The default value is false. AllowPartialResults bool // BatchSize is the maximum number of documents to be included in each batch returned by the server. BatchSize int32 // Collation specifies a collation to use for string comparisons during the operation. This option is only valid for // MongoDB versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string that will be included in server logs, profiling logs, and currentOp queries to help trace the operation. // The default is nil, which means that no comment will be included in the logs. Comment string // CursorType specifies the type of cursor that should be created for the operation. The default is NonTailable, which // means that the cursor will be closed by the server when the last batch of documents is retrieved. CursorType CursorType // Hint is the index to use for the Find operation. This should either be the index name as a string or the index // specification as a document. The driver will return an error if the hint parameter is a multi-key map. The default // value is nil, which means that no hint will be sent. Hint interface{} // Limit is the maximum number of documents to return. The default value is 0, which means that all documents matching the // filter will be returned. A negative limit specifies that the resulting documents should be returned in a single // batch. The default value is 0. Limit int64 // Max is a document specifying the exclusive upper bound for a specific index. The default value is nil, which means that // there is no maximum value. Max interface{} // MaxAwaitTime is the maximum amount of time that the server should wait for new documents to satisfy a tailable cursor // query. This option is only valid for tailable await cursors (see the CursorType option for more information) and // MongoDB versions >= 3.2. For other cursor types or previous server versions, this option is ignored. MaxAwaitTime time.Duration // MaxTime is the maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used in its // place to control the amount of time that a single operation can run before returning an error. MaxTime is ignored if // Timeout is set on the client. MaxTime time.Duration // Min is a document specifying the inclusive lower bound for a specific index. The default value is 0, which means that // there is no minimum value. Min interface{} // NoCursorTimeout specifies whether the cursor created by the operation will not timeout after a period of inactivity. // The default value is false. NoCursorTimeout bool // OplogReplay is for internal replication use only and should not be set. // // Deprecated: This option has been deprecated in MongoDB version 4.4 and will be ignored by the server if it is // set. OplogReplay bool // Project is a document describing which fields will be included in the documents returned by the Find operation. The // default value is nil, which means all fields will be included. Projection interface{} // ReturnKey specifies whether the documents returned by the Find operation will only contain fields corresponding to the // index used. The default value is false. ReturnKey bool // ShowRecordID specifies whether a $recordId field with a record identifier will be included in the documents returned by // the Find operation. The default value is false. ShowRecordID bool // Skip is the number of documents to skip before adding documents to the result. The default value is 0. Skip int64 // Snapshot specifies whether the cursor will not return a document more than once because of an intervening write operation. // The default value is false. // // Deprecated: This option has been deprecated in MongoDB version 3.6 and removed in MongoDB version 4.0. Snapshot bool // Sort is a document specifying the order in which documents should be returned. The driver will return an error if the // sort parameter is a multi-key map. Sort interface{} // Let specifies parameters for the find expression. This option is only valid for MongoDB versions >= 5.0. Older // servers will report an error for using this option. This must be a document mapping parameter names to values. // Values must be constant or closed expressions that do not reference document fields. Parameters can then be // accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} } // Find creates a new FindOptions instance. func Find() FindOptions { return &FindOptions{} } // SetAllowDiskUse sets the value for the AllowDiskUse field. func (f FindOptions) SetAllowDiskUse(b bool) FindOptions { f.AllowDiskUse = &b return f } // SetAllowPartialResults sets the value for the AllowPartialResults field. func (f FindOptions) SetAllowPartialResults(b bool) FindOptions { f.AllowPartialResults = &b return f } // SetBatchSize sets the value for the BatchSize field. func (f FindOptions) SetBatchSize(i int32) FindOptions { f.BatchSize = &i return f } // SetCollation sets the value for the Collation field. func (f FindOptions) SetCollation(collation Collation) FindOptions { f.Collation = collation return f } // SetComment sets the value for the Comment field. func (f FindOptions) SetComment(comment string) FindOptions { f.Comment = &comment return f } // SetCursorType sets the value for the CursorType field. func (f FindOptions) SetCursorType(ct CursorType) FindOptions { f.CursorType = &ct return f } // SetHint sets the value for the Hint field. func (f FindOptions) SetHint(hint interface{}) FindOptions { f.Hint = hint return f } // SetLet sets the value for the Let field. func (f FindOptions) SetLet(let interface{}) FindOptions { f.Let = let return f } // SetLimit sets the value for the Limit field. func (f FindOptions) SetLimit(i int64) FindOptions { f.Limit = &i return f } // SetMax sets the value for the Max field. func (f FindOptions) SetMax(max interface{}) FindOptions { f.Max = max return f } // SetMaxAwaitTime sets the value for the MaxAwaitTime field. func (f FindOptions) SetMaxAwaitTime(d time.Duration) FindOptions { f.MaxAwaitTime = &d return f } // SetMaxTime specifies the max time to allow the query to run. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used used in its place to control the amount of time that a single operation // can run before returning an error. MaxTime is ignored if Timeout is set on the client. func (f FindOptions) SetMaxTime(d time.Duration) FindOptions { f.MaxTime = &d return f } // SetMin sets the value for the Min field. func (f FindOptions) SetMin(min interface{}) FindOptions { f.Min = min return f } // SetNoCursorTimeout sets the value for the NoCursorTimeout field. func (f FindOptions) SetNoCursorTimeout(b bool) FindOptions { f.NoCursorTimeout = &b return f } // SetOplogReplay sets the value for the OplogReplay field. // // Deprecated: This option has been deprecated in MongoDB version 4.4 and will be ignored by the server if it is set. func (f FindOptions) SetOplogReplay(b bool) FindOptions { f.OplogReplay = &b return f } // SetProjection sets the value for the Projection field. func (f FindOptions) SetProjection(projection interface{}) FindOptions { f.Projection = projection return f } // SetReturnKey sets the value for the ReturnKey field. func (f FindOptions) SetReturnKey(b bool) FindOptions { f.ReturnKey = &b return f } // SetShowRecordID sets the value for the ShowRecordID field. func (f FindOptions) SetShowRecordID(b bool) FindOptions { f.ShowRecordID = &b return f } // SetSkip sets the value for the Skip field. func (f FindOptions) SetSkip(i int64) FindOptions { f.Skip = &i return f } // SetSnapshot sets the value for the Snapshot field. // // Deprecated: This option has been deprecated in MongoDB version 3.6 and removed in MongoDB version 4.0. func (f FindOptions) SetSnapshot(b bool) FindOptions { f.Snapshot = &b return f } // SetSort sets the value for the Sort field. func (f FindOptions) SetSort(sort interface{}) FindOptions { f.Sort = sort return f } // MergeFindOptions combines the given FindOptions instances into a single FindOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeFindOptions(opts ...FindOptions) FindOptions { fo := Find() for _, opt := range opts { if opt == nil { continue } if opt.AllowDiskUse != nil { fo.AllowDiskUse = opt.AllowDiskUse } if opt.AllowPartialResults != nil { fo.AllowPartialResults = opt.AllowPartialResults } if opt.BatchSize != nil { fo.BatchSize = opt.BatchSize } if opt.Collation != nil { fo.Collation = opt.Collation } if opt.Comment != nil { fo.Comment = opt.Comment } if opt.CursorType != nil { fo.CursorType = opt.CursorType } if opt.Hint != nil { fo.Hint = opt.Hint } if opt.Let != nil { fo.Let = opt.Let } if opt.Limit != nil { fo.Limit = opt.Limit } if opt.Max != nil { fo.Max = opt.Max } if opt.MaxAwaitTime != nil { fo.MaxAwaitTime = opt.MaxAwaitTime } if opt.MaxTime != nil { fo.MaxTime = opt.MaxTime } if opt.Min != nil { fo.Min = opt.Min } if opt.NoCursorTimeout != nil { fo.NoCursorTimeout = opt.NoCursorTimeout } if opt.OplogReplay != nil { fo.OplogReplay = opt.OplogReplay } if opt.Projection != nil { fo.Projection = opt.Projection } if opt.ReturnKey != nil { fo.ReturnKey = opt.ReturnKey } if opt.ShowRecordID != nil { fo.ShowRecordID = opt.ShowRecordID } if opt.Skip != nil { fo.Skip = opt.Skip } if opt.Snapshot != nil { fo.Snapshot = opt.Snapshot } if opt.Sort != nil { fo.Sort = opt.Sort } } return fo } // FindOneOptions represents options that can be used to configure a FindOne operation. type FindOneOptions struct { // If true, an operation on a sharded cluster can return partial results if some shards are down rather than // returning an error. The default value is false. AllowPartialResults bool // The maximum number of documents to be included in each batch returned by the server. // // Deprecated: This option is not valid for a findOne operation, as no cursor is actually created. BatchSize int32 // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string that will be included in server logs, profiling logs, and currentOp queries to help trace the operation. // The default is nil, which means that no comment will be included in the logs. Comment string // Specifies the type of cursor that should be created for the operation. The default is NonTailable, which means // that the cursor will be closed by the server when the last batch of documents is retrieved. // // Deprecated: This option is not valid for a findOne operation, as no cursor is actually created. CursorType CursorType // The index to use for the aggregation. This should either be the index name as a string or the index specification // as a document. The driver will return an error if the hint parameter is a multi-key map. The default value is nil, // which means that no hint will be sent. Hint interface{} // A document specifying the exclusive upper bound for a specific index. The default value is nil, which means that // there is no maximum value. Max interface{} // The maximum amount of time that the server should wait for new documents to satisfy a tailable cursor query. // This option is only valid for tailable await cursors (see the CursorType option for more information) and // MongoDB versions >= 3.2. For other cursor types or previous server versions, this option is ignored. // // Deprecated: This option is not valid for a findOne operation, as no cursor is actually created. MaxAwaitTime time.Duration // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration // A document specifying the inclusive lower bound for a specific index. The default value is 0, which means that // there is no minimum value. Min interface{} // If true, the cursor created by the operation will not timeout after a period of inactivity. The default value // is false. // // Deprecated: This option is not valid for a findOne operation, as no cursor is actually created. NoCursorTimeout bool // This option is for internal replication use only and should not be set. // // Deprecated: This option has been deprecated in MongoDB version 4.4 and will be ignored by the server if it is // set. OplogReplay bool // A document describing which fields will be included in the document returned by the operation. The default value // is nil, which means all fields will be included. Projection interface{} // If true, the document returned by the operation will only contain fields corresponding to the index used. The // default value is false. ReturnKey bool // If true, a $recordId field with a record identifier will be included in the document returned by the operation. // The default value is false. ShowRecordID bool // The number of documents to skip before selecting the document to be returned. The default value is 0. Skip int64 // If true, the cursor will not return a document more than once because of an intervening write operation. The // default value is false. // // Deprecated: This option has been deprecated in MongoDB version 3.6 and removed in MongoDB version 4.0. Snapshot bool // A document specifying the sort order to apply to the query. The first document in the sorted order will be // returned. The driver will return an error if the sort parameter is a multi-key map. Sort interface{} } // FindOne creates a new FindOneOptions instance. func FindOne() FindOneOptions { return &FindOneOptions{} } // SetAllowPartialResults sets the value for the AllowPartialResults field. func (f FindOneOptions) SetAllowPartialResults(b bool) FindOneOptions { f.AllowPartialResults = &b return f } // SetBatchSize sets the value for the BatchSize field. // // Deprecated: This option is not valid for a findOne operation, as no cursor is actually created. func (f FindOneOptions) SetBatchSize(i int32) FindOneOptions { f.BatchSize = &i return f } // SetCollation sets the value for the Collation field. func (f FindOneOptions) SetCollation(collation Collation) FindOneOptions { f.Collation = collation return f } // SetComment sets the value for the Comment field. func (f FindOneOptions) SetComment(comment string) FindOneOptions { f.Comment = &comment return f } // SetCursorType sets the value for the CursorType field. // // Deprecated: This option is not valid for a findOne operation, as no cursor is actually created. func (f FindOneOptions) SetCursorType(ct CursorType) FindOneOptions { f.CursorType = &ct return f } // SetHint sets the value for the Hint field. func (f FindOneOptions) SetHint(hint interface{}) FindOneOptions { f.Hint = hint return f } // SetMax sets the value for the Max field. func (f FindOneOptions) SetMax(max interface{}) FindOneOptions { f.Max = max return f } // SetMaxAwaitTime sets the value for the MaxAwaitTime field. // // Deprecated: This option is not valid for a findOne operation, as no cursor is actually created. func (f FindOneOptions) SetMaxAwaitTime(d time.Duration) FindOneOptions { f.MaxAwaitTime = &d return f } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (f FindOneOptions) SetMaxTime(d time.Duration) FindOneOptions { f.MaxTime = &d return f } // SetMin sets the value for the Min field. func (f FindOneOptions) SetMin(min interface{}) FindOneOptions { f.Min = min return f } // SetNoCursorTimeout sets the value for the NoCursorTimeout field. // // Deprecated: This option is not valid for a findOne operation, as no cursor is actually created. func (f FindOneOptions) SetNoCursorTimeout(b bool) FindOneOptions { f.NoCursorTimeout = &b return f } // SetOplogReplay sets the value for the OplogReplay field. // // Deprecated: This option has been deprecated in MongoDB version 4.4 and will be ignored by the server if it is // set. func (f FindOneOptions) SetOplogReplay(b bool) FindOneOptions { f.OplogReplay = &b return f } // SetProjection sets the value for the Projection field. func (f FindOneOptions) SetProjection(projection interface{}) FindOneOptions { f.Projection = projection return f } // SetReturnKey sets the value for the ReturnKey field. func (f FindOneOptions) SetReturnKey(b bool) FindOneOptions { f.ReturnKey = &b return f } // SetShowRecordID sets the value for the ShowRecordID field. func (f FindOneOptions) SetShowRecordID(b bool) FindOneOptions { f.ShowRecordID = &b return f } // SetSkip sets the value for the Skip field. func (f FindOneOptions) SetSkip(i int64) FindOneOptions { f.Skip = &i return f } // SetSnapshot sets the value for the Snapshot field. // // Deprecated: This option has been deprecated in MongoDB version 3.6 and removed in MongoDB version 4.0. func (f FindOneOptions) SetSnapshot(b bool) FindOneOptions { f.Snapshot = &b return f } // SetSort sets the value for the Sort field. func (f FindOneOptions) SetSort(sort interface{}) FindOneOptions { f.Sort = sort return f } // MergeFindOneOptions combines the given FindOneOptions instances into a single FindOneOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeFindOneOptions(opts ...FindOneOptions) FindOneOptions { fo := FindOne() for _, opt := range opts { if opt == nil { continue } if opt.AllowPartialResults != nil { fo.AllowPartialResults = opt.AllowPartialResults } if opt.BatchSize != nil { fo.BatchSize = opt.BatchSize } if opt.Collation != nil { fo.Collation = opt.Collation } if opt.Comment != nil { fo.Comment = opt.Comment } if opt.CursorType != nil { fo.CursorType = opt.CursorType } if opt.Hint != nil { fo.Hint = opt.Hint } if opt.Max != nil { fo.Max = opt.Max } if opt.MaxAwaitTime != nil { fo.MaxAwaitTime = opt.MaxAwaitTime } if opt.MaxTime != nil { fo.MaxTime = opt.MaxTime } if opt.Min != nil { fo.Min = opt.Min } if opt.NoCursorTimeout != nil { fo.NoCursorTimeout = opt.NoCursorTimeout } if opt.OplogReplay != nil { fo.OplogReplay = opt.OplogReplay } if opt.Projection != nil { fo.Projection = opt.Projection } if opt.ReturnKey != nil { fo.ReturnKey = opt.ReturnKey } if opt.ShowRecordID != nil { fo.ShowRecordID = opt.ShowRecordID } if opt.Skip != nil { fo.Skip = opt.Skip } if opt.Snapshot != nil { fo.Snapshot = opt.Snapshot } if opt.Sort != nil { fo.Sort = opt.Sort } } return fo } // FindOneAndReplaceOptions represents options that can be used to configure a FindOneAndReplace instance. type FindOneAndReplaceOptions struct { // If true, writes executed as part of the operation will opt out of document-level validation on the server. This // option is valid for MongoDB versions >= 3.2 and is ignored for previous server versions. The default value is // false. See https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about document // validation. BypassDocumentValidation bool // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration // A document describing which fields will be included in the document returned by the operation. The default value // is nil, which means all fields will be included. Projection interface{} // Specifies whether the original or replaced document should be returned by the operation. The default value is // Before, which means the original document will be returned from before the replacement is performed. ReturnDocument ReturnDocument // A document specifying which document should be replaced if the filter used by the operation matches multiple // documents in the collection. If set, the first document in the sorted order will be replaced. The driver will // return an error if the sort parameter is a multi-key map. The default value is nil. Sort interface{} // If true, a new document will be inserted if the filter does not match any documents in the collection. The // default value is false. Upsert bool // The index to use for the operation. This should either be the index name as a string or the index specification // as a document. This option is only valid for MongoDB versions >= 4.4. MongoDB version 4.2 will report an error if // this option is specified. For server versions < 4.2, the driver will return an error if this option is specified. // The driver will return an error if this option is used with during an unacknowledged write operation. The driver // will return an error if the hint parameter is a multi-key map. The default value is nil, which means that no hint // will be sent. Hint interface{} // Specifies parameters for the find one and replace expression. This option is only valid for MongoDB versions >= 5.0. Older // servers will report an error for using this option. This must be a document mapping parameter names to values. // Values must be constant or closed expressions that do not reference document fields. Parameters can then be // accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} } // FindOneAndReplace creates a new FindOneAndReplaceOptions instance. func FindOneAndReplace() FindOneAndReplaceOptions { return &FindOneAndReplaceOptions{} } // SetBypassDocumentValidation sets the value for the BypassDocumentValidation field. func (f FindOneAndReplaceOptions) SetBypassDocumentValidation(b bool) FindOneAndReplaceOptions { f.BypassDocumentValidation = &b return f } // SetCollation sets the value for the Collation field. func (f FindOneAndReplaceOptions) SetCollation(collation Collation) FindOneAndReplaceOptions { f.Collation = collation return f } // SetComment sets the value for the Comment field. func (f FindOneAndReplaceOptions) SetComment(comment interface{}) FindOneAndReplaceOptions { f.Comment = comment return f } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (f FindOneAndReplaceOptions) SetMaxTime(d time.Duration) FindOneAndReplaceOptions { f.MaxTime = &d return f } // SetProjection sets the value for the Projection field. func (f FindOneAndReplaceOptions) SetProjection(projection interface{}) FindOneAndReplaceOptions { f.Projection = projection return f } // SetReturnDocument sets the value for the ReturnDocument field. func (f FindOneAndReplaceOptions) SetReturnDocument(rd ReturnDocument) FindOneAndReplaceOptions { f.ReturnDocument = &rd return f } // SetSort sets the value for the Sort field. func (f FindOneAndReplaceOptions) SetSort(sort interface{}) FindOneAndReplaceOptions { f.Sort = sort return f } // SetUpsert sets the value for the Upsert field. func (f FindOneAndReplaceOptions) SetUpsert(b bool) FindOneAndReplaceOptions { f.Upsert = &b return f } // SetHint sets the value for the Hint field. func (f FindOneAndReplaceOptions) SetHint(hint interface{}) FindOneAndReplaceOptions { f.Hint = hint return f } // SetLet sets the value for the Let field. func (f FindOneAndReplaceOptions) SetLet(let interface{}) FindOneAndReplaceOptions { f.Let = let return f } // MergeFindOneAndReplaceOptions combines the given FindOneAndReplaceOptions instances into a single // FindOneAndReplaceOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeFindOneAndReplaceOptions(opts ...FindOneAndReplaceOptions) FindOneAndReplaceOptions { fo := FindOneAndReplace() for _, opt := range opts { if opt == nil { continue } if opt.BypassDocumentValidation != nil { fo.BypassDocumentValidation = opt.BypassDocumentValidation } if opt.Collation != nil { fo.Collation = opt.Collation } if opt.Comment != nil { fo.Comment = opt.Comment } if opt.MaxTime != nil { fo.MaxTime = opt.MaxTime } if opt.Projection != nil { fo.Projection = opt.Projection } if opt.ReturnDocument != nil { fo.ReturnDocument = opt.ReturnDocument } if opt.Sort != nil { fo.Sort = opt.Sort } if opt.Upsert != nil { fo.Upsert = opt.Upsert } if opt.Hint != nil { fo.Hint = opt.Hint } if opt.Let != nil { fo.Let = opt.Let } } return fo } // FindOneAndUpdateOptions represents options that can be used to configure a FindOneAndUpdate options. type FindOneAndUpdateOptions struct { // A set of filters specifying to which array elements an update should apply. This option is only valid for MongoDB // versions >= 3.6. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the update will apply to all array elements. ArrayFilters ArrayFilters // If true, writes executed as part of the operation will opt out of document-level validation on the server. This // option is valid for MongoDB versions >= 3.2 and is ignored for previous server versions. The default value is // false. See https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about document // validation. BypassDocumentValidation bool // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime is // ignored if Timeout is set on the client. MaxTime time.Duration // A document describing which fields will be included in the document returned by the operation. The default value // is nil, which means all fields will be included. Projection interface{} // Specifies whether the original or replaced document should be returned by the operation. The default value is // Before, which means the original document will be returned before the replacement is performed. ReturnDocument ReturnDocument // A document specifying which document should be updated if the filter used by the operation matches multiple // documents in the collection. If set, the first document in the sorted order will be updated. The driver will // return an error if the sort parameter is a multi-key map. The default value is nil. Sort interface{} // If true, a new document will be inserted if the filter does not match any documents in the collection. The // default value is false. Upsert bool // The index to use for the operation. This should either be the index name as a string or the index specification // as a document. This option is only valid for MongoDB versions >= 4.4. MongoDB version 4.2 will report an error if // this option is specified. For server versions < 4.2, the driver will return an error if this option is specified. // The driver will return an error if this option is used with during an unacknowledged write operation. The driver // will return an error if the hint parameter is a multi-key map. The default value is nil, which means that no hint // will be sent. Hint interface{} // Specifies parameters for the find one and update expression. This option is only valid for MongoDB versions >= 5.0. Older // servers will report an error for using this option. This must be a document mapping parameter names to values. // Values must be constant or closed expressions that do not reference document fields. Parameters can then be // accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} } // FindOneAndUpdate creates a new FindOneAndUpdateOptions instance. func FindOneAndUpdate() FindOneAndUpdateOptions { return &FindOneAndUpdateOptions{} } // SetBypassDocumentValidation sets the value for the BypassDocumentValidation field. func (f FindOneAndUpdateOptions) SetBypassDocumentValidation(b bool) FindOneAndUpdateOptions { f.BypassDocumentValidation = &b return f } // SetArrayFilters sets the value for the ArrayFilters field. func (f FindOneAndUpdateOptions) SetArrayFilters(filters ArrayFilters) FindOneAndUpdateOptions { f.ArrayFilters = &filters return f } // SetCollation sets the value for the Collation field. func (f FindOneAndUpdateOptions) SetCollation(collation Collation) FindOneAndUpdateOptions { f.Collation = collation return f } // SetComment sets the value for the Comment field. func (f FindOneAndUpdateOptions) SetComment(comment interface{}) FindOneAndUpdateOptions { f.Comment = comment return f } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (f FindOneAndUpdateOptions) SetMaxTime(d time.Duration) FindOneAndUpdateOptions { f.MaxTime = &d return f } // SetProjection sets the value for the Projection field. func (f FindOneAndUpdateOptions) SetProjection(projection interface{}) FindOneAndUpdateOptions { f.Projection = projection return f } // SetReturnDocument sets the value for the ReturnDocument field. func (f FindOneAndUpdateOptions) SetReturnDocument(rd ReturnDocument) FindOneAndUpdateOptions { f.ReturnDocument = &rd return f } // SetSort sets the value for the Sort field. func (f FindOneAndUpdateOptions) SetSort(sort interface{}) FindOneAndUpdateOptions { f.Sort = sort return f } // SetUpsert sets the value for the Upsert field. func (f FindOneAndUpdateOptions) SetUpsert(b bool) FindOneAndUpdateOptions { f.Upsert = &b return f } // SetHint sets the value for the Hint field. func (f FindOneAndUpdateOptions) SetHint(hint interface{}) FindOneAndUpdateOptions { f.Hint = hint return f } // SetLet sets the value for the Let field. func (f FindOneAndUpdateOptions) SetLet(let interface{}) FindOneAndUpdateOptions { f.Let = let return f } // MergeFindOneAndUpdateOptions combines the given FindOneAndUpdateOptions instances into a single // FindOneAndUpdateOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeFindOneAndUpdateOptions(opts ...FindOneAndUpdateOptions) FindOneAndUpdateOptions { fo := FindOneAndUpdate() for _, opt := range opts { if opt == nil { continue } if opt.ArrayFilters != nil { fo.ArrayFilters = opt.ArrayFilters } if opt.BypassDocumentValidation != nil { fo.BypassDocumentValidation = opt.BypassDocumentValidation } if opt.Collation != nil { fo.Collation = opt.Collation } if opt.Comment != nil { fo.Comment = opt.Comment } if opt.MaxTime != nil { fo.MaxTime = opt.MaxTime } if opt.Projection != nil { fo.Projection = opt.Projection } if opt.ReturnDocument != nil { fo.ReturnDocument = opt.ReturnDocument } if opt.Sort != nil { fo.Sort = opt.Sort } if opt.Upsert != nil { fo.Upsert = opt.Upsert } if opt.Hint != nil { fo.Hint = opt.Hint } if opt.Let != nil { fo.Let = opt.Let } } return fo } // FindOneAndDeleteOptions represents options that can be used to configure a FindOneAndDelete operation. type FindOneAndDeleteOptions struct { // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration // A document describing which fields will be included in the document returned by the operation. The default value // is nil, which means all fields will be included. Projection interface{} // A document specifying which document should be replaced if the filter used by the operation matches multiple // documents in the collection. If set, the first document in the sorted order will be selected for replacement. // The driver will return an error if the sort parameter is a multi-key map. The default value is nil. Sort interface{} // The index to use for the operation. This should either be the index name as a string or the index specification // as a document. This option is only valid for MongoDB versions >= 4.4. MongoDB version 4.2 will report an error if // this option is specified. For server versions < 4.2, the driver will return an error if this option is specified. // The driver will return an error if this option is used with during an unacknowledged write operation. The driver // will return an error if the hint parameter is a multi-key map. The default value is nil, which means that no hint // will be sent. Hint interface{} // Specifies parameters for the find one and delete expression. This option is only valid for MongoDB versions >= 5.0. Older // servers will report an error for using this option. This must be a document mapping parameter names to values. // Values must be constant or closed expressions that do not reference document fields. Parameters can then be // accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} } // FindOneAndDelete creates a new FindOneAndDeleteOptions instance. func FindOneAndDelete() FindOneAndDeleteOptions { return &FindOneAndDeleteOptions{} } // SetCollation sets the value for the Collation field. func (f FindOneAndDeleteOptions) SetCollation(collation Collation) FindOneAndDeleteOptions { f.Collation = collation return f } // SetComment sets the value for the Comment field. func (f FindOneAndDeleteOptions) SetComment(comment interface{}) FindOneAndDeleteOptions { f.Comment = comment return f } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (f FindOneAndDeleteOptions) SetMaxTime(d time.Duration) FindOneAndDeleteOptions { f.MaxTime = &d return f } // SetProjection sets the value for the Projection field. func (f FindOneAndDeleteOptions) SetProjection(projection interface{}) FindOneAndDeleteOptions { f.Projection = projection return f } // SetSort sets the value for the Sort field. func (f FindOneAndDeleteOptions) SetSort(sort interface{}) FindOneAndDeleteOptions { f.Sort = sort return f } // SetHint sets the value for the Hint field. func (f FindOneAndDeleteOptions) SetHint(hint interface{}) FindOneAndDeleteOptions { f.Hint = hint return f } // SetLet sets the value for the Let field. func (f FindOneAndDeleteOptions) SetLet(let interface{}) FindOneAndDeleteOptions { f.Let = let return f } // MergeFindOneAndDeleteOptions combines the given FindOneAndDeleteOptions instances into a single // FindOneAndDeleteOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeFindOneAndDeleteOptions(opts ...FindOneAndDeleteOptions) *FindOneAndDeleteOptions { fo := FindOneAndDelete() for _, opt := range opts { if opt == nil { continue } if opt.Collation != nil { fo.Collation = opt.Collation } if opt.Comment != nil { fo.Comment = opt.Comment } if opt.MaxTime != nil { fo.MaxTime = opt.MaxTime } if opt.Projection != nil { fo.Projection = opt.Projection } if opt.Sort != nil { fo.Sort = opt.Sort } if opt.Hint != nil { fo.Hint = opt.Hint } if opt.Let != nil { fo.Let = opt.Let } } return fo }	40.17 KB	2025-05-25 12:27
📄 gridfsoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" ) // DefaultName is the default name for a GridFS bucket. var DefaultName = "fs" // DefaultChunkSize is the default size of each file chunk in bytes (255 KiB). var DefaultChunkSize int32 = 255 * 1024 // DefaultRevision is the default revision number for a download by name operation. var DefaultRevision int32 = -1 // BucketOptions represents options that can be used to configure GridFS bucket. type BucketOptions struct { // The name of the bucket. The default value is "fs". Name string // The number of bytes in each chunk in the bucket. The default value is 255 KiB. ChunkSizeBytes int32 // The write concern for the bucket. The default value is the write concern of the database from which the bucket // is created. WriteConcern writeconcern.WriteConcern // The read concern for the bucket. The default value is the read concern of the database from which the bucket // is created. ReadConcern readconcern.ReadConcern // The read preference for the bucket. The default value is the read preference of the database from which the // bucket is created. ReadPreference readpref.ReadPref } // GridFSBucket creates a new BucketOptions instance. func GridFSBucket() BucketOptions { return &BucketOptions{ Name: &DefaultName, ChunkSizeBytes: &DefaultChunkSize, } } // SetName sets the value for the Name field. func (b BucketOptions) SetName(name string) BucketOptions { b.Name = &name return b } // SetChunkSizeBytes sets the value for the ChunkSize field. func (b BucketOptions) SetChunkSizeBytes(i int32) BucketOptions { b.ChunkSizeBytes = &i return b } // SetWriteConcern sets the value for the WriteConcern field. func (b BucketOptions) SetWriteConcern(wc writeconcern.WriteConcern) BucketOptions { b.WriteConcern = wc return b } // SetReadConcern sets the value for the ReadConcern field. func (b BucketOptions) SetReadConcern(rc readconcern.ReadConcern) BucketOptions { b.ReadConcern = rc return b } // SetReadPreference sets the value for the ReadPreference field. func (b BucketOptions) SetReadPreference(rp readpref.ReadPref) BucketOptions { b.ReadPreference = rp return b } // MergeBucketOptions combines the given BucketOptions instances into a single BucketOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeBucketOptions(opts ...BucketOptions) BucketOptions { b := GridFSBucket() for _, opt := range opts { if opt == nil { continue } if opt.Name != nil { b.Name = opt.Name } if opt.ChunkSizeBytes != nil { b.ChunkSizeBytes = opt.ChunkSizeBytes } if opt.WriteConcern != nil { b.WriteConcern = opt.WriteConcern } if opt.ReadConcern != nil { b.ReadConcern = opt.ReadConcern } if opt.ReadPreference != nil { b.ReadPreference = opt.ReadPreference } } return b } // UploadOptions represents options that can be used to configure a GridFS upload operation. type UploadOptions struct { // The number of bytes in each chunk in the bucket. The default value is DefaultChunkSize (255 KiB). ChunkSizeBytes int32 // Additional application data that will be stored in the "metadata" field of the document in the files collection. // The default value is nil, which means that the document in the files collection will not contain a "metadata" // field. Metadata interface{} // The BSON registry to use for converting filters to BSON documents. The default value is bson.DefaultRegistry. Registry bsoncodec.Registry } // GridFSUpload creates a new UploadOptions instance. func GridFSUpload() UploadOptions { return &UploadOptions{Registry: bson.DefaultRegistry} } // SetChunkSizeBytes sets the value for the ChunkSize field. func (u UploadOptions) SetChunkSizeBytes(i int32) UploadOptions { u.ChunkSizeBytes = &i return u } // SetMetadata sets the value for the Metadata field. func (u UploadOptions) SetMetadata(doc interface{}) UploadOptions { u.Metadata = doc return u } // MergeUploadOptions combines the given UploadOptions instances into a single UploadOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeUploadOptions(opts ...UploadOptions) UploadOptions { u := GridFSUpload() for _, opt := range opts { if opt == nil { continue } if opt.ChunkSizeBytes != nil { u.ChunkSizeBytes = opt.ChunkSizeBytes } if opt.Metadata != nil { u.Metadata = opt.Metadata } if opt.Registry != nil { u.Registry = opt.Registry } } return u } // NameOptions represents options that can be used to configure a GridFS DownloadByName operation. type NameOptions struct { // Specifies the revision of the file to retrieve. Revision numbers are defined as follows: // // * 0 = the original stored file // * 1 = the first revision // * 2 = the second revision // * etc.. // * -2 = the second most recent revision // * -1 = the most recent revision. // // The default value is -1 Revision int32 } // GridFSName creates a new NameOptions instance. func GridFSName() NameOptions { return &NameOptions{} } // SetRevision sets the value for the Revision field. func (n NameOptions) SetRevision(r int32) NameOptions { n.Revision = &r return n } // MergeNameOptions combines the given NameOptions instances into a single NameOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeNameOptions(opts ...NameOptions) NameOptions { n := GridFSName() n.Revision = &DefaultRevision for _, opt := range opts { if opt == nil { continue } if opt.Revision != nil { n.Revision = opt.Revision } } return n } // GridFSFindOptions represents options that can be used to configure a GridFS Find operation. type GridFSFindOptions struct { // If true, the server can write temporary data to disk while executing the find operation. The default value // is false. This option is only valid for MongoDB versions >= 4.4. For previous server versions, the server will // return an error if this option is used. AllowDiskUse bool // The maximum number of documents to be included in each batch returned by the server. BatchSize int32 // The maximum number of documents to return. The default value is 0, which means that all documents matching the // filter will be returned. A negative limit specifies that the resulting documents should be returned in a single // batch. The default value is 0. Limit int32 // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration // If true, the cursor created by the operation will not timeout after a period of inactivity. The default value // is false. NoCursorTimeout bool // The number of documents to skip before adding documents to the result. The default value is 0. Skip int32 // A document specifying the order in which documents should be returned. The driver will return an error if the // sort parameter is a multi-key map. Sort interface{} } // GridFSFind creates a new GridFSFindOptions instance. func GridFSFind() GridFSFindOptions { return &GridFSFindOptions{} } // SetAllowDiskUse sets the value for the AllowDiskUse field. func (f GridFSFindOptions) SetAllowDiskUse(b bool) GridFSFindOptions { f.AllowDiskUse = &b return f } // SetBatchSize sets the value for the BatchSize field. func (f GridFSFindOptions) SetBatchSize(i int32) GridFSFindOptions { f.BatchSize = &i return f } // SetLimit sets the value for the Limit field. func (f GridFSFindOptions) SetLimit(i int32) GridFSFindOptions { f.Limit = &i return f } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (f GridFSFindOptions) SetMaxTime(d time.Duration) GridFSFindOptions { f.MaxTime = &d return f } // SetNoCursorTimeout sets the value for the NoCursorTimeout field. func (f GridFSFindOptions) SetNoCursorTimeout(b bool) GridFSFindOptions { f.NoCursorTimeout = &b return f } // SetSkip sets the value for the Skip field. func (f GridFSFindOptions) SetSkip(i int32) GridFSFindOptions { f.Skip = &i return f } // SetSort sets the value for the Sort field. func (f GridFSFindOptions) SetSort(sort interface{}) GridFSFindOptions { f.Sort = sort return f } // MergeGridFSFindOptions combines the given GridFSFindOptions instances into a single GridFSFindOptions in a // last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeGridFSFindOptions(opts ...GridFSFindOptions) GridFSFindOptions { fo := GridFSFind() for _, opt := range opts { if opt == nil { continue } if opt.AllowDiskUse != nil { fo.AllowDiskUse = opt.AllowDiskUse } if opt.BatchSize != nil { fo.BatchSize = opt.BatchSize } if opt.Limit != nil { fo.Limit = opt.Limit } if opt.MaxTime != nil { fo.MaxTime = opt.MaxTime } if opt.NoCursorTimeout != nil { fo.NoCursorTimeout = opt.NoCursorTimeout } if opt.Skip != nil { fo.Skip = opt.Skip } if opt.Sort != nil { fo.Sort = opt.Sort } } return fo }	10.26 KB	2025-05-25 12:27
📄 indexoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "time" ) // CreateIndexesOptions represents options that can be used to configure IndexView.CreateOne and IndexView.CreateMany // operations. type CreateIndexesOptions struct { // The number of data-bearing members of a replica set, including the primary, that must complete the index builds // successfully before the primary marks the indexes as ready. This should either be a string or int32 value. The // semantics of the values are as follows: // // 1. String: specifies a tag. All members with that tag must complete the build. // 2. int: the number of members that must complete the build. // 3. "majority": A special value to indicate that more than half the nodes must complete the build. // 4. "votingMembers": A special value to indicate that all voting data-bearing nodes must complete. // // This option is only available on MongoDB versions >= 4.4. A client-side error will be returned if the option // is specified for MongoDB versions <= 4.2. The default value is nil, meaning that the server-side default will be // used. See dochub.mongodb.org/core/index-commit-quorum for more information. CommitQuorum interface{} // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration } // CreateIndexes creates a new CreateIndexesOptions instance. func CreateIndexes() CreateIndexesOptions { return &CreateIndexesOptions{} } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (c CreateIndexesOptions) SetMaxTime(d time.Duration) CreateIndexesOptions { c.MaxTime = &d return c } // SetCommitQuorumInt sets the value for the CommitQuorum field as an int32. func (c CreateIndexesOptions) SetCommitQuorumInt(quorum int32) CreateIndexesOptions { c.CommitQuorum = quorum return c } // SetCommitQuorumString sets the value for the CommitQuorum field as a string. func (c CreateIndexesOptions) SetCommitQuorumString(quorum string) CreateIndexesOptions { c.CommitQuorum = quorum return c } // SetCommitQuorumMajority sets the value for the CommitQuorum to special "majority" value. func (c CreateIndexesOptions) SetCommitQuorumMajority() CreateIndexesOptions { c.CommitQuorum = "majority" return c } // SetCommitQuorumVotingMembers sets the value for the CommitQuorum to special "votingMembers" value. func (c CreateIndexesOptions) SetCommitQuorumVotingMembers() CreateIndexesOptions { c.CommitQuorum = "votingMembers" return c } // MergeCreateIndexesOptions combines the given CreateIndexesOptions into a single CreateIndexesOptions in a last one // wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeCreateIndexesOptions(opts ...CreateIndexesOptions) CreateIndexesOptions { c := CreateIndexes() for _, opt := range opts { if opt == nil { continue } if opt.MaxTime != nil { c.MaxTime = opt.MaxTime } if opt.CommitQuorum != nil { c.CommitQuorum = opt.CommitQuorum } } return c } // DropIndexesOptions represents options that can be used to configure IndexView.DropOne and IndexView.DropAll // operations. type DropIndexesOptions struct { // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration } // DropIndexes creates a new DropIndexesOptions instance. func DropIndexes() DropIndexesOptions { return &DropIndexesOptions{} } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (d DropIndexesOptions) SetMaxTime(duration time.Duration) DropIndexesOptions { d.MaxTime = &duration return d } // MergeDropIndexesOptions combines the given DropIndexesOptions into a single DropIndexesOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeDropIndexesOptions(opts ...DropIndexesOptions) DropIndexesOptions { c := DropIndexes() for _, opt := range opts { if opt == nil { continue } if opt.MaxTime != nil { c.MaxTime = opt.MaxTime } } return c } // ListIndexesOptions represents options that can be used to configure an IndexView.List operation. type ListIndexesOptions struct { // The maximum number of documents to be included in each batch returned by the server. BatchSize int32 // The maximum amount of time that the query can run on the server. The default value is nil, meaning that there // is no time limit for query execution. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout option may be used // in its place to control the amount of time that a single operation can run before returning an error. MaxTime // is ignored if Timeout is set on the client. MaxTime time.Duration } // ListIndexes creates a new ListIndexesOptions instance. func ListIndexes() ListIndexesOptions { return &ListIndexesOptions{} } // SetBatchSize sets the value for the BatchSize field. func (l ListIndexesOptions) SetBatchSize(i int32) ListIndexesOptions { l.BatchSize = &i return l } // SetMaxTime sets the value for the MaxTime field. // // NOTE(benjirewis): MaxTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can // run before returning an error. MaxTime is ignored if Timeout is set on the client. func (l ListIndexesOptions) SetMaxTime(d time.Duration) ListIndexesOptions { l.MaxTime = &d return l } // MergeListIndexesOptions combines the given ListIndexesOptions instances into a single ListIndexesOptions in a // last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeListIndexesOptions(opts ...ListIndexesOptions) ListIndexesOptions { c := ListIndexes() for _, opt := range opts { if opt == nil { continue } if opt.BatchSize != nil { c.BatchSize = opt.BatchSize } if opt.MaxTime != nil { c.MaxTime = opt.MaxTime } } return c } // IndexOptions represents options that can be used to configure a new index created through the IndexView.CreateOne // or IndexView.CreateMany operations. type IndexOptions struct { // If true, the index will be built in the background on the server and will not block other tasks. The default // value is false. // // Deprecated: This option has been deprecated in MongoDB version 4.2. Background bool // The length of time, in seconds, for documents to remain in the collection. The default value is 0, which means // that documents will remain in the collection until they're explicitly deleted or the collection is dropped. ExpireAfterSeconds int32 // The name of the index. The default value is "[field1]_[direction1]_[field2]_[direction2]...". For example, an // index with the specification {name: 1, age: -1} will be named "name_1_age_-1". Name string // If true, the index will only reference documents that contain the fields specified in the index. The default is // false. Sparse bool // Specifies the storage engine to use for the index. The value must be a document in the form // {<storage engine name>: <options>}. The default value is nil, which means that the default storage engine // will be used. This option is only applicable for MongoDB versions >= 3.0 and is ignored for previous server // versions. StorageEngine interface{} // If true, the collection will not accept insertion or update of documents where the index key value matches an // existing value in the index. The default is false. Unique bool // The index version number, either 0 or 1. Version int32 // The language that determines the list of stop words and the rules for the stemmer and tokenizer. This option // is only applicable for text indexes and is ignored for other index types. The default value is "english". DefaultLanguage string // The name of the field in the collection's documents that contains the override language for the document. This // option is only applicable for text indexes and is ignored for other index types. The default value is the value // of the DefaultLanguage option. LanguageOverride string // The index version number for a text index. See https://www.mongodb.com/docs/manual/core/index-text/#text-versions for // information about different version numbers. TextVersion int32 // A document that contains field and weight pairs. The weight is an integer ranging from 1 to 99,999, inclusive, // indicating the significance of the field relative to the other indexed fields in terms of the score. This option // is only applicable for text indexes and is ignored for other index types. The default value is nil, which means // that every field will have a weight of 1. Weights interface{} // The index version number for a 2D sphere index. See https://www.mongodb.com/docs/manual/core/2dsphere/#dsphere-v2 for // information about different version numbers. SphereVersion int32 // The precision of the stored geohash value of the location data. This option only applies to 2D indexes and is // ignored for other index types. The value must be between 1 and 32, inclusive. The default value is 26. Bits int32 // The upper inclusive boundary for longitude and latitude values. This option is only applicable to 2D indexes and // is ignored for other index types. The default value is 180.0. Max float64 // The lower inclusive boundary for longitude and latitude values. This option is only applicable to 2D indexes and // is ignored for other index types. The default value is -180.0. Min float64 // The number of units within which to group location values. Location values that are within BucketSize units of // each other will be grouped in the same bucket. This option is only applicable to geoHaystack indexes and is // ignored for other index types. The value must be greater than 0. BucketSize int32 // A document that defines which collection documents the index should reference. This option is only valid for // MongoDB versions >= 3.2 and is ignored for previous server versions. PartialFilterExpression interface{} // The collation to use for string comparisons for the index. This option is only valid for MongoDB versions >= 3.4. // For previous server versions, the driver will return an error if this option is used. Collation Collation // A document that defines the wildcard projection for the index. WildcardProjection interface{} // If true, the index will exist on the target collection but will not be used by the query planner when executing // operations. This option is only valid for MongoDB versions >= 4.4. The default value is false. Hidden bool } // Index creates a new IndexOptions instance. func Index() IndexOptions { return &IndexOptions{} } // SetBackground sets value for the Background field. // // Deprecated: This option has been deprecated in MongoDB version 4.2. func (i IndexOptions) SetBackground(background bool) IndexOptions { i.Background = &background return i } // SetExpireAfterSeconds sets value for the ExpireAfterSeconds field. func (i IndexOptions) SetExpireAfterSeconds(seconds int32) IndexOptions { i.ExpireAfterSeconds = &seconds return i } // SetName sets the value for the Name field. func (i IndexOptions) SetName(name string) IndexOptions { i.Name = &name return i } // SetSparse sets the value of the Sparse field. func (i IndexOptions) SetSparse(sparse bool) IndexOptions { i.Sparse = &sparse return i } // SetStorageEngine sets the value for the StorageEngine field. func (i IndexOptions) SetStorageEngine(engine interface{}) IndexOptions { i.StorageEngine = engine return i } // SetUnique sets the value for the Unique field. func (i IndexOptions) SetUnique(unique bool) IndexOptions { i.Unique = &unique return i } // SetVersion sets the value for the Version field. func (i IndexOptions) SetVersion(version int32) IndexOptions { i.Version = &version return i } // SetDefaultLanguage sets the value for the DefaultLanguage field. func (i IndexOptions) SetDefaultLanguage(language string) IndexOptions { i.DefaultLanguage = &language return i } // SetLanguageOverride sets the value of the LanguageOverride field. func (i IndexOptions) SetLanguageOverride(override string) IndexOptions { i.LanguageOverride = &override return i } // SetTextVersion sets the value for the TextVersion field. func (i IndexOptions) SetTextVersion(version int32) IndexOptions { i.TextVersion = &version return i } // SetWeights sets the value for the Weights field. func (i IndexOptions) SetWeights(weights interface{}) IndexOptions { i.Weights = weights return i } // SetSphereVersion sets the value for the SphereVersion field. func (i IndexOptions) SetSphereVersion(version int32) IndexOptions { i.SphereVersion = &version return i } // SetBits sets the value for the Bits field. func (i IndexOptions) SetBits(bits int32) IndexOptions { i.Bits = &bits return i } // SetMax sets the value for the Max field. func (i IndexOptions) SetMax(max float64) IndexOptions { i.Max = &max return i } // SetMin sets the value for the Min field. func (i IndexOptions) SetMin(min float64) IndexOptions { i.Min = &min return i } // SetBucketSize sets the value for the BucketSize field func (i IndexOptions) SetBucketSize(bucketSize int32) IndexOptions { i.BucketSize = &bucketSize return i } // SetPartialFilterExpression sets the value for the PartialFilterExpression field. func (i IndexOptions) SetPartialFilterExpression(expression interface{}) IndexOptions { i.PartialFilterExpression = expression return i } // SetCollation sets the value for the Collation field. func (i IndexOptions) SetCollation(collation Collation) IndexOptions { i.Collation = collation return i } // SetWildcardProjection sets the value for the WildcardProjection field. func (i IndexOptions) SetWildcardProjection(wildcardProjection interface{}) IndexOptions { i.WildcardProjection = wildcardProjection return i } // SetHidden sets the value for the Hidden field. func (i IndexOptions) SetHidden(hidden bool) IndexOptions { i.Hidden = &hidden return i } // MergeIndexOptions combines the given IndexOptions into a single IndexOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeIndexOptions(opts ...IndexOptions) IndexOptions { i := Index() for _, opt := range opts { if opt == nil { continue } if opt.Background != nil { i.Background = opt.Background } if opt.ExpireAfterSeconds != nil { i.ExpireAfterSeconds = opt.ExpireAfterSeconds } if opt.Name != nil { i.Name = opt.Name } if opt.Sparse != nil { i.Sparse = opt.Sparse } if opt.StorageEngine != nil { i.StorageEngine = opt.StorageEngine } if opt.Unique != nil { i.Unique = opt.Unique } if opt.Version != nil { i.Version = opt.Version } if opt.DefaultLanguage != nil { i.DefaultLanguage = opt.DefaultLanguage } if opt.LanguageOverride != nil { i.LanguageOverride = opt.LanguageOverride } if opt.TextVersion != nil { i.TextVersion = opt.TextVersion } if opt.Weights != nil { i.Weights = opt.Weights } if opt.SphereVersion != nil { i.SphereVersion = opt.SphereVersion } if opt.Bits != nil { i.Bits = opt.Bits } if opt.Max != nil { i.Max = opt.Max } if opt.Min != nil { i.Min = opt.Min } if opt.BucketSize != nil { i.BucketSize = opt.BucketSize } if opt.PartialFilterExpression != nil { i.PartialFilterExpression = opt.PartialFilterExpression } if opt.Collation != nil { i.Collation = opt.Collation } if opt.WildcardProjection != nil { i.WildcardProjection = opt.WildcardProjection } if opt.Hidden != nil { i.Hidden = opt.Hidden } } return i }	17.17 KB	2025-05-25 12:27
📄 insertoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // InsertOneOptions represents options that can be used to configure an InsertOne operation. type InsertOneOptions struct { // If true, writes executed as part of the operation will opt out of document-level validation on the server. This // option is valid for MongoDB versions >= 3.2 and is ignored for previous server versions. The default value is // false. See https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about document // validation. BypassDocumentValidation bool // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} } // InsertOne creates a new InsertOneOptions instance. func InsertOne() InsertOneOptions { return &InsertOneOptions{} } // SetBypassDocumentValidation sets the value for the BypassDocumentValidation field. func (ioo InsertOneOptions) SetBypassDocumentValidation(b bool) InsertOneOptions { ioo.BypassDocumentValidation = &b return ioo } // SetComment sets the value for the Comment field. func (ioo InsertOneOptions) SetComment(comment interface{}) InsertOneOptions { ioo.Comment = comment return ioo } // MergeInsertOneOptions combines the given InsertOneOptions instances into a single InsertOneOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeInsertOneOptions(opts ...InsertOneOptions) InsertOneOptions { ioOpts := InsertOne() for _, ioo := range opts { if ioo == nil { continue } if ioo.BypassDocumentValidation != nil { ioOpts.BypassDocumentValidation = ioo.BypassDocumentValidation } if ioo.Comment != nil { ioOpts.Comment = ioo.Comment } } return ioOpts } // InsertManyOptions represents options that can be used to configure an InsertMany operation. type InsertManyOptions struct { // If true, writes executed as part of the operation will opt out of document-level validation on the server. This // option is valid for MongoDB versions >= 3.2 and is ignored for previous server versions. The default value is // false. See https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about document // validation. BypassDocumentValidation bool // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // If true, no writes will be executed after one fails. The default value is true. Ordered bool } // InsertMany creates a new InsertManyOptions instance. func InsertMany() InsertManyOptions { return &InsertManyOptions{ Ordered: &DefaultOrdered, } } // SetBypassDocumentValidation sets the value for the BypassDocumentValidation field. func (imo InsertManyOptions) SetBypassDocumentValidation(b bool) InsertManyOptions { imo.BypassDocumentValidation = &b return imo } // SetComment sets the value for the Comment field. func (imo InsertManyOptions) SetComment(comment interface{}) InsertManyOptions { imo.Comment = comment return imo } // SetOrdered sets the value for the Ordered field. func (imo InsertManyOptions) SetOrdered(b bool) InsertManyOptions { imo.Ordered = &b return imo } // MergeInsertManyOptions combines the given InsertManyOptions instances into a single InsertManyOptions in a last one // wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeInsertManyOptions(opts ...InsertManyOptions) *InsertManyOptions { imOpts := InsertMany() for _, imo := range opts { if imo == nil { continue } if imo.BypassDocumentValidation != nil { imOpts.BypassDocumentValidation = imo.BypassDocumentValidation } if imo.Comment != nil { imOpts.Comment = imo.Comment } if imo.Ordered != nil { imOpts.Ordered = imo.Ordered } } return imOpts }	4.34 KB	2025-05-25 12:27
📄 listcollectionsoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // ListCollectionsOptions represents options that can be used to configure a ListCollections operation. type ListCollectionsOptions struct { // If true, each collection document will only contain a field for the collection name. The default value is false. NameOnly bool // The maximum number of documents to be included in each batch returned by the server. BatchSize int32 // If true, and NameOnly is true, limits the documents returned to only contain collections the user is authorized to use. The default value // is false. This option is only valid for MongoDB server versions >= 4.0. Server versions < 4.0 ignore this option. AuthorizedCollections bool } // ListCollections creates a new ListCollectionsOptions instance. func ListCollections() ListCollectionsOptions { return &ListCollectionsOptions{} } // SetNameOnly sets the value for the NameOnly field. func (lc ListCollectionsOptions) SetNameOnly(b bool) ListCollectionsOptions { lc.NameOnly = &b return lc } // SetBatchSize sets the value for the BatchSize field. func (lc ListCollectionsOptions) SetBatchSize(size int32) ListCollectionsOptions { lc.BatchSize = &size return lc } // SetAuthorizedCollections sets the value for the AuthorizedCollections field. This option is only valid for MongoDB server versions >= 4.0. Server // versions < 4.0 ignore this option. func (lc ListCollectionsOptions) SetAuthorizedCollections(b bool) ListCollectionsOptions { lc.AuthorizedCollections = &b return lc } // MergeListCollectionsOptions combines the given ListCollectionsOptions instances into a single ListCollectionsOptions // in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeListCollectionsOptions(opts ...ListCollectionsOptions) *ListCollectionsOptions { lc := ListCollections() for _, opt := range opts { if opt == nil { continue } if opt.NameOnly != nil { lc.NameOnly = opt.NameOnly } if opt.BatchSize != nil { lc.BatchSize = opt.BatchSize } if opt.AuthorizedCollections != nil { lc.AuthorizedCollections = opt.AuthorizedCollections } } return lc }	2.43 KB	2025-05-25 12:27
📄 listdatabasesoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // ListDatabasesOptions represents options that can be used to configure a ListDatabases operation. type ListDatabasesOptions struct { // If true, only the Name field of the returned DatabaseSpecification objects will be populated. The default value // is false. NameOnly bool // If true, only the databases which the user is authorized to see will be returned. For more information about // the behavior of this option, see https://www.mongodb.com/docs/manual/reference/privilege-actions/#find. The default // value is true. AuthorizedDatabases bool } // ListDatabases creates a new ListDatabasesOptions instance. func ListDatabases() ListDatabasesOptions { return &ListDatabasesOptions{} } // SetNameOnly sets the value for the NameOnly field. func (ld ListDatabasesOptions) SetNameOnly(b bool) ListDatabasesOptions { ld.NameOnly = &b return ld } // SetAuthorizedDatabases sets the value for the AuthorizedDatabases field. func (ld ListDatabasesOptions) SetAuthorizedDatabases(b bool) ListDatabasesOptions { ld.AuthorizedDatabases = &b return ld } // MergeListDatabasesOptions combines the given ListDatabasesOptions instances into a single ListDatabasesOptions in a // last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeListDatabasesOptions(opts ...ListDatabasesOptions) ListDatabasesOptions { ld := ListDatabases() for _, opt := range opts { if opt == nil { continue } if opt.NameOnly != nil { ld.NameOnly = opt.NameOnly } if opt.AuthorizedDatabases != nil { ld.AuthorizedDatabases = opt.AuthorizedDatabases } } return ld }	1.94 KB	2025-05-25 12:27
📄 loggeroptions.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "go.mongodb.org/mongo-driver/internal/logger" ) // LogLevel is an enumeration representing the supported log severity levels. type LogLevel int const ( // LogLevelInfo enables logging of informational messages. These logs // are high-level information about normal driver behavior. LogLevelInfo LogLevel = LogLevel(logger.LevelInfo) // LogLevelDebug enables logging of debug messages. These logs can be // voluminous and are intended for detailed information that may be // helpful when debugging an application. LogLevelDebug LogLevel = LogLevel(logger.LevelDebug) ) // LogComponent is an enumeration representing the "components" which can be // logged against. A LogLevel can be configured on a per-component basis. type LogComponent int const ( // LogComponentAll enables logging for all components. LogComponentAll LogComponent = LogComponent(logger.ComponentAll) // LogComponentCommand enables command monitor logging. LogComponentCommand LogComponent = LogComponent(logger.ComponentCommand) // LogComponentTopology enables topology logging. LogComponentTopology LogComponent = LogComponent(logger.ComponentTopology) // LogComponentServerSelection enables server selection logging. LogComponentServerSelection LogComponent = LogComponent(logger.ComponentServerSelection) // LogComponentConnection enables connection services logging. LogComponentConnection LogComponent = LogComponent(logger.ComponentConnection) ) // LogSink is an interface that can be implemented to provide a custom sink for // the driver's logs. type LogSink interface { // Info logs a non-error message with the given key/value pairs. This // method will only be called if the provided level has been defined // for a component in the LoggerOptions. // // Here are the following level mappings for V = "Verbosity": // // - V(0): off // - V(1): informational // - V(2): debugging // // This level mapping is taken from the go-logr/logr library // specifications, specifically: // // "Level V(0) is the default, and logger.V(0).Info() has the same // meaning as logger.Info()." Info(level int, message string, keysAndValues ...interface{}) // Error logs an error message with the given key/value pairs Error(err error, message string, keysAndValues ...interface{}) } // LoggerOptions represent options used to configure Logging in the Go Driver. type LoggerOptions struct { // ComponentLevels is a map of LogComponent to LogLevel. The LogLevel // for a given LogComponent will be used to determine if a log message // should be logged. ComponentLevels map[LogComponent]LogLevel // Sink is the LogSink that will be used to log messages. If this is // nil, the driver will use the standard logging library. Sink LogSink // MaxDocumentLength is the maximum length of a document to be logged. // If the underlying document is larger than this value, it will be // truncated and appended with an ellipses "...". MaxDocumentLength uint } // Logger creates a new LoggerOptions instance. func Logger() LoggerOptions { return &LoggerOptions{ ComponentLevels: map[LogComponent]LogLevel{}, } } // SetComponentLevel sets the LogLevel value for a LogComponent. func (opts LoggerOptions) SetComponentLevel(component LogComponent, level LogLevel) LoggerOptions { opts.ComponentLevels[component] = level return opts } // SetMaxDocumentLength sets the maximum length of a document to be logged. func (opts LoggerOptions) SetMaxDocumentLength(maxDocumentLength uint) LoggerOptions { opts.MaxDocumentLength = maxDocumentLength return opts } // SetSink sets the LogSink to use for logging. func (opts LoggerOptions) SetSink(sink LogSink) *LoggerOptions { opts.Sink = sink return opts }	3.93 KB	2025-05-25 12:27
📄 mongooptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "fmt" "reflect" "strconv" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) // Collation allows users to specify language-specific rules for string comparison, such as // rules for lettercase and accent marks. type Collation struct { Locale string `bson:",omitempty"` // The locale CaseLevel bool `bson:",omitempty"` // The case level CaseFirst string `bson:",omitempty"` // The case ordering Strength int `bson:",omitempty"` // The number of comparison levels to use NumericOrdering bool `bson:",omitempty"` // Whether to order numbers based on numerical order and not collation order Alternate string `bson:",omitempty"` // Whether spaces and punctuation are considered base characters MaxVariable string `bson:",omitempty"` // Which characters are affected by alternate: "shifted" Normalization bool `bson:",omitempty"` // Causes text to be normalized into Unicode NFD Backwards bool `bson:",omitempty"` // Causes secondary differences to be considered in reverse order, as it is done in the French language } // ToDocument converts the Collation to a bson.Raw. // // Deprecated: Marshaling a Collation to BSON will not be supported in Go Driver 2.0. func (co Collation) ToDocument() bson.Raw { idx, doc := bsoncore.AppendDocumentStart(nil) if co.Locale != "" { doc = bsoncore.AppendStringElement(doc, "locale", co.Locale) } if co.CaseLevel { doc = bsoncore.AppendBooleanElement(doc, "caseLevel", true) } if co.CaseFirst != "" { doc = bsoncore.AppendStringElement(doc, "caseFirst", co.CaseFirst) } if co.Strength != 0 { doc = bsoncore.AppendInt32Element(doc, "strength", int32(co.Strength)) } if co.NumericOrdering { doc = bsoncore.AppendBooleanElement(doc, "numericOrdering", true) } if co.Alternate != "" { doc = bsoncore.AppendStringElement(doc, "alternate", co.Alternate) } if co.MaxVariable != "" { doc = bsoncore.AppendStringElement(doc, "maxVariable", co.MaxVariable) } if co.Normalization { doc = bsoncore.AppendBooleanElement(doc, "normalization", true) } if co.Backwards { doc = bsoncore.AppendBooleanElement(doc, "backwards", true) } doc, _ = bsoncore.AppendDocumentEnd(doc, idx) return doc } // CursorType specifies whether a cursor should close when the last data is retrieved. See // NonTailable, Tailable, and TailableAwait. type CursorType int8 const ( // NonTailable specifies that a cursor should close after retrieving the last data. NonTailable CursorType = iota // Tailable specifies that a cursor should not close when the last data is retrieved and can be resumed later. Tailable // TailableAwait specifies that a cursor should not close when the last data is retrieved and // that it should block for a certain amount of time for new data before returning no data. TailableAwait ) // ReturnDocument specifies whether a findAndUpdate operation should return the document as it was // before the update or as it is after the update. type ReturnDocument int8 const ( // Before specifies that findAndUpdate should return the document as it was before the update. Before ReturnDocument = iota // After specifies that findAndUpdate should return the document as it is after the update. After ) // FullDocument specifies how a change stream should return the modified document. type FullDocument string const ( // Default does not include a document copy. Default FullDocument = "default" // Off is the same as sending no value for fullDocumentBeforeChange. Off FullDocument = "off" // Required is the same as WhenAvailable but raises a server-side error if the post-image is not available. Required FullDocument = "required" // UpdateLookup includes a delta describing the changes to the document and a copy of the entire document that // was changed. UpdateLookup FullDocument = "updateLookup" // WhenAvailable includes a post-image of the the modified document for replace and update change events // if the post-image for this event is available. WhenAvailable FullDocument = "whenAvailable" ) // TODO(GODRIVER-2617): Once Registry is removed, ArrayFilters doesn't need to // TODO be a separate type. Remove the type and update all ArrayFilters fields // TODO to be type []interface{}. // ArrayFilters is used to hold filters for the array filters CRUD option. If a registry is nil, bson.DefaultRegistry // will be used when converting the filter interfaces to BSON. type ArrayFilters struct { // Registry is the registry to use for converting filters. Defaults to bson.DefaultRegistry. // // Deprecated: Marshaling ArrayFilters to BSON will not be supported in Go Driver 2.0. Registry bsoncodec.Registry Filters []interface{} // The filters to apply } // ToArray builds a []bson.Raw from the provided ArrayFilters. // // Deprecated: Marshaling ArrayFilters to BSON will not be supported in Go Driver 2.0. func (af ArrayFilters) ToArray() ([]bson.Raw, error) { registry := af.Registry if registry == nil { registry = bson.DefaultRegistry } filters := make([]bson.Raw, 0, len(af.Filters)) for _, f := range af.Filters { filter, err := bson.MarshalWithRegistry(registry, f) if err != nil { return nil, err } filters = append(filters, filter) } return filters, nil } // ToArrayDocument builds a BSON array for the array filters CRUD option. If the registry for af is nil, // bson.DefaultRegistry will be used when converting the filter interfaces to BSON. // // Deprecated: Marshaling ArrayFilters to BSON will not be supported in Go Driver 2.0. func (af ArrayFilters) ToArrayDocument() (bson.Raw, error) { registry := af.Registry if registry == nil { registry = bson.DefaultRegistry } idx, arr := bsoncore.AppendArrayStart(nil) for i, f := range af.Filters { filter, err := bson.MarshalWithRegistry(registry, f) if err != nil { return nil, err } arr = bsoncore.AppendDocumentElement(arr, strconv.Itoa(i), filter) } arr, _ = bsoncore.AppendArrayEnd(arr, idx) return arr, nil } // MarshalError is returned when attempting to transform a value into a document // results in an error. // // Deprecated: MarshalError is unused and will be removed in Go Driver 2.0. type MarshalError struct { Value interface{} Err error } // Error implements the error interface. // // Deprecated: MarshalError is unused and will be removed in Go Driver 2.0. func (me MarshalError) Error() string { return fmt.Sprintf("cannot transform type %s to a bson.Raw", reflect.TypeOf(me.Value)) }	6.71 KB	2025-05-25 12:27
📄 replaceoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // ReplaceOptions represents options that can be used to configure a ReplaceOne operation. type ReplaceOptions struct { // If true, writes executed as part of the operation will opt out of document-level validation on the server. This // option is valid for MongoDB versions >= 3.2 and is ignored for previous server versions. The default value is // false. See https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about document // validation. BypassDocumentValidation bool // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // The index to use for the operation. This should either be the index name as a string or the index specification // as a document. This option is only valid for MongoDB versions >= 4.2. Server versions >= 3.4 will return an error // if this option is specified. For server versions < 3.4, the driver will return a client-side error if this option // is specified. The driver will return an error if this option is specified during an unacknowledged write // operation. The driver will return an error if the hint parameter is a multi-key map. The default value is nil, // which means that no hint will be sent. Hint interface{} // If true, a new document will be inserted if the filter does not match any documents in the collection. The // default value is false. Upsert bool // Specifies parameters for the aggregate expression. This option is only valid for MongoDB versions >= 5.0. Older // servers will report an error for using this option. This must be a document mapping parameter names to values. // Values must be constant or closed expressions that do not reference document fields. Parameters can then be // accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} } // Replace creates a new ReplaceOptions instance. func Replace() ReplaceOptions { return &ReplaceOptions{} } // SetBypassDocumentValidation sets the value for the BypassDocumentValidation field. func (ro ReplaceOptions) SetBypassDocumentValidation(b bool) ReplaceOptions { ro.BypassDocumentValidation = &b return ro } // SetCollation sets the value for the Collation field. func (ro ReplaceOptions) SetCollation(c Collation) ReplaceOptions { ro.Collation = c return ro } // SetComment sets the value for the Comment field. func (ro ReplaceOptions) SetComment(comment interface{}) ReplaceOptions { ro.Comment = comment return ro } // SetHint sets the value for the Hint field. func (ro ReplaceOptions) SetHint(h interface{}) ReplaceOptions { ro.Hint = h return ro } // SetUpsert sets the value for the Upsert field. func (ro ReplaceOptions) SetUpsert(b bool) ReplaceOptions { ro.Upsert = &b return ro } // SetLet sets the value for the Let field. func (ro ReplaceOptions) SetLet(l interface{}) ReplaceOptions { ro.Let = l return ro } // MergeReplaceOptions combines the given ReplaceOptions instances into a single ReplaceOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeReplaceOptions(opts ...ReplaceOptions) *ReplaceOptions { rOpts := Replace() for _, ro := range opts { if ro == nil { continue } if ro.BypassDocumentValidation != nil { rOpts.BypassDocumentValidation = ro.BypassDocumentValidation } if ro.Collation != nil { rOpts.Collation = ro.Collation } if ro.Comment != nil { rOpts.Comment = ro.Comment } if ro.Hint != nil { rOpts.Hint = ro.Hint } if ro.Upsert != nil { rOpts.Upsert = ro.Upsert } if ro.Let != nil { rOpts.Let = ro.Let } } return rOpts }	4.39 KB	2025-05-25 12:27
📄 rewrapdatakeyoptions.go // Copyright (C) MongoDB, Inc. 2022-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // RewrapManyDataKeyOptions represents all possible options used to decrypt and encrypt all matching data keys with a // possibly new masterKey. type RewrapManyDataKeyOptions struct { // Provider identifies the new KMS provider. If omitted, encrypting uses the current KMS provider. Provider string // MasterKey identifies the new masterKey. If omitted, rewraps with the current masterKey. MasterKey interface{} } // RewrapManyDataKey creates a new RewrapManyDataKeyOptions instance. func RewrapManyDataKey() RewrapManyDataKeyOptions { return new(RewrapManyDataKeyOptions) } // SetProvider sets the value for the Provider field. func (rmdko RewrapManyDataKeyOptions) SetProvider(provider string) RewrapManyDataKeyOptions { rmdko.Provider = &provider return rmdko } // SetMasterKey sets the value for the MasterKey field. func (rmdko RewrapManyDataKeyOptions) SetMasterKey(masterKey interface{}) RewrapManyDataKeyOptions { rmdko.MasterKey = masterKey return rmdko } // MergeRewrapManyDataKeyOptions combines the given RewrapManyDataKeyOptions instances into a single // RewrapManyDataKeyOptions in a last one wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeRewrapManyDataKeyOptions(opts ...RewrapManyDataKeyOptions) RewrapManyDataKeyOptions { rmdkOpts := RewrapManyDataKey() for _, rmdko := range opts { if rmdko == nil { continue } if provider := rmdko.Provider; provider != nil { rmdkOpts.Provider = provider } if masterKey := rmdko.MasterKey; masterKey != nil { rmdkOpts.MasterKey = masterKey } } return rmdkOpts }	1.92 KB	2025-05-25 12:27
📄 runcmdoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "go.mongodb.org/mongo-driver/mongo/readpref" ) // RunCmdOptions represents options that can be used to configure a RunCommand operation. type RunCmdOptions struct { // The read preference to use for the operation. The default value is nil, which means that the primary read // preference will be used. ReadPreference readpref.ReadPref } // RunCmd creates a new RunCmdOptions instance. func RunCmd() RunCmdOptions { return &RunCmdOptions{} } // SetReadPreference sets value for the ReadPreference field. func (rc RunCmdOptions) SetReadPreference(rp readpref.ReadPref) RunCmdOptions { rc.ReadPreference = rp return rc } // MergeRunCmdOptions combines the given RunCmdOptions instances into one RunCmdOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeRunCmdOptions(opts ...RunCmdOptions) RunCmdOptions { rc := RunCmd() for _, opt := range opts { if opt == nil { continue } if opt.ReadPreference != nil { rc.ReadPreference = opt.ReadPreference } } return rc }	1.39 KB	2025-05-25 12:27
📄 searchindexoptions.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // SearchIndexesOptions represents options that can be used to configure a SearchIndexView. type SearchIndexesOptions struct { Name string } // SearchIndexes creates a new SearchIndexesOptions instance. func SearchIndexes() SearchIndexesOptions { return &SearchIndexesOptions{} } // SetName sets the value for the Name field. func (sio SearchIndexesOptions) SetName(name string) SearchIndexesOptions { sio.Name = &name return sio } // CreateSearchIndexesOptions represents options that can be used to configure a SearchIndexView.CreateOne or // SearchIndexView.CreateMany operation. type CreateSearchIndexesOptions struct { } // ListSearchIndexesOptions represents options that can be used to configure a SearchIndexView.List operation. type ListSearchIndexesOptions struct { AggregateOpts *AggregateOptions } // DropSearchIndexOptions represents options that can be used to configure a SearchIndexView.DropOne operation. type DropSearchIndexOptions struct { } // UpdateSearchIndexOptions represents options that can be used to configure a SearchIndexView.UpdateOne operation. type UpdateSearchIndexOptions struct { }	1.39 KB	2025-05-25 12:27
📄 serverapioptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "fmt" ) // ServerAPIOptions represents options used to configure the API version sent to the server // when running commands. // // Sending a specified server API version causes the server to behave in a manner compatible with that // API version. It also causes the driver to behave in a manner compatible with the driver’s behavior as // of the release when the driver first started to support the specified server API version. // // The user must specify a ServerAPIVersion if including ServerAPIOptions in their client. That version // must also be currently supported by the driver. This version of the driver supports API version "1". type ServerAPIOptions struct { ServerAPIVersion ServerAPIVersion Strict bool DeprecationErrors bool } // ServerAPI creates a new ServerAPIOptions configured with the provided serverAPIversion. func ServerAPI(serverAPIVersion ServerAPIVersion) ServerAPIOptions { return &ServerAPIOptions{ServerAPIVersion: serverAPIVersion} } // SetStrict specifies whether the server should return errors for features that are not part of the API version. func (s ServerAPIOptions) SetStrict(strict bool) ServerAPIOptions { s.Strict = &strict return s } // SetDeprecationErrors specifies whether the server should return errors for deprecated features. func (s ServerAPIOptions) SetDeprecationErrors(deprecationErrors bool) *ServerAPIOptions { s.DeprecationErrors = &deprecationErrors return s } // ServerAPIVersion represents an API version that can be used in ServerAPIOptions. type ServerAPIVersion string const ( // ServerAPIVersion1 is the first API version. ServerAPIVersion1 ServerAPIVersion = "1" ) // Validate determines if the provided ServerAPIVersion is currently supported by the driver. func (sav ServerAPIVersion) Validate() error { switch sav { case ServerAPIVersion1: return nil } return fmt.Errorf("api version %q not supported; this driver version only supports API version \"1\"", sav) }	2.22 KB	2025-05-25 12:27
📄 sessionoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "time" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" ) // DefaultCausalConsistency is the default value for the CausalConsistency option. var DefaultCausalConsistency = true // SessionOptions represents options that can be used to configure a Session. type SessionOptions struct { // If true, causal consistency will be enabled for the session. This option cannot be set to true if Snapshot is // set to true. The default value is true unless Snapshot is set to true. See // https://www.mongodb.com/docs/manual/core/read-isolation-consistency-recency/#sessions for more information. CausalConsistency bool // The default read concern for transactions started in the session. The default value is nil, which means that // the read concern of the client used to start the session will be used. DefaultReadConcern readconcern.ReadConcern // The default read preference for transactions started in the session. The default value is nil, which means that // the read preference of the client used to start the session will be used. DefaultReadPreference readpref.ReadPref // The default write concern for transactions started in the session. The default value is nil, which means that // the write concern of the client used to start the session will be used. DefaultWriteConcern writeconcern.WriteConcern // The default maximum amount of time that a CommitTransaction operation executed in the session can run on the // server. The default value is nil, which means that that there is no time limit for execution. // // NOTE(benjirewis): DefaultMaxCommitTime will be deprecated in a future release. The more general Timeout option // may be used in its place to control the amount of time that a single operation can run before returning an // error. DefaultMaxCommitTime is ignored if Timeout is set on the client. DefaultMaxCommitTime time.Duration // If true, all read operations performed with this session will be read from the same snapshot. This option cannot // be set to true if CausalConsistency is set to true. Transactions and write operations are not allowed on // snapshot sessions and will error. The default value is false. Snapshot bool } // Session creates a new SessionOptions instance. func Session() SessionOptions { return &SessionOptions{} } // SetCausalConsistency sets the value for the CausalConsistency field. func (s SessionOptions) SetCausalConsistency(b bool) SessionOptions { s.CausalConsistency = &b return s } // SetDefaultReadConcern sets the value for the DefaultReadConcern field. func (s SessionOptions) SetDefaultReadConcern(rc readconcern.ReadConcern) SessionOptions { s.DefaultReadConcern = rc return s } // SetDefaultReadPreference sets the value for the DefaultReadPreference field. func (s SessionOptions) SetDefaultReadPreference(rp readpref.ReadPref) SessionOptions { s.DefaultReadPreference = rp return s } // SetDefaultWriteConcern sets the value for the DefaultWriteConcern field. func (s SessionOptions) SetDefaultWriteConcern(wc writeconcern.WriteConcern) SessionOptions { s.DefaultWriteConcern = wc return s } // SetDefaultMaxCommitTime sets the value for the DefaultMaxCommitTime field. // // NOTE(benjirewis): DefaultMaxCommitTime will be deprecated in a future release. The more // general Timeout option may be used in its place to control the amount of time that a // single operation can run before returning an error. DefaultMaxCommitTime is ignored if // Timeout is set on the client. func (s SessionOptions) SetDefaultMaxCommitTime(mct time.Duration) SessionOptions { s.DefaultMaxCommitTime = mct return s } // SetSnapshot sets the value for the Snapshot field. func (s SessionOptions) SetSnapshot(b bool) SessionOptions { s.Snapshot = &b return s } // MergeSessionOptions combines the given SessionOptions instances into a single SessionOptions in a last-one-wins // fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeSessionOptions(opts ...SessionOptions) SessionOptions { s := Session() for _, opt := range opts { if opt == nil { continue } if opt.CausalConsistency != nil { s.CausalConsistency = opt.CausalConsistency } if opt.DefaultReadConcern != nil { s.DefaultReadConcern = opt.DefaultReadConcern } if opt.DefaultReadPreference != nil { s.DefaultReadPreference = opt.DefaultReadPreference } if opt.DefaultWriteConcern != nil { s.DefaultWriteConcern = opt.DefaultWriteConcern } if opt.DefaultMaxCommitTime != nil { s.DefaultMaxCommitTime = opt.DefaultMaxCommitTime } if opt.Snapshot != nil { s.Snapshot = opt.Snapshot } } if s.CausalConsistency == nil && (s.Snapshot == nil \|\| !s.Snapshot) { s.CausalConsistency = &DefaultCausalConsistency } return s }	5.13 KB	2025-05-25 12:27
📁 testdata	-	2025-05-25 12:27
📄 transactionoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options import ( "time" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" ) // TransactionOptions represents options that can be used to configure a transaction. type TransactionOptions struct { // The read concern for operations in the transaction. The default value is nil, which means that the default // read concern of the session used to start the transaction will be used. ReadConcern readconcern.ReadConcern // The read preference for operations in the transaction. The default value is nil, which means that the default // read preference of the session used to start the transaction will be used. ReadPreference readpref.ReadPref // The write concern for operations in the transaction. The default value is nil, which means that the default // write concern of the session used to start the transaction will be used. WriteConcern writeconcern.WriteConcern // The default maximum amount of time that a CommitTransaction operation executed in the session can run on the // server. The default value is nil, meaning that there is no time limit for execution. // The maximum amount of time that a CommitTransaction operation can executed in the transaction can run on the // server. The default value is nil, which means that the default maximum commit time of the session used to // start the transaction will be used. // // NOTE(benjirewis): MaxCommitTime will be deprecated in a future release. The more general Timeout option may // be used in its place to control the amount of time that a single operation can run before returning an error. // MaxCommitTime is ignored if Timeout is set on the client. MaxCommitTime time.Duration } // Transaction creates a new TransactionOptions instance. func Transaction() TransactionOptions { return &TransactionOptions{} } // SetReadConcern sets the value for the ReadConcern field. func (t TransactionOptions) SetReadConcern(rc readconcern.ReadConcern) TransactionOptions { t.ReadConcern = rc return t } // SetReadPreference sets the value for the ReadPreference field. func (t TransactionOptions) SetReadPreference(rp readpref.ReadPref) TransactionOptions { t.ReadPreference = rp return t } // SetWriteConcern sets the value for the WriteConcern field. func (t TransactionOptions) SetWriteConcern(wc writeconcern.WriteConcern) TransactionOptions { t.WriteConcern = wc return t } // SetMaxCommitTime sets the value for the MaxCommitTime field. // // NOTE(benjirewis): MaxCommitTime will be deprecated in a future release. The more general Timeout // option may be used in its place to control the amount of time that a single operation can run before // returning an error. MaxCommitTime is ignored if Timeout is set on the client. func (t TransactionOptions) SetMaxCommitTime(mct time.Duration) TransactionOptions { t.MaxCommitTime = mct return t } // MergeTransactionOptions combines the given TransactionOptions instances into a single TransactionOptions in a // last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeTransactionOptions(opts ...TransactionOptions) *TransactionOptions { t := Transaction() for _, opt := range opts { if opt == nil { continue } if opt.ReadConcern != nil { t.ReadConcern = opt.ReadConcern } if opt.ReadPreference != nil { t.ReadPreference = opt.ReadPreference } if opt.WriteConcern != nil { t.WriteConcern = opt.WriteConcern } if opt.MaxCommitTime != nil { t.MaxCommitTime = opt.MaxCommitTime } } return t }	3.89 KB	2025-05-25 12:27
📄 updateoptions.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package options // UpdateOptions represents options that can be used to configure UpdateOne and UpdateMany operations. type UpdateOptions struct { // A set of filters specifying to which array elements an update should apply. This option is only valid for MongoDB // versions >= 3.6. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the update will apply to all array elements. ArrayFilters ArrayFilters // If true, writes executed as part of the operation will opt out of document-level validation on the server. This // option is valid for MongoDB versions >= 3.2 and is ignored for previous server versions. The default value is // false. See https://www.mongodb.com/docs/manual/core/schema-validation/ for more information about document // validation. BypassDocumentValidation bool // Specifies a collation to use for string comparisons during the operation. This option is only valid for MongoDB // versions >= 3.4. For previous server versions, the driver will return an error if this option is used. The // default value is nil, which means the default collation of the collection will be used. Collation Collation // A string or document that will be included in server logs, profiling logs, and currentOp queries to help trace // the operation. The default value is nil, which means that no comment will be included in the logs. Comment interface{} // The index to use for the operation. This should either be the index name as a string or the index specification // as a document. This option is only valid for MongoDB versions >= 4.2. Server versions >= 3.4 will return an error // if this option is specified. For server versions < 3.4, the driver will return a client-side error if this option // is specified. The driver will return an error if this option is specified during an unacknowledged write // operation. The driver will return an error if the hint parameter is a multi-key map. The default value is nil, // which means that no hint will be sent. Hint interface{} // If true, a new document will be inserted if the filter does not match any documents in the collection. The // default value is false. Upsert bool // Specifies parameters for the update expression. This option is only valid for MongoDB versions >= 5.0. Older // servers will report an error for using this option. This must be a document mapping parameter names to values. // Values must be constant or closed expressions that do not reference document fields. Parameters can then be // accessed as variables in an aggregate expression context (e.g. "$$var"). Let interface{} } // Update creates a new UpdateOptions instance. func Update() UpdateOptions { return &UpdateOptions{} } // SetArrayFilters sets the value for the ArrayFilters field. func (uo UpdateOptions) SetArrayFilters(af ArrayFilters) UpdateOptions { uo.ArrayFilters = &af return uo } // SetBypassDocumentValidation sets the value for the BypassDocumentValidation field. func (uo UpdateOptions) SetBypassDocumentValidation(b bool) UpdateOptions { uo.BypassDocumentValidation = &b return uo } // SetCollation sets the value for the Collation field. func (uo UpdateOptions) SetCollation(c Collation) UpdateOptions { uo.Collation = c return uo } // SetComment sets the value for the Comment field. func (uo UpdateOptions) SetComment(comment interface{}) UpdateOptions { uo.Comment = comment return uo } // SetHint sets the value for the Hint field. func (uo UpdateOptions) SetHint(h interface{}) UpdateOptions { uo.Hint = h return uo } // SetUpsert sets the value for the Upsert field. func (uo UpdateOptions) SetUpsert(b bool) UpdateOptions { uo.Upsert = &b return uo } // SetLet sets the value for the Let field. func (uo UpdateOptions) SetLet(l interface{}) UpdateOptions { uo.Let = l return uo } // MergeUpdateOptions combines the given UpdateOptions instances into a single UpdateOptions in a last-one-wins fashion. // // Deprecated: Merging options structs will not be supported in Go Driver 2.0. Users should create a // single options struct instead. func MergeUpdateOptions(opts ...UpdateOptions) UpdateOptions { uOpts := Update() for _, uo := range opts { if uo == nil { continue } if uo.ArrayFilters != nil { uOpts.ArrayFilters = uo.ArrayFilters } if uo.BypassDocumentValidation != nil { uOpts.BypassDocumentValidation = uo.BypassDocumentValidation } if uo.Collation != nil { uOpts.Collation = uo.Collation } if uo.Comment != nil { uOpts.Comment = uo.Comment } if uo.Hint != nil { uOpts.Hint = uo.Hint } if uo.Upsert != nil { uOpts.Upsert = uo.Upsert } if uo.Let != nil { uOpts.Let = uo.Let } } return uOpts }	4.95 KB	2025-05-25 12:27

Edit File:

Terminal