public override async Task <BulkWriteResult <TDocument> > BulkWriteAsync(IEnumerable <WriteModel <TDocument> > requests, BulkWriteOptions options, CancellationToken cancellationToken)
{
Ensure.IsNotNull(requests, "requests");
if (!requests.Any())
{
throw new ArgumentException("Must contain at least 1 request.", "requests");
}
options = options ?? new BulkWriteOptions();
var operation = new BulkMixedWriteOperation(
_collectionNamespace,
requests.Select(ConvertWriteModelToWriteRequest),
_messageEncoderSettings)
{
IsOrdered = options.IsOrdered,
WriteConcern = _settings.WriteConcern
};
try
{
var result = await ExecuteWriteOperation(operation, cancellationToken).ConfigureAwait(false);
return(BulkWriteResult <TDocument> .FromCore(result, requests));
}
catch (MongoBulkWriteOperationException ex)
{
throw MongoBulkWriteException <TDocument> .FromCore(ex, requests.ToList());
}
}
// static
internal static DeleteResult FromCore(BulkWriteResult result)
{
if (result.IsAcknowledged)
{
return(new Acknowledged(result.DeletedCount));
}
return(Unacknowledged.Instance);
}
private BulkWriteResult <TDocument> ExecuteHelper(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,
WriteConcern = writeConcern
};
using (var binding = _collection.Database.Server.GetWriteBinding())
{
try
{
var result = operation.Execute(binding, CancellationToken.None);
return(BulkWriteResult <TDocument> .FromCore(result));
}
catch (MongoBulkWriteOperationException ex)
{
throw MongoBulkWriteException <TDocument> .FromCore(ex);
}
}
}
// static
internal static DeleteResult FromCore(BulkWriteResult result)
{
if (result.IsAcknowledged)
{
return new Acknowledged(result.DeletedCount);
}
return Unacknowledged.Instance;
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="BulkWriteException" /> class.
/// </summary>
/// <param name="result">The result.</param>
/// <param name="writeErrors">The write errors.</param>
/// <param name="unprocessedRequests">The unprocessed requests.</param>
/// <param name="writeConcernError">The write concern error.</param>
public BulkWriteException(
BulkWriteResult result,
IEnumerable<BulkWriteError> writeErrors,
WriteConcernError writeConcernError,
IEnumerable<WriteRequest> unprocessedRequests)
: base("A bulk write operation resulted in one or more errors.")
{
_result = result;
_writeErrors = new ReadOnlyCollection<BulkWriteError>(writeErrors.ToList());
_writeConcernError = writeConcernError;
_unprocessedRequests = new ReadOnlyCollection<WriteRequest>(unprocessedRequests.ToList());
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="BulkWriteException" /> class.
/// </summary>
/// <param name="result">The result.</param>
/// <param name="writeErrors">The write errors.</param>
/// <param name="unprocessedRequests">The unprocessed requests.</param>
/// <param name="writeConcernError">The write concern error.</param>
public BulkWriteException(
BulkWriteResult result,
IEnumerable <BulkWriteError> writeErrors,
WriteConcernError writeConcernError,
IEnumerable <WriteRequest> unprocessedRequests)
: base("A bulk write operation resulted in one or more errors.")
{
_result = result;
_writeErrors = new ReadOnlyCollection <BulkWriteError>(writeErrors.ToList());
_writeConcernError = writeConcernError;
_unprocessedRequests = new ReadOnlyCollection <WriteRequest>(unprocessedRequests.ToList());
}
// static
internal static ReplaceOneResult FromCore(BulkWriteResult result)
{
if (result.IsAcknowledged)
{
var upsert = result.Upserts.Count == 1
? result.Upserts[0].Id
: null;
var modifiedCount = result.IsModifiedCountAvailable
? (long?)result.ModifiedCount
: null;
return(new Acknowledged(result.MatchedCount, modifiedCount, upsert));
}
return(Unacknowledged.Instance);
}
// static
internal static UpdateResult FromCore(BulkWriteResult result)
{
if (result.IsAcknowledged)
{
var upsert = result.Upserts.Count == 1
? result.Upserts[0].Id
: null;
var modifiedCount = result.IsModifiedCountAvailable
? (long?)result.ModifiedCount
: null;
return new Acknowledged(result.MatchedCount, modifiedCount, upsert);
}
return Unacknowledged.Instance;
}
public override BulkWriteResult <TDocument> BulkWrite(IEnumerable <WriteModel <TDocument> > requests, BulkWriteOptions options, CancellationToken cancellationToken)
{
Ensure.IsNotNull(requests, nameof(requests));
if (!requests.Any())
{
throw new ArgumentException("Must contain at least 1 request.", "requests");
}
options = options ?? new BulkWriteOptions();
var operation = CreateBulkWriteOperation(requests, options);
try
{
var result = ExecuteWriteOperation(operation, cancellationToken);
return(BulkWriteResult <TDocument> .FromCore(result, requests));
}
catch (MongoBulkWriteOperationException ex)
{
throw MongoBulkWriteException <TDocument> .FromCore(ex, requests.ToList());
}
}
public async Task <BulkWriteResult <TDocument> > BulkWriteAsync(BulkWriteModel <TDocument> model, TimeSpan?timeout, CancellationToken cancellationToken)
{
Ensure.IsNotNull(model, "model");
var operation = new BulkMixedWriteOperation(
_collectionNamespace,
model.Requests.Select(ConvertWriteModelToWriteRequest),
_messageEncoderSettings)
{
IsOrdered = model.IsOrdered,
WriteConcern = _settings.WriteConcern
};
try
{
var result = await ExecuteWriteOperation(operation, timeout, cancellationToken);
return(BulkWriteResult <TDocument> .FromCore(result, model.Requests));
}
catch (BulkWriteOperationException ex)
{
throw BulkWriteException <TDocument> .FromCore(ex, model.Requests);
}
}
// private methods
private void CheckExpectedResult(ExpectedResult expectedResult, BulkWriteResult result)
{
Assert.AreEqual(expectedResult.IsAcknowledged ?? true, result.IsAcknowledged);
Assert.AreEqual(expectedResult.ProcessedRequestsCount ?? expectedResult.RequestCount ?? 1, result.ProcessedRequests.Count);
Assert.AreEqual(expectedResult.RequestCount ?? 1, result.RequestCount);
if (result.IsAcknowledged)
{
Assert.AreEqual(expectedResult.DeletedCount ?? 0, result.DeletedCount);
Assert.AreEqual(expectedResult.InsertedCount ?? 0, result.InsertedCount);
Assert.AreEqual(expectedResult.MatchedCount ?? 0, result.MatchedCount);
Assert.AreEqual(expectedResult.IsModifiedCountAvailable ?? true, result.IsModifiedCountAvailable);
if (result.IsModifiedCountAvailable)
{
Assert.AreEqual(expectedResult.ModifiedCount ?? 0, result.ModifiedCount);
}
else
{
Assert.Throws<NotSupportedException>(() => { var _ = result.ModifiedCount; });
}
Assert.AreEqual(expectedResult.UpsertsCount ?? 0, result.Upserts.Count);
}
else
{
Assert.Throws<NotSupportedException>(() => { var x = result.DeletedCount; });
Assert.Throws<NotSupportedException>(() => { var x = result.InsertedCount; });
Assert.Throws<NotSupportedException>(() => { var x = result.MatchedCount; });
Assert.Throws<NotSupportedException>(() => { var x = result.ModifiedCount; });
Assert.Throws<NotSupportedException>(() => { var x = result.Upserts; });
}
}
