protected void Update(BsonDocument filter, BsonDocument update)
{
var requests = new[] { new UpdateRequest(UpdateType.Update, filter, update) };
var operation = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings);
ExecuteOperation(operation);
}
public void Execute_with_collation_should_throw_when_collation_is_not_supported(
[Values(false, true)] bool async)
{
var collation = new Collation("en_US");
var requests = new List <UpdateRequest>
{
new UpdateRequest(UpdateType.Update, new BsonDocument("x", 1), new BsonDocument("$set", new BsonDocument("x", 2))),
new UpdateRequest(UpdateType.Update, new BsonDocument("x", 1), new BsonDocument("$set", new BsonDocument("x", 2)))
{
Collation = collation
}
};
var subject = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings);
var exception = Record.Exception(() => ExecuteOperation(subject, async));
if (Feature.Collation.IsSupported(CoreTestConfiguration.ServerVersion))
{
exception.Should().BeNull();
}
else
{
exception.Should().BeOfType <NotSupportedException>();
}
}
private Task <BulkWriteOperationResult> ExecuteUpdatesAsync(IChannelHandle channel, IEnumerable <UpdateRequest> requests, CancellationToken cancellationToken)
{
var operation = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
MaxBatchCount = _maxBatchCount,
MaxBatchLength = _maxBatchLength,
IsOrdered = _isOrdered,
WriteConcern = _writeConcern
};
return(operation.ExecuteAsync(channel, cancellationToken));
}
private Task <BulkWriteResult> ExecuteUpdatesAsync(IConnectionHandle connection, IEnumerable <UpdateRequest> requests, TimeSpan timeout, CancellationToken cancellationToken)
{
var operation = new BulkUpdateOperation(_databaseName, _collectionName, requests)
{
CheckElementNames = _checkElementNames,
MaxBatchCount = _maxBatchCount,
MaxBatchLength = _maxBatchLength,
IsOrdered = _isOrdered,
ReaderSettings = _readerSettings,
WriteConcern = _writeConcern,
WriterSettings = _writerSettings
};
return(operation.ExecuteAsync(connection, timeout, cancellationToken));
}
// methods
public async Task <WriteConcernResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(connection, "connection");
var requests = new[] { new UpdateRequest(_criteria, _update)
{
IsMultiUpdate = _isMulti, IsUpsert = _isUpsert
} };
var operation = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
IsOrdered = true,
WriteConcern = _writeConcern
};
BulkWriteOperationResult bulkWriteResult;
BulkWriteOperationException bulkWriteException = null;
try
{
bulkWriteResult = await operation.ExecuteAsync(connection, timeout, cancellationToken);
}
catch (BulkWriteOperationException ex)
{
bulkWriteResult = ex.Result;
bulkWriteException = ex;
}
var converter = new BulkWriteOperationResultConverter();
if (bulkWriteException != null)
{
throw converter.ToWriteConcernException(bulkWriteException);
}
else
{
if (_writeConcern.IsAcknowledged)
{
return(converter.ToWriteConcernResult(bulkWriteResult));
}
else
{
return(null);
}
}
}
// methods
public async Task <WriteConcernResult> ExecuteAsync(IChannelHandle channel, CancellationToken cancellationToken)
{
Ensure.IsNotNull(channel, "channel");
var requests = new[] { _request };
var operation = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
IsOrdered = true,
WriteConcern = _writeConcern
};
BulkWriteOperationResult bulkWriteResult;
MongoBulkWriteOperationException bulkWriteException = null;
try
{
bulkWriteResult = await operation.ExecuteAsync(channel, cancellationToken).ConfigureAwait(false);
}
catch (MongoBulkWriteOperationException ex)
{
bulkWriteResult = ex.Result;
bulkWriteException = ex;
}
var converter = new BulkWriteOperationResultConverter();
if (bulkWriteException != null)
{
throw converter.ToWriteConcernException(channel.ConnectionDescription.ConnectionId, bulkWriteException);
}
else
{
if (_writeConcern.IsAcknowledged)
{
return(converter.ToWriteConcernResult(bulkWriteResult));
}
else
{
return(null);
}
}
}
// methods
public async Task<WriteConcernResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(connection, "connection");
var requests = new[] { _request };
var operation = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
IsOrdered = true,
WriteConcern = _writeConcern
};
BulkWriteOperationResult bulkWriteResult;
BulkWriteOperationException bulkWriteException = null;
try
{
bulkWriteResult = await operation.ExecuteAsync(connection, timeout, cancellationToken);
}
catch (BulkWriteOperationException ex)
{
bulkWriteResult = ex.Result;
bulkWriteException = ex;
}
var converter = new BulkWriteOperationResultConverter();
if (bulkWriteException != null)
{
throw converter.ToWriteConcernException(bulkWriteException);
}
else
{
if (_writeConcern.IsAcknowledged)
{
return converter.ToWriteConcernResult(bulkWriteResult);
}
else
{
return null;
}
}
}
public void Let_get_and_set_should_work(
[Values(null, "{ name : 'name' }")] string let)
{
var requests = new List <UpdateRequest>
{
new UpdateRequest(
UpdateType.Update,
new BsonDocument("x", 1),
new BsonDocument("$set", new BsonDocument("x", 2)))
{
Hint = new BsonDocument("_id", 1)
}
};
var subject = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings);
var value = let != null?BsonDocument.Parse(let) : null;
subject.Let = value;
var result = subject.Let;
result.Should().Be(value);
}
public void Execute_with_hint_should_throw_when_hint_is_not_supported(
[Values(0, 1)] int w,
[Values(false, true)] bool async)
{
var writeConcern = new WriteConcern(w);
var serverVersion = CoreTestConfiguration.ServerVersion;
var requests = new List <UpdateRequest>
{
new UpdateRequest(
UpdateType.Update,
new BsonDocument("x", 1),
new BsonDocument("$set", new BsonDocument("x", 2)))
{
Hint = new BsonDocument("_id", 1)
}
};
var subject = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
WriteConcern = writeConcern
};
var exception = Record.Exception(() => ExecuteOperation(subject, async, useImplicitSession: true));
if (Feature.HintForUpdateAndReplaceOperations.IsSupported(serverVersion))
{
exception.Should().BeNull();
}
else if (!writeConcern.IsAcknowledged)
{
exception.Should().BeOfType <NotSupportedException>();
}
else if (Feature.HintForUpdateAndReplaceOperations.DriverMustThrowIfNotSupported(serverVersion))
{
exception.Should().BeOfType <NotSupportedException>();
}
else
{
exception.Should().BeOfType <MongoCommandException>();
}
}
// methods
public async Task<WriteConcernResult> ExecuteAsync(IChannelHandle channel, CancellationToken cancellationToken)
{
Ensure.IsNotNull(channel, "channel");
var requests = new[] { _request };
var operation = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
IsOrdered = true,
WriteConcern = _writeConcern
};
BulkWriteOperationResult bulkWriteResult;
MongoBulkWriteOperationException bulkWriteException = null;
try
{
bulkWriteResult = await operation.ExecuteAsync(channel, cancellationToken).ConfigureAwait(false);
}
catch (MongoBulkWriteOperationException ex)
{
bulkWriteResult = ex.Result;
bulkWriteException = ex;
}
var converter = new BulkWriteOperationResultConverter();
if (bulkWriteException != null)
{
throw converter.ToWriteConcernException(channel.ConnectionDescription.ConnectionId, bulkWriteException);
}
else
{
if (_writeConcern.IsAcknowledged)
{
return converter.ToWriteConcernResult(bulkWriteResult);
}
else
{
return null;
}
}
}
