/// <inheritdoc />
public virtual IMongoDatabase WithWriteConcern(WriteConcern writeConcern)
{
throw new NotImplementedException();
}
public virtual MongoDatabase this[string databaseName, WriteConcern writeConcern]
{
get { return(GetDatabase(databaseName, writeConcern)); }
}
public MongoInsertOptions(MongoCollection collection) : this()
{
_writeConcern = collection.Settings.WriteConcern;
}
public override IMongoCollection <TDerivedDocument> WithWriteConcern(WriteConcern writeConcern)
{
return(new OfTypeMongoCollection <TRootDocument, TDerivedDocument>(_rootDocumentCollection, WrappedCollection.WithWriteConcern(writeConcern), Filter));
}
public virtual MongoCollection <BsonDocument> this[string collectionName, WriteConcern writeConcern]
{
get { return(GetCollection(collectionName, writeConcern)); }
}
/// <summary>
/// Gets a MongoCollection instance representing a collection on this database
/// with a default document type of BsonDocument.
/// </summary>
/// <param name="collectionName">The name of the collection.</param>
/// <param name="writeConcern">The write concern to use when accessing this collection.</param>
/// <returns>An instance of MongoCollection.</returns>
public virtual MongoCollection <BsonDocument> GetCollection(string collectionName, WriteConcern writeConcern)
{
return(GetCollection <BsonDocument>(collectionName, writeConcern));
}
public virtual MongoDatabase this[string databaseName, MongoCredentials credentials, WriteConcern writeConcern]
{
get { return(GetDatabase(databaseName, credentials, writeConcern)); }
}
internal SafeMode(WriteConcern writeConcern)
{
_writeConcern = writeConcern;
}
public void CreateCollection_should_execute_a_CreateCollectionOperation_when_options_is_generic(
[Values(false, true)] bool usingSession,
[Values(false, true)] bool async)
{
var writeConcern = new WriteConcern(1);
var subject = _subject.WithWriteConcern(writeConcern);
var session = CreateSession(usingSession);
var name = "bar";
var storageEngine = new BsonDocument("awesome", true);
var validatorDocument = BsonDocument.Parse("{ x : 1 }");
var validatorDefinition = (FilterDefinition <BsonDocument>)validatorDocument;
var options = new CreateCollectionOptions <BsonDocument>
{
AutoIndexId = false,
Capped = true,
Collation = new Collation("en_US"),
IndexOptionDefaults = new IndexOptionDefaults {
StorageEngine = new BsonDocument("x", 1)
},
MaxDocuments = 10,
MaxSize = 11,
NoPadding = true,
StorageEngine = storageEngine,
UsePowerOf2Sizes = true,
ValidationAction = DocumentValidationAction.Warn,
ValidationLevel = DocumentValidationLevel.Off,
Validator = validatorDefinition
};
var cancellationToken = new CancellationTokenSource().Token;
if (usingSession)
{
if (async)
{
subject.CreateCollectionAsync(session, name, options, cancellationToken).GetAwaiter().GetResult();
}
else
{
subject.CreateCollection(session, name, options, cancellationToken);
}
}
else
{
if (async)
{
subject.CreateCollectionAsync(name, options, cancellationToken).GetAwaiter().GetResult();
}
else
{
subject.CreateCollection(name, options, cancellationToken);
}
}
var call = _operationExecutor.GetWriteCall <BsonDocument>();
VerifySessionAndCancellationToken(call, session, cancellationToken);
var op = call.Operation.Should().BeOfType <CreateCollectionOperation>().Subject;
op.CollectionNamespace.Should().Be(new CollectionNamespace(_subject.DatabaseNamespace, name));
op.AutoIndexId.Should().Be(options.AutoIndexId);
op.Capped.Should().Be(options.Capped);
op.Collation.Should().BeSameAs(options.Collation);
op.IndexOptionDefaults.ToBsonDocument().Should().Be(options.IndexOptionDefaults.ToBsonDocument());
op.MaxDocuments.Should().Be(options.MaxDocuments);
op.MaxSize.Should().Be(options.MaxSize);
op.NoPadding.Should().Be(options.NoPadding);
op.StorageEngine.Should().Be(storageEngine);
op.UsePowerOf2Sizes.Should().Be(options.UsePowerOf2Sizes);
op.ValidationAction.Should().Be(options.ValidationAction);
op.ValidationLevel.Should().Be(options.ValidationLevel);
op.Validator.Should().Be(validatorDocument);
op.WriteConcern.Should().BeSameAs(writeConcern);
}
/// <inheritdoc /> public abstract IMongoCollection <TDocument> WithWriteConcern(WriteConcern writeConcern);
/// <summary>
/// Gets a MongoCollection instance representing a collection on this database
/// with a default document type of BsonDocument.
/// </summary>
/// <param name="collectionName">The name of the collection.</param>
/// <param name="writeConcern">The write concern to use when accessing this collection.</param>
/// <returns>An instance of MongoCollection.</returns>
public virtual MongoCollection <BsonDocument> GetCollection(string collectionName, WriteConcern writeConcern)
{
var collectionSettings = new MongoCollectionSettings <BsonDocument>(this, collectionName)
{
WriteConcern = writeConcern
};
return(GetCollection(collectionSettings));
}
public virtual MongoCollection <BsonDocument> this[string collectionName, WriteConcern writeConcern] => GetCollection(collectionName, writeConcern);
private BulkWriteResult <TDocument> ExecuteHelper(IClientSessionHandle session, WriteConcern writeConcern)
{
if (_hasBeenExecuted)
{
throw new InvalidOperationException("The bulk write operation has already been executed.");
}
_hasBeenExecuted = true;
var collectionSettings = _collection.Settings;
var messageEncoderSettings = _collection.GetMessageEncoderSettings();
IEnumerable <WriteRequest> requests = _requests;
if (_collection.Settings.AssignIdOnInsert)
{
requests = _requests.Select(x =>
{
var insertRequest = x as InsertRequest;
if (insertRequest != null)
{
object document = insertRequest.Document;
IBsonSerializer serializer = BsonDocumentSerializer.Instance;
var wrapped = insertRequest.Document as BsonDocumentWrapper;
while (wrapped != null)
{
document = wrapped.Wrapped;
serializer = wrapped.Serializer;
wrapped = document as BsonDocumentWrapper;
}
_collection.AssignId(document, serializer);
}
return(x);
});
}
var operation = new BulkMixedWriteOperation(new CollectionNamespace(_collection.Database.Name, _collection.Name), requests, messageEncoderSettings)
{
BypassDocumentValidation = _bypassDocumentValidation,
IsOrdered = _isOrdered,
RetryRequested = _collection.Database.Server.Settings.RetryWrites,
WriteConcern = writeConcern
};
try
{
var result = _collection.ExecuteWriteOperation(session, operation);
return(BulkWriteResult <TDocument> .FromCore(result));
}
catch (MongoBulkWriteOperationException ex)
{
throw MongoBulkWriteException <TDocument> .FromCore(ex);
}
}
private BulkWriteResult <TDocument> ExecuteHelper(WriteConcern writeConcern)
{
return(_collection.UsingImplicitSession(session => ExecuteHelper(session, writeConcern)));
}
public virtual MongoDatabase this[string databaseName, WriteConcern writeConcern] => GetDatabase(databaseName, writeConcern);
