/// <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); }