/// <summary>
/// Writes one or more <see cref="BsonDocument"/>(s) to MongoDb
/// </summary>
/// <param name="toWrite"></param>
/// <param name="collectionNamePostfix">Optional argument to write to a different collection with the specified tag</param>
/// <returns></returns>
public WriteResult WriteMany(IList <BsonDocument> toWrite, string collectionNamePostfix = null)
{
if (!toWrite.Any())
{
return(WriteResult.Success);
}
//TODO Test whether pre-fetching references to all the image_* collections results in any speedup
IMongoCollection <BsonDocument> collectionForWrite =
collectionNamePostfix == null
? _defaultCollection
: _database.GetCollection <BsonDocument>($"{_defaultCollectionName}_{collectionNamePostfix}");
_logger.Info($"Attempting bulk write of {toWrite.Count} documents to {collectionForWrite.CollectionNamespace}");
try
{
//TODO Try and determine if any write errors are to do with a document in the batch or not
BulkWriteResult <BsonDocument> res = collectionForWrite.BulkWrite(toWrite.Select(d => new InsertOneModel <BsonDocument>(d)));
_logger.Debug(" Write to {0} acknowledged: {1}", collectionForWrite.CollectionNamespace, res.IsAcknowledged);
return(res.IsAcknowledged ? WriteResult.Success : WriteResult.Failure);
}
catch (MongoBulkWriteException e)
{
//TODO Determine possible causes of MongoBulkWriteException
_logger.Error("Exception when writing to MongoDb: " + e);
return(WriteResult.Unknown);
}
}
public virtual async Task UpdateSendResults(List <SignalEvent <ObjectId> > items)
{
var requests = new List <WriteModel <SignalEvent <ObjectId> > >();
foreach (SignalEvent <ObjectId> item in items)
{
var filter = Builders <SignalEvent <ObjectId> > .Filter.Where(
p => p.SignalEventId == item.SignalEventId);
var update = Builders <SignalEvent <ObjectId> > .Update
.Set(p => p.FailedAttempts, item.FailedAttempts)
.Set(p => p.EventSettingsId, item.EventSettingsId)
.Set(p => p.SubscriberIdRangeFrom, item.SubscriberIdRangeFrom)
.Set(p => p.SubscriberIdRangeTo, item.SubscriberIdRangeTo)
.Set(p => p.SubscriberIdFromDeliveryTypesHandled, item.SubscriberIdFromDeliveryTypesHandled);
requests.Add(new UpdateOneModel <SignalEvent <ObjectId> >(filter, update)
{
IsUpsert = false
});
}
var options = new BulkWriteOptions
{
IsOrdered = false
};
BulkWriteResult response = await _collectionFactory
.GetCollection <SignalEvent <ObjectId> >()
.BulkWriteAsync(requests, options);
}
public virtual async Task Update(List <EventSettings <ObjectId> > items)
{
var requests = new List <WriteModel <EventSettings <ObjectId> > >();
foreach (EventSettings <ObjectId> item in items)
{
var filter = Builders <EventSettings <ObjectId> > .Filter.Where(
p => p.EventSettingsId == item.EventSettingsId);
var update = Builders <EventSettings <ObjectId> > .Update
.Set(p => p.Subscription, item.Subscription)
.Set(p => p.Updates, item.Updates)
.Set(p => p.Templates, item.Templates);
requests.Add(new UpdateOneModel <EventSettings <ObjectId> >(filter, update)
{
IsUpsert = false
});
}
var options = new BulkWriteOptions
{
IsOrdered = false
};
BulkWriteResult response = await _collectionFactory
.GetCollection <EventSettings <ObjectId> >()
.BulkWriteAsync(requests, options)
.ConfigureAwait(false);
}
public virtual async Task <long> ReplaceMany(IEnumerable <T> entities, bool isUpsert, CancellationToken token = default)
{
if (entities.Count() == 0)
{
return(0);
}
var requests = new List <WriteModel <T> >();
Func <object, object> idGetter = FieldDefinitions.GetIdFieldGetter(typeof(T));
foreach (T entity in entities)
{
ObjectId entityId = (ObjectId)idGetter.Invoke(entity);
var filter = Builders <T> .Filter.Eq("_id", entityId);
requests.Add(new ReplaceOneModel <T>(filter, entity)
{
IsUpsert = isUpsert
});
}
// BulkWrite
var options = new BulkWriteOptions()
{
IsOrdered = false
};
BulkWriteResult <T> bulkResult = await _collection
.BulkWriteAsync(requests, options, cancellationToken : token)
.ConfigureAwait(false);
return(bulkResult.Upserts.Count + bulkResult.ModifiedCount);
}
public async Task Update(List <DispatchTemplate <ObjectId> > items)
{
var requests = new List <WriteModel <DispatchTemplate <ObjectId> > >();
foreach (DispatchTemplate <ObjectId> item in items)
{
var filter = Builders <DispatchTemplate <ObjectId> > .Filter.Where(
p => p.DispatchTemplateId == item.DispatchTemplateId);
var update = Builders <DispatchTemplate <ObjectId> > .Update
.SetAllMappedMembers(item);
requests.Add(new UpdateOneModel <DispatchTemplate <ObjectId> >(filter, update)
{
IsUpsert = false
});
}
var options = new BulkWriteOptions
{
IsOrdered = false
};
BulkWriteResult response = await _collectionFactory
.GetCollection <DispatchTemplate <ObjectId> >()
.BulkWriteAsync(requests, options);
}
private async Task <int> SaveChangesAsync <TEntity>(IEnumerable <IUpdateEntry> entries, CancellationToken cancellationToken)
{
IEnumerable <WriteModel <TEntity> > writeModels = entries.Select(entry => entry.ToMongoDbWriteModel <TEntity>());
BulkWriteResult result = await _mongoDbConnection.GetCollection <TEntity>().BulkWriteAsync(writeModels, options: null, cancellationToken: cancellationToken);
return((int)(result.DeletedCount + result.InsertedCount + result.ModifiedCount));
}
public virtual async Task RewriteSets(ObjectId subscriberId
, List <SubscriberScheduleSettings <ObjectId> > periods)
{
List <int> receivePeriodSets = periods
.Select(x => x.Set)
.Distinct()
.ToList();
var requests = new List <WriteModel <SubscriberScheduleSettings <ObjectId> > >();
var filter = Builders <SubscriberScheduleSettings <ObjectId> > .Filter.Where(
p => p.SubscriberId == subscriberId &&
receivePeriodSets.Contains(p.Set));
requests.Add(new DeleteManyModel <SubscriberScheduleSettings <ObjectId> >(filter));
foreach (SubscriberScheduleSettings <ObjectId> item in periods)
{
requests.Add(new InsertOneModel <SubscriberScheduleSettings <ObjectId> >(item));
}
var options = new BulkWriteOptions()
{
IsOrdered = true
};
BulkWriteResult response = await _collectionFactory
.GetCollection <SubscriberScheduleSettings <ObjectId> >()
.BulkWriteAsync(requests, options)
.ConfigureAwait(false);
}
public object Update(object entity)
{
bool result = false;
var mlist = entity as List <MedicationData>;
try
{
using (MedicationMongoContext ctx = new MedicationMongoContext(ContractDBName))
{
var bulk = ctx.Medications.Collection.InitializeUnorderedBulkOperation();
foreach (MEMedication fooDoc in ctx.Medications)
{
var update = new UpdateDocument {
{ fooDoc.ToBsonDocument() }
};
update.Set("fmid", ObjectId.Parse(GetMedFamilyId(mlist, fooDoc.Id.ToString())));
bulk.Find(Query.EQ("_id", fooDoc.Id)).Upsert().UpdateOne(update);
}
BulkWriteResult bwr = bulk.Execute();
result = true;
}
return(result as object);
}
catch (Exception) { throw; }
}
public virtual async Task Update(List <StoredNotification <ObjectId> > items)
{
var requests = new List <WriteModel <StoredNotification <ObjectId> > >();
foreach (StoredNotification <ObjectId> item in items)
{
var filter = Builders <StoredNotification <ObjectId> > .Filter.Where(
p => p.StoredNotificationId == item.StoredNotificationId);
var update = Builders <StoredNotification <ObjectId> > .Update
.SetAllMappedMembers(item);
requests.Add(new UpdateOneModel <StoredNotification <ObjectId> >(filter, update)
{
IsUpsert = false
});
}
var options = new BulkWriteOptions
{
IsOrdered = false
};
BulkWriteResult response = await _collectionFactory
.GetCollection <StoredNotification <ObjectId> >()
.BulkWriteAsync(requests, options)
.ConfigureAwait(false);
}
public virtual async Task UpdateIsEnabled(List <TCategory> items)
{
var requests = new List <WriteModel <TCategory> >();
foreach (TCategory item in items)
{
var filter = Builders <TCategory> .Filter.Where(
p => p.SubscriberCategorySettingsId == item.SubscriberCategorySettingsId);
var update = Builders <TCategory> .Update
.Set(p => p.IsEnabled, item.IsEnabled);
requests.Add(new UpdateOneModel <TCategory>(filter, update)
{
IsUpsert = false
});
}
var options = new BulkWriteOptions
{
IsOrdered = false
};
BulkWriteResult response = await _collectionFactory
.GetCollection <TCategory>()
.BulkWriteAsync(requests, options)
.ConfigureAwait(false);
}
public void Should_convert_from_core_acknowledged_result_when_original_models_do_not_exist(long?modifiedCount)
{
var core = new BulkWriteOperationResult.Acknowledged(
requestCount: 1,
matchedCount: 2,
deletedCount: 3,
insertedCount: 4,
modifiedCount: modifiedCount,
processedRequests: new[] { new InsertRequest(new BsonDocumentWrapper(new BsonDocument("b", 1))) },
upserts: new List <BulkWriteOperationUpsert>());
var mapped = BulkWriteResult <BsonDocument> .FromCore(core);
mapped.ProcessedRequests[0].Should().BeOfType <InsertOneModel <BsonDocument> >();
mapped.IsAcknowledged.Should().BeTrue();
mapped.RequestCount.Should().Be(core.RequestCount);
mapped.MatchedCount.Should().Be(core.MatchedCount);
mapped.DeletedCount.Should().Be(core.DeletedCount);
mapped.InsertedCount.Should().Be(core.InsertedCount);
mapped.IsModifiedCountAvailable.Should().Be(core.IsModifiedCountAvailable);
if (mapped.IsModifiedCountAvailable)
{
mapped.ModifiedCount.Should().Be(core.ModifiedCount);
}
mapped.Upserts.Count.Should().Be(core.Upserts.Count);
}
public void runSampleUpdates()
{
using (_ms.RequestStart(_mdb)) {
try {
MongoCollection mc = _mdb.GetCollection("csharp");
BulkWriteOperation bwo = mc.InitializeOrderedBulkOperation();
foreach (var doc in getAllDocuments("csharp"))
{
BulkWriteRequestBuilder bwrb = bwo.Find(new QueryDocument {
{ "counter", doc.GetValue("counter").AsInt32 }
});
bwrb.Update(new UpdateDocument {
{ "$set", new UpdateDocument {
{ "counter", 1 }
} }
});
}
BulkWriteResult bwr = bwo.Execute();
Console.WriteLine("Completed BulkWriteOperations [updates: " + bwr.ModifiedCount + "]");
displayCollection("csharp");
} catch (Exception ex) {
Console.WriteLine("Caught Exception while BulkWriteOperation for Update: " + ex.StackTrace);
}
}
}
public virtual async Task UpdateNDRSettings(List <TDeliveryType> settings)
{
var updates = new List <WriteModel <TDeliveryType> >();
foreach (TDeliveryType item in settings)
{
var filter = Builders <TDeliveryType> .Filter.Where(
p => p.SubscriberId == item.SubscriberId &&
p.DeliveryType == item.DeliveryType);
var update = Builders <TDeliveryType> .Update
.Set(p => p.NDRCount, item.NDRCount)
.Set(p => p.IsNDRBlocked, item.IsNDRBlocked);
updates.Add(new UpdateOneModel <TDeliveryType>(filter, update)
{
IsUpsert = false
});
}
var options = new BulkWriteOptions()
{
IsOrdered = false
};
BulkWriteResult response = await _collectionFactory
.GetCollection <TDeliveryType>()
.BulkWriteAsync(updates, options)
.ConfigureAwait(false);
}
// private methods
private WriteConcernResult ToWriteConcernResult(BulkWriteResult bulkWriteResult, BulkWriteException bulkWriteException)
{
if (!bulkWriteResult.IsAcknowledged)
{
return null;
}
// don't include InsertedCount in getLastErrorResponse
var documentsAffectedCount =
bulkWriteResult.DeletedCount +
bulkWriteResult.MatchedCount +
bulkWriteResult.Upserts.Count;
var isUpdate = bulkWriteResult.ProcessedRequests.Any(r => r.RequestType == WriteRequestType.Update);
var updatedExisting = false;
BulkWriteUpsert upsert = null;
if (isUpdate)
{
upsert = bulkWriteResult.Upserts.LastOrDefault();
updatedExisting = documentsAffectedCount > 0 && upsert == null;
}
var code = 0;
string message = null;
BsonDocument details = null;
if (bulkWriteException != null)
{
var lastWriteError = bulkWriteException.WriteErrors.LastOrDefault();
var writeConcernError = bulkWriteException.WriteConcernError;
code = 8; // UnknownError
if (lastWriteError != null)
{
code = lastWriteError.Code;
message = lastWriteError.Message;
details = lastWriteError.Details;
}
else if (writeConcernError != null)
{
code = writeConcernError.Code;
message = writeConcernError.Message;
details = writeConcernError.Details;
}
}
var getLastErrorResponse = new BsonDocument
{
{ "ok", 1 },
{ "code", code, code != 0 },
{ "err", message, message != null },
{ "n", documentsAffectedCount },
{ "updatedExisting", updatedExisting, isUpdate },
{ "upserted", () => upsert.Id, isUpdate && upsert != null },
};
getLastErrorResponse.Merge(details, false); // don't overwrite existing elements
return new WriteConcernResult(getLastErrorResponse);
}
/// <summary>
/// 大批量插入数据
/// </summary>
/// <param name="collection">表名</param>
/// <param name="list">Bson数据集合</param>
/// <returns></returns>
public async Task <List <WriteModel <BsonDocument> > > BulkInsertAsync(string collection,
IEnumerable <WriteModel <BsonDocument> > list)
{
BulkWriteResult <BsonDocument> result =
await Database.GetCollection <BsonDocument>(collection).BulkWriteAsync(list);
return(result.ProcessedRequests.ToList());
}
private int SaveChanges <TEntity>(IEnumerable <IUpdateEntry> entries)
{
IEnumerable <WriteModel <TEntity> > writeModels = entries
.Select(entry => entry.ToMongoDbWriteModel <TEntity>())
.ToList();
BulkWriteResult result = _mongoDbConnection.GetCollection <TEntity>().BulkWrite(writeModels);
return((int)(result.DeletedCount + result.InsertedCount + result.ModifiedCount));
}
static async Task Main(string[] args)
{
Setup();
List <ReplaceOneModel <Movie> > operations = new List <ReplaceOneModel <Movie> >();
Console.WriteLine("Starting the data migration.");
var datePipelineResults = TransformDatePipeline();
Console.WriteLine($"I found {datePipelineResults.Count} docs where the lastupdated field is of type 'string'.");
if (datePipelineResults.Count > 0)
{
BulkWriteResult <Movie> bulkWriteDatesResult = null;
// TODO Ticket: Call _moviesCollection.BulkWriteAsync, passing in the
// datePipelineResults. You will need to use a ReplaceOneModel<Movie>
// (https://api.mongodb.com/csharp/current/html/T_MongoDB_Driver_ReplaceOneModel_1.htm).
foreach (var item in datePipelineResults)
{
operations.Add(new ReplaceOneModel <Movie>(Builders <Movie> .Filter.Where(x => x.Id == item.Id), item));
}
bulkWriteDatesResult = await _moviesCollection.BulkWriteAsync(operations, new BulkWriteOptions { IsOrdered = false });
Console.WriteLine($"{bulkWriteDatesResult.ProcessedRequests.Count} records updated.");
}
var ratingPipelineResults = TransformRatingPipeline();
Console.WriteLine($"I found {ratingPipelineResults.Count} docs where the imdb.rating field is not a number type.");
if (ratingPipelineResults.Count > 0)
{
BulkWriteResult <Movie> bulkWriteRatingsResult = null;
// TODO Ticket: Call _moviesCollection.BulkWriteAsync, passing in the
// ratingPipelineResults. You will need to use a ReplaceOneModel<Movie>
// (https://api.mongodb.com/csharp/current/html/T_MongoDB_Driver_ReplaceOneModel_1.htm).
foreach (var item in ratingPipelineResults)
{
operations.Add(new ReplaceOneModel <Movie>(Builders <Movie> .Filter.Where(x => x.Id == item.Id), item));
}
bulkWriteRatingsResult = await _moviesCollection.BulkWriteAsync(operations, new BulkWriteOptions { IsOrdered = false });
Console.WriteLine($"{bulkWriteRatingsResult.ProcessedRequests.Count} records updated.");
}
Console.WriteLine();
Console.WriteLine("Checking the data conversions...");
Verify();
// Keep the console window open until user hits `enter` or closes.
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Press <Enter> to close.");
Console.ReadLine();
}
protected override void When()
{
var subject = new BulkMixedWriteOperation(DatabaseName, CollectionName, _requests)
{
IsOrdered = false
};
_result = ExecuteOperationAsync(subject).GetAwaiter().GetResult();
}
protected override void When()
{
var subject = new BulkMixedWriteOperation(DatabaseName, CollectionName, _requests)
{
MaxBatchCount = _maxBatchCount,
};
_result = ExecuteOperationAsync(subject).GetAwaiter().GetResult();
}
protected virtual async Task UpdateTopicCounters(UpdateParameters parameters, List <SignalDispatch <ObjectId> > items)
{
if (!parameters.UpdateTopic)
{
return;
}
var operations = new List <WriteModel <TTopic> >();
foreach (SignalDispatch <ObjectId> item in items)
{
var filter = Builders <TTopic> .Filter.Where(
p => p.SubscriberId == item.ReceiverSubscriberId.Value &&
p.CategoryId == item.CategoryId &&
p.TopicId == item.TopicId);
var update = Builders <TTopic> .Update.Combine();
if (parameters.UpdateDeliveryTypeLastSendDateUtc)
{
update = update.Set(p => p.LastSendDateUtc, item.SendDateUtc);
}
if (parameters.UpdateDeliveryTypeSendCount)
{
update = update.Inc(p => p.SendCount, 1);
}
if (parameters.CreateCategoryIfNotExist)
{
update = update.SetOnInsertAllMappedMembers(new TTopic()
{
SubscriberId = item.ReceiverSubscriberId.Value,
CategoryId = item.CategoryId.Value,
TopicId = item.TopicId,
LastSendDateUtc = item.SendDateUtc,
SendCount = 1,
AddDateUtc = DateTime.UtcNow,
IsEnabled = true,
IsDeleted = false
});
}
operations.Add(new UpdateOneModel <TTopic>(filter, update)
{
IsUpsert = parameters.CreateTopicIfNotExist
});
}
var options = new BulkWriteOptions()
{
IsOrdered = false
};
BulkWriteResult <TTopic> response =
await _collectionFactory.GetCollection <TTopic>().BulkWriteAsync(operations, options);
}
static async Task Main(string[] args)
{
Setup();
Console.WriteLine("Starting the data migration.");
var datePipelineResults = TransformDatePipeline();
Console.WriteLine($"I found {datePipelineResults.Count} docs where the lastupdated field is of type 'string'.");
if (datePipelineResults.Count > 0)
{
BulkWriteResult <Movie> bulkWriteDatesResult = null;
// TODO Ticket: Call _moviesCollection.BulkWriteAsync, passing in the
// datePipelineResults. You will need to use a ReplaceOneModel<Movie>
// (https://api.mongodb.com/csharp/current/html/T_MongoDB_Driver_ReplaceOneModel_1.htm).
//
var updates = datePipelineResults.Select(d => {
return(new ReplaceOneModel <Movie>(GetMovieFilter(d.Id), d));
});
bulkWriteDatesResult = await _moviesCollection.BulkWriteAsync(updates);
Console.WriteLine($"{bulkWriteDatesResult.ProcessedRequests.Count} records updated.");
}
var ratingPipelineResults = TransformRatingPipeline();
Console.WriteLine($"I found {ratingPipelineResults.Count} docs where the imdb.rating field is not a number type.");
if (ratingPipelineResults.Count > 0)
{
BulkWriteResult <Movie> bulkWriteRatingsResult = null;
// TODO Ticket: Call _moviesCollection.BulkWriteAsync, passing in the
// ratingPipelineResults. You will need to use a ReplaceOneModel<Movie>
// (https://api.mongodb.com/csharp/current/html/T_MongoDB_Driver_ReplaceOneModel_1.htm).
//
var updates = ratingPipelineResults.Select(r => {
return(new ReplaceOneModel <Movie>(GetMovieFilter(r.Id), r));
});
bulkWriteRatingsResult = await _moviesCollection.BulkWriteAsync(updates);
Console.WriteLine($"{bulkWriteRatingsResult.ProcessedRequests.Count} records updated.");
}
Console.WriteLine();
Console.WriteLine("Checking the data conversions...");
Verify();
// Keep the console window open until user hits `enter` or closes.
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Press <Enter> to close.");
Console.ReadLine();
}
/// <summary>
/// Update one document from the MongoDb collection.
/// </summary>
/// <param name="context">Mongodb collection context</param>
/// <param name="document">The document to be updated</param>
/// <param name="options"><see cref="UpdateOptions"/></param>
/// <typeparam name="TDocument">Type of the document</typeparam>
/// <returns><see cref="BulkWriteResult{TDocument}"/></returns>
public static async ValueTask <BulkWriteResult <TDocument> > Update <TDocument>(this ICallistoCollectionContext <TDocument> context, TDocument document,
BulkWriteOptions options = null)
where TDocument : class, IDocumentRoot, IUpdatableDocument <TDocument>
{
ValidateOperationParameters(document, context, "update-one");
BulkWriteResult <TDocument> result = await Write(context, CheckPendingUpdatesListFilter(document), options);
document.PendingUpdates.Clear();
return(result);
}
public void UpdateBulkLocations()
{
if (BulkLocations.Count < 1)
{
return;
}
BulkWriteResult <Location> result = Locations.BulkWriteAsync(BulkLocations, writeOptions).Result;
BulkLocations.Clear();
Locations = _database.GetCollection <Location>("Locations");
}
protected override void VerifyResult(BulkWriteResult <BsonDocument> actualResult, BulkWriteResult <BsonDocument> expectedResult)
{
actualResult.DeletedCount.Should().Be(expectedResult.DeletedCount);
actualResult.InsertedCount.Should().Be(expectedResult.InsertedCount);
actualResult.IsModifiedCountAvailable.Should().Be(expectedResult.IsModifiedCountAvailable);
actualResult.MatchedCount.Should().Be(expectedResult.MatchedCount);
actualResult.ModifiedCount.Should().Be(expectedResult.ModifiedCount);
actualResult.ProcessedRequests.Should().Equal(expectedResult.ProcessedRequests);
actualResult.RequestCount.Should().Be(expectedResult.RequestCount);
actualResult.Upserts.Should().Equal(expectedResult.Upserts);
}
public void UpdateBulkReferenceObjects()
{
if (BulkReferenceObjects.Count < 1)
{
return;
}
BulkWriteResult <ReferenceObject> result = ReferenceObjects.BulkWriteAsync(BulkReferenceObjects, writeOptions).Result;
BulkReferenceObjects.Clear();
ReferenceObjects = _database.GetCollection <ReferenceObject>("ReferenceObjects");
}
protected override async Task CallMethodAsync(CancellationToken cancellationToken)
{
if (_session == null)
{
_result = await _collection.BulkWriteAsync(_requests, _options).ConfigureAwait(false);
}
else
{
_result = await _collection.BulkWriteAsync(_session, _requests, _options).ConfigureAwait(false);
}
}
protected override void CallMethod(CancellationToken cancellationToken)
{
if (_session == null)
{
_result = _collection.BulkWrite(_requests, _options);
}
else
{
_result = _collection.BulkWrite(_session, _requests, _options);
}
}
public void UpdateBulkObjectsReal()
{
if (BulkObjectsReal.Count < 1)
{
return;
}
BulkWriteResult <ObjectReal> result = ObjectsReal.BulkWriteAsync(BulkObjectsReal, writeOptions).Result;
BulkObjectsReal.Clear();
ObjectsReal = _database.GetCollection <ObjectReal>("ObjectReal");
}
/// <summary>
/// 删除数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="databaseName"></param>
/// <param name="collectionName"></param>
/// <param name="list"></param>
/// <returns></returns>
public static BulkWriteResult Delete <T>(string databaseName, string collectionName, List <T> list)
{
var bulk = ClientInstance.GetServer().GetDatabase(databaseName).GetCollection <T>(collectionName).InitializeOrderedBulkOperation();
foreach (var t in list)
{
bulk.Find(Query.EQ("_id", typeof(T).GetProperty("Id").GetValue(t).ToString())).RemoveOne();
}
BulkWriteResult result = bulk.Execute();
return(result);
}
public void OneTimeSetUp()
{
_connectionId = new ConnectionId(new ServerId(new ClusterId(1), new DnsEndPoint("localhost", 27017)), 2);
var processedRequests = new[] { new InsertOneModel <BsonDocument>(new BsonDocument("b", 1)) };
var upserts = new BulkWriteUpsert[0];
_bulkWriteResult = new BulkWriteResult <BsonDocument> .Acknowledged(1, 1, 0, 0, 0, processedRequests, upserts);
_writeConcernError = new WriteConcernError(11, "funny", new BsonDocument("c", 1));
_writeErrors = new[] { new BulkWriteError(10, ServerErrorCategory.Uncategorized, 1, "blah", new BsonDocument("a", 1)) };
_unprocessedRequests = new[] { new InsertOneModel <BsonDocument>(new BsonDocument("a", 1)) };
}
/// <summary>
/// 批量插入数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="databaseName"></param>
/// <param name="collectionName"></param>
/// <param name="list"></param>
/// <returns></returns>
public static BulkWriteResult BulkWrite <T>(string databaseName, string collectionName, List <T> list)
{
WriteModel <T>[] bulkModels = new WriteModel <T> [list.Count];
Parallel.For(0, list.Count, (int i) =>
{
bulkModels[i] = new InsertOneModel <T>(list[i]);
});
BulkWriteResult result = ClientInstance.GetDatabase(databaseName).GetCollection <T>(collectionName).BulkWrite(bulkModels);
return(result);
}
public void FromBulkWriteException_should_return_expected_result()
{
var processedRequests = new[] { new InsertOneModel<BsonDocument>(new BsonDocument("_id", 1)) };
var upserts = new List<BulkWriteUpsert>();
var bulkWriteResult = new BulkWriteResult<BsonDocument>.Acknowledged(1, 1, 0, 0, 0, processedRequests, upserts);
var writeErrors = new[] { new BulkWriteError(1, ServerErrorCategory.Uncategorized, 2, "message", new BsonDocument("details", 1)) };
var writeConcernError = new WriteConcernError(1, "message", new BsonDocument("details", 1));
var unprocessedRequests = new List<WriteModel<BsonDocument>>();
var bulkWriteException = new MongoBulkWriteException<BsonDocument>(_connectionId, bulkWriteResult, writeErrors, writeConcernError, unprocessedRequests);
var result = MongoWriteException.FromBulkWriteException(bulkWriteException);
result.ConnectionId.Should().Be(_connectionId);
result.InnerException.Should().BeSameAs(bulkWriteException);
result.Message.Should().Be("A write operation resulted in an error." + Environment.NewLine + " message" + Environment.NewLine + " message");
result.WriteConcernError.Should().Be(writeConcernError);
result.WriteError.Should().Be(writeErrors[0]);
}
public WriteConcernResult ToWriteConcernResult(BulkWriteResult bulkWriteResult)
{
return ToWriteConcernResult(bulkWriteResult, null);
}
