public UnifiedInsertManyOperation Build(string targetCollectionId, BsonDocument arguments) { var collection = _entityMap.GetCollection(targetCollectionId); List <BsonDocument> documents = null; InsertManyOptions options = null; IClientSessionHandle session = null; foreach (var argument in arguments) { switch (argument.Name) { case "documents": documents = argument.Value.AsBsonArray.Cast <BsonDocument>().ToList(); break; case "ordered": options = options ?? new InsertManyOptions(); options.IsOrdered = argument.Value.AsBoolean; break; case "session": session = _entityMap.GetSession(argument.Value.AsString); break; default: throw new FormatException($"Invalid InsertManyOperation argument name: '{argument.Name}'."); } } return(new UnifiedInsertManyOperation(session, collection, documents, options)); }
/// <summary> /// 插入多条 /// </summary> /// <typeparam name="T">文档类型</typeparam> /// <param name="collection">集合</param> /// <param name="documents">文档对象</param> /// <param name="options">插入操作设置</param> /// <param name="cancellationToken">取消操作设置</param> public static void AddMany <T>(this IMongoCollection <T> collection, IEnumerable <T> documents, InsertManyOptions options = null, CancellationToken cancellationToken = default) { collection.InsertMany(documents, options, cancellationToken); }
public MongoDbRepository( IMapper mapper, ILogger <MongoDbRepository> logger, IOptions <MongoOptions> options) { this.mapper = mapper; this.logger = logger; var internalIdentity = new MongoInternalIdentity(Constants.ADMIN, options.Value.Username); var passwordEvidence = new PasswordEvidence(options.Value.Password); var mongoCredential = new MongoCredential(options.Value.AuthMechanism, internalIdentity, passwordEvidence); var settings = new MongoClientSettings { Credential = mongoCredential, Server = new MongoServerAddress(options.Value.MongoHost, int.Parse(options.Value.Port)), GuidRepresentation = GuidRepresentation.Standard }; var client = new MongoClient(settings); this.database = client.GetDatabase(options.Value.DefaultDb); this.insertManyOptions = new InsertManyOptions { BypassDocumentValidation = false, IsOrdered = false }; this.insertOneOptions = new InsertOneOptions { BypassDocumentValidation = false }; }
/// <summary> /// 同步添加多条记录 /// </summary> /// <param name="collectionName"></param> /// <param name="documents"></param> /// <param name="options"></param> public void BulkAdd(string collectionName, IEnumerable <T> documents, InsertManyOptions options = null) { infrastructure.Exec(database => { database.GetCollection <T>(collectionName).InsertMany(documents, options); }); }
public void InsertMany <T>(IEnumerable <T> items, InsertManyOptions options = null) where T : IMongoEntity { foreach (var item in items) { Data[typeof(T)].Add(item); } }
public async Task BulkInsertAsync(IEnumerable <TModel> models, InsertManyOptions options = null, CancellationToken token = default) { try { await _collection.InsertManyAsync(models, options, token); } catch (MongoAuthenticationException mongoAuthEx) { throw new NautilusMongoDbException("Mongo security error", mongoAuthEx); } catch (MongoConnectionException mongoConnectEx) { throw new NautilusMongoDbException(mongoConnectEx.Message, mongoConnectEx); } catch (MongoWriteException mongoWriteEx) { throw new NautilusMongoDbException("Mongo write error", mongoWriteEx); } catch (MongoCommandException mongoCmdEx) { throw new NautilusMongoDbException("Mongo command error", mongoCmdEx); } catch (TimeoutException timeoutEx) { throw new NautilusMongoDbException("Mongo has timed out", timeoutEx); } catch (Exception ex) { throw new NautilusMongoDbException("Mongo throws a general exception", ex); } }
/// <summary> /// 异步添加多条数据 /// </summary> /// <param name="collectionName"></param> /// <param name="documents"></param> /// <param name="options"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public Task BulkAddAsync(string collectionName, IEnumerable <T> documents, InsertManyOptions options = null, CancellationToken cancellationToken = default) { return(infrastructure.Exec(database => { return database.GetCollection <T>(collectionName).InsertManyAsync(documents, options, cancellationToken); })); }
/// <summary> /// 批量插入。 /// </summary> /// <param name="entities">插入实体集合。</param> /// <param name="options">插入数据配置项。</param> public void InsertMany(IEnumerable <TEntity> entities, InsertManyOptions options = null) { string collectionName = typeof(TEntity).Name; var colleciton = GetMongoCollection(collectionName); colleciton.InsertMany(entities, options); }
public override void InsertMany(IEnumerable <TVal> documents, InsertManyOptions options = null, CancellationToken cancellationToken = new CancellationToken()) { foreach (TVal doc in documents) { InsertOne(doc, null, cancellationToken); } }
public override void InsertMany(IEnumerable <TDocument> documents, InsertManyOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { foreach (var document in documents) { var bsonDocument = SerializeDocument(document); _documents.Add(bsonDocument); } }
public Task Insert(IEnumerable <TValue> items) { var options = new InsertManyOptions { BypassDocumentValidation = true }; return(_collection.InsertManyAsync(items, options)); }
/// <summary> /// 异步批量插入。 /// </summary> /// <param name="entities">插入实体集合。</param> /// <param name="options">插入数据配置项。</param> public async Task InsertManyAsync(IEnumerable <TEntity> entities, InsertManyOptions options = null) { string collectionName = typeof(TEntity).Name; var colleciton = GetMongoCollection(collectionName); await colleciton.InsertManyAsync(entities, options); await this.SyncContext; }
async Task <IReadOnlyList <TEntity> > ICollectionAdapter <TEntity> .InsertManyAsync( IReadOnlyList <TEntity> entities, InsertManyOptions options, CancellationToken token) { await this.collection.InsertManyAsync(entities, options, token); return(entities); }
/// <summary> /// 插入多条 /// </summary> /// <typeparam name="T">文档类型</typeparam> /// <param name="collection">集合</param> /// <param name="documents">文档对象</param> /// <param name="options">插入操作设置</param> /// <param name="cancellationToken">取消操作设置</param> public static Task AddManyAsync <T>( this IMongoCollection <T> collection, IEnumerable <T> documents, InsertManyOptions options = null, CancellationToken cancellationToken = default) where T : BaseMongoEntity { return(Task.Run(() => AddMany(collection, documents, options, cancellationToken))); }
public ICallistoInsertMany <T> CreateInsertMany <T>(IEnumerable <T> values, InsertManyOptions insertOneOptions, string operationName) where T : class, IDocumentRoot { // if (values is null) // throw new CallistoException($"No insert can be made with a null {nameof(T)} instance"); // if (!values.Any()) // throw new CallistoException("There is no need to insert an empty list of values into the database."); return(new DefaultCallistoInsertMany <T>(operationName, values, insertOneOptions)); }
public UnifiedInsertManyOperation( IClientSessionHandle session, IMongoCollection <BsonDocument> collection, List <BsonDocument> documents, InsertManyOptions options) { _session = session; _collection = collection; _documents = documents; _options = options; }
//methods public virtual Task Insert(List <TCategory> settings) { var options = new InsertManyOptions() { IsOrdered = false }; return(_collectionFactory .GetCollection <TCategory>() .InsertManyAsync(settings, options)); }
public void Supported_multi_statement_writes_should_have_transaction_id( [Values("insertMany", "bulkWrite")] string operation, [Values(false, true)] bool ordered, [Values(false, true)] bool async) { RequireServer.Check().VersionGreaterThanOrEqualTo("3.6.0").ClusterTypes(ClusterType.ReplicaSet, ClusterType.Sharded); DropCollection(); var eventCapturer = CreateEventCapturer(); using (var client = CreateDisposableClient(eventCapturer)) { var database = client.GetDatabase(_databaseName); var collection = database.GetCollection <BsonDocument>(_collectionName); switch (operation) { case "bulkWrite": var requests = new[] { new InsertOneModel <BsonDocument>(new BsonDocument("_id", 1)) }; var bulkWriteOptions = new BulkWriteOptions { IsOrdered = ordered }; if (async) { collection.BulkWriteAsync(requests, bulkWriteOptions).GetAwaiter().GetResult(); } else { collection.BulkWrite(requests, bulkWriteOptions); } break; case "insertMany": var documents = new[] { new BsonDocument("_id", 1) }; var insertManyOptions = new InsertManyOptions { IsOrdered = ordered }; if (async) { collection.InsertManyAsync(documents, insertManyOptions).GetAwaiter().GetResult(); } else { collection.InsertMany(documents, insertManyOptions); } break; default: throw new Exception($"Unexpected operation: {operation}."); } AssertCommandHasTransactionId(eventCapturer); } }
//methods public Task Insert(List <DispatchTemplate <ObjectId> > items) { var options = new InsertManyOptions() { IsOrdered = true }; return(_collectionFactory .GetCollection <DispatchTemplate <ObjectId> >() .InsertManyAsync(items, options)); }
/// <summary> /// Insert all entities to database /// </summary> /// <param name="entities">Entity list model</param> /// <param name="insertManyOptions">To set insert options</param> /// <param name="cancellationToken">Token</param> /// <typeparam name="TEntity">Entity type</typeparam> /// <returns></returns> public async Task SaveAllAsync <TEntity> (IEnumerable <TEntity> entities, InsertManyOptions insertManyOptions = null, CancellationToken cancellationToken = default) where TEntity : Entity { try { await GetCollection <TEntity> ().InsertManyAsync(entities, insertManyOptions, cancellationToken); } catch (TimeoutException ex) { _logger?.LogError($"Timeout Exception in SaveAsync method. Source: {ex.Source}"); } catch (MongoAuthenticationException ex) { _logger?.LogError($"Mongo Authentication Exception in SaveAsync method. Source: {ex.Source}"); } catch (Exception ex) { _logger?.LogError(ex, $"These records cannot be saved"); } }
//methods public virtual async Task Insert(List <SubscriberScheduleSettings <ObjectId> > periods) { var options = new InsertManyOptions() { IsOrdered = false }; await _collectionFactory .GetCollection <SubscriberScheduleSettings <ObjectId> >() .InsertManyAsync(periods, options) .ConfigureAwait(false); }
//methods public virtual async Task Insert(List <TTopic> settings) { var options = new InsertManyOptions() { IsOrdered = false }; await _collectionFactory .GetCollection <TTopic>() .InsertManyAsync(settings, options) .ConfigureAwait(false); }
//methods public virtual async Task Insert(List <StoredNotification <ObjectId> > items) { var options = new InsertManyOptions() { IsOrdered = true }; await _collectionFactory .GetCollection <StoredNotification <ObjectId> >() .InsertManyAsync(items, options) .ConfigureAwait(false); }
//Insert public virtual async Task Insert(List <SignalBounce <ObjectId> > messages) { var options = new InsertManyOptions() { IsOrdered = false }; await _collectionFactory .GetCollection <SignalBounce <ObjectId> >() .InsertManyAsync(messages, options) .ConfigureAwait(false); }
public async Task <Response <string> > SaveCache(MongoAccess mongo) { Response <string> response = new Response <string>(); var col = mongo.DBContext.GetCollection <GameModel>("games"); InsertManyOptions options = new InsertManyOptions(); options.BypassDocumentValidation = true; await col.InsertManyAsync(Cache, options); return(response); }
public MongoOutputAdapter(IConfigurationService configurationService, IVinterMongoDBClient dbClient) { this._configurationService = configurationService; this.dbClient = dbClient; this.database = null; this.frameCollection = null; this.bodyCollection = null; this._buffer = new List <MocapFrame>(); this._bufferSize = this._configurationService.GetConfiguration().Mongo.MongoBufferSize; this.Enabled = this._configurationService.GetConfiguration().Mongo.Enabled; this.Write = this._configurationService.GetConfiguration().Mongo.Write; this._insertOptions = new InsertManyOptions(); }
/// <summary> /// 创建多条数据 /// </summary> /// <param name="data">基于数据类的数据列表</param> /// <param name="option">创建参数</param> /// <returns>是否成功</returns> protected async Task <bool> CreateManyAsync(IEnumerable <T> data, InsertManyOptions option = null) { try { await DBContext.InsertManyAsync(data, option); return(true); } catch { return(false); } }
/// <summary> /// Dùng để insert Async một array documents /// </summary> /// <param name="arrT"></param> /// <param name="clientSession"></param> /// <returns></returns> public async Task InsertManyAsync(IList <T> arrT, IClientSessionHandle clientSession = null) { var options = new InsertManyOptions { IsOrdered = true }; if (clientSession == null) { await _collection.InsertManyAsync(arrT, options); } else { await _collection.InsertManyAsync(clientSession, arrT, options); } }
/// <summary>批量插入</summary> public async Task <AppDataSaveResult[]> InsertManyAsync(IndexDataSaveRequest <TDataSave> request) { var pairs = new List <PKSKeyValuePair <TDocument, AppDataSaveResult> >(); foreach (var value in request.Values) { var pair = await Validate(value, false); pairs.Add(pair); } var options = new InsertManyOptions(); await Accessor.InsertManyAsync(pairs.Select(e => e.Key)); return(pairs.Select(e => e.Value).ToArray()); }
public async Task InsertManyLesson(List <Lesson> lessons, CancellationToken cancellationToken = default) { var options = new InsertManyOptions { IsOrdered = false, BypassDocumentValidation = false }; try { await GetCollection().InsertManyAsync(lessons); } catch (Exception e) { Console.WriteLine(e.Message); } }