public UnifiedFindOneAndDeleteOperation Build(string targetCollectionId, BsonDocument arguments) { var collection = _entityMap.GetCollection(targetCollectionId); FilterDefinition <BsonDocument> filter = null; FindOneAndDeleteOptions <BsonDocument> options = null; foreach (var argument in arguments) { switch (argument.Name) { case "filter": filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument); break; case "hint": options ??= new FindOneAndDeleteOptions <BsonDocument>(); options.Hint = argument.Value; break; case "let": options ??= new FindOneAndDeleteOptions <BsonDocument>(); options.Let = argument.Value.AsBsonDocument; break; default: throw new FormatException($"Invalid FindOneAndDeleteOperation argument name: '{argument.Name}'."); } } return(new UnifiedFindOneAndDeleteOperation(collection, filter, options)); }
public FilterDefinition <T> Compile <T>(RqlExpression expression) { this.exp = expression; this.sb = new StringBuilder(); Visit(exp); string s = sb.ToString(); FilterDefinition <T> filter = null; if (!String.IsNullOrEmpty(s)) { try { filter = new BsonDocumentFilterDefinition <T>(BsonSerializer.Deserialize <BsonDocument>(s)); } catch { throw new RqlToMongoException("Invalid query specified"); } } this.sb = null; return(filter); }
// private methods private void ParseDeleteModel( BsonDocument model, out FilterDefinition <BsonDocument> filter, out BsonValue hint) { filter = null; hint = null; foreach (BsonElement argument in model.Elements) { switch (argument.Name) { case "hint": hint = argument.Value; break; case "filter": filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument); break; default: throw new FormatException($"Invalid BulkWrite Delete model argument name: '{argument.Name}'."); } } }
public virtual FilterDefinition <BsonDocument> GetFilter() { var queryString = GetQueryString(_queryString); var builder = Builders <BsonDocument> .Filter; FilterDefinition <BsonDocument> filter = new BsonDocumentFilterDefinition <BsonDocument>(new BsonDocument()); foreach (var query in queryString) { if (query.Key.Equals("page", StringComparison.InvariantCultureIgnoreCase) || query.Key.Equals("size", StringComparison.InvariantCultureIgnoreCase)) { continue; } var values = query.Value.Split(','); foreach (var value in values) { var criteriaFilter = builder.Eq(query.Key, value); if (filter != null) { filter = filter & criteriaFilter; } else { filter = criteriaFilter; } } } return(filter); }
/// <summary> /// 默认遍历规则/方法,不适用单条查询,默认查询未被关闭的数据集 /// </summary> public async Task <List <T> > DefaultQueryDataMethod <T>(string tableName, FilterDefinition <T> filter) where T : MongoEntity { var collection = _dataBase.GetCollection <T>(tableName); //查询器,如果不存在则构造,如果存在则检查是否添加此规则 if (filter == null) { var simpleQuery = new BsonDocument(); simpleQuery.Add(new BsonElement("closed", BsonValue.Create(false))); filter = new BsonDocumentFilterDefinition <T>(simpleQuery); } else { var simpleQuery = filter.ToBsonDocument(); if (!simpleQuery.Contains("closed")) { simpleQuery.Add(new BsonElement("closed", BsonValue.Create(false))); } filter = new BsonDocumentFilterDefinition <T>(simpleQuery); } List <T> results = new List <T>(); using (var cursor = await collection.FindAsync(filter)) { while (await cursor.MoveNextAsync()) { var batch = cursor.Current; foreach (var document in batch) { results.Add(document); } } } return(results); }
public UnifiedCountDocumentsOperation Build(string targetCollectionId, BsonDocument arguments) { var collection = _entityMap.GetCollection(targetCollectionId); FilterDefinition <BsonDocument> filter = null; CountOptions options = null; IClientSessionHandle session = null; foreach (var argument in arguments) { switch (argument.Name) { case "comment": options ??= new CountOptions(); options.Comment = argument.Value; break; case "filter": filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument); break; case "session": session = _entityMap.GetSession(argument.Value.AsString); break; default: throw new FormatException($"Invalid CountDocumentsOperation argument name: '{argument.Name}'."); } } return(new UnifiedCountDocumentsOperation(collection, filter, options, session)); }
public UnifiedReplaceOneOperation Build(string targetCollectionId, BsonDocument arguments) { var collection = _entityMap.GetCollection(targetCollectionId); FilterDefinition <BsonDocument> filter = null; ReplaceOptions options = null; BsonDocument replacement = null; foreach (var argument in arguments) { switch (argument.Name) { case "filter": filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument); break; case "replacement": replacement = argument.Value.AsBsonDocument; break; case "upsert": options = options ?? new ReplaceOptions(); options.IsUpsert = argument.Value.AsBoolean; break; default: throw new FormatException($"Invalid ReplaceOneOperation argument name: '{argument.Name}'."); } } return(new UnifiedReplaceOneOperation(collection, filter, replacement, options)); }
public UnifiedFindOneAndUpdateOperation Build(string targetCollectionId, BsonDocument arguments) { var collection = _entityMap.GetCollection(targetCollectionId); FilterDefinition <BsonDocument> filter = null; FindOneAndUpdateOptions <BsonDocument> options = null; UpdateDefinition <BsonDocument> update = null; IClientSessionHandle session = null; foreach (var argument in arguments) { switch (argument.Name) { case "filter": filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument); break; case "hint": options ??= new FindOneAndUpdateOptions <BsonDocument>(); options.Hint = argument.Value; break; case "returnDocument": options ??= new FindOneAndUpdateOptions <BsonDocument>(); options.ReturnDocument = (ReturnDocument)Enum.Parse(typeof(ReturnDocument), argument.Value.AsString); break; case "session": session = _entityMap.GetSession(argument.Value.AsString); break; case "sort": options ??= new FindOneAndUpdateOptions <BsonDocument>(); options.Sort = new BsonDocumentSortDefinition <BsonDocument>(argument.Value.AsBsonDocument); break; case "update": switch (argument.Value) { case BsonDocument: update = argument.Value.AsBsonDocument; break; case BsonArray: update = PipelineDefinition <BsonDocument, BsonDocument> .Create(argument.Value.AsBsonArray.Cast <BsonDocument>()); break; default: throw new FormatException($"Invalid FindOneAndUpdateOperation update argument: '{argument.Value}'."); } break; default: throw new FormatException($"Invalid FindOneAndUpdateOperation argument name: '{argument.Name}'."); } } return(new UnifiedFindOneAndUpdateOperation(collection, filter, update, session, options)); }
private static ReplaceOneModel <BsonDocument> CreateReplaceModel(BsonDocument filterFields, BsonDocument replacement, string[] keyFields, bool upsert) { var filter = new BsonDocumentFilterDefinition <BsonDocument>(new BsonDocument()); if (keyFields.Any()) { foreach (var field in keyFields) { filter.Document[field] = filterFields[field]; } } else { filter.Document["_id"] = filterFields["_id"]; } var model = new ReplaceOneModel <BsonDocument>(filter, replacement) { IsUpsert = upsert }; return(model); }
private DeleteOneModel <BsonDocument> ParseDeleteOneModel(BsonDocument model) { JsonDrivenHelper.EnsureAllFieldsAreValid(model, "filter"); var filter = new BsonDocumentFilterDefinition <BsonDocument>(model["filter"].AsBsonDocument); return(new DeleteOneModel <BsonDocument>(filter)); }
private UpdateOneModel <BsonDocument> ParseUpdateOne(BsonDocument request) { var filter = new BsonDocumentFilterDefinition <BsonDocument>((BsonDocument)request["filter"]); var update = new BsonDocumentUpdateDefinition <BsonDocument>((BsonDocument)request["update"]); var model = new UpdateOneModel <BsonDocument>(filter, update); model.IsUpsert = request.GetValue("upsert", false).ToBoolean(); return(model); }
/// <summary> /// Replaces document in DB, based on _id /// </summary> /// <param name="objectToSave"></param> public async Task <ReplaceOneResult> UpdateAsync(Tdb objectToSave) { FilterDefinition <Tdb> filter = new BsonDocumentFilterDefinition <Tdb>(new BsonDocument("_id", objectToSave.Id)); var updateOptions = new ReplaceOptions { IsUpsert = false }; // update or insert / upsert return(await Collection.ReplaceOneAsync(filter, objectToSave, updateOptions)); }
protected IFindFluent <TEntity, TEntity> FindFluent(BsonDocument doc, int pageIndex, int pageSize, object sortBy = null) { FilterDefinition <TEntity> filter = new BsonDocumentFilterDefinition <TEntity>(doc); IFindFluent <TEntity, TEntity> res = FindFluent(filter, sortBy); res.Skip((pageIndex - 1) * pageSize); res.Limit(pageSize); return(res); }
public UnifiedFindOperation Build(string targetCollectionId, BsonDocument arguments) { var collection = _entityMap.GetCollection(targetCollectionId); FilterDefinition <BsonDocument> filter = null; FindOptions <BsonDocument> options = null; IClientSessionHandle session = null; foreach (var argument in arguments) { switch (argument.Name) { case "allowDiskUse": options ??= new FindOptions <BsonDocument>(); options.AllowDiskUse = argument.Value.AsBoolean; break; case "batchSize": options ??= new FindOptions <BsonDocument>(); options.BatchSize = argument.Value.AsInt32; break; case "comment": options ??= new FindOptions <BsonDocument>(); options.Comment = argument.Value; break; case "filter": filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument); break; case "let": options ??= new FindOptions <BsonDocument>(); options.Let = argument.Value.AsBsonDocument; break; case "limit": options ??= new FindOptions <BsonDocument>(); options.Limit = argument.Value.AsInt32; break; case "session": session = _entityMap.GetSession(argument.Value.AsString); break; case "sort": options ??= new FindOptions <BsonDocument>(); options.Sort = new BsonDocumentSortDefinition <BsonDocument>(argument.Value.AsBsonDocument); break; default: throw new FormatException($"Invalid FindOperation argument name: '{argument.Name}'."); } } return(new UnifiedFindOperation(collection, filter, session, options)); }
public AppFront.CityList.City[] StartWith(string keyword) { string pattern = String.Format("(?i)^{0}", keyword); var startWithRegex = new BsonRegularExpression(pattern); var filter = new BsonDocumentFilterDefinition <BsonDocument>( new BsonDocument("name", startWithRegex)); var collection = database.GetCollection <BsonDocument>("allcity"); return(DoSearch(collection, filter)); }
/// <summary> /// 导出数据 /// </summary> /// <typeparam name="T">数据类型</typeparam> /// <param name="dataBaseName">数据集名</param> /// <param name="tableName">表名</param> /// <param name="pullAction">回调函数</param> protected void ExportFromDataBase <T>(string tableName, Action <List <T> > pullAction = null, Dictionary <string, string> filterDictionary = null) where T : MongoEntity { BsonDocumentFilterDefinition <T> filter = null; if (filterDictionary != null) { filter = BuildFilter <T>(filterDictionary); } _pull.PullData <T>(tableName, pullAction, filter); }
private DeleteManyModel <BsonDocument> ParseDeleteManyModel(BsonDocument model) { JsonDrivenHelper.EnsureAllFieldsAreValid(model, "name", "arguments"); var arguments = model["arguments"].AsBsonDocument; JsonDrivenHelper.EnsureAllFieldsAreValid(arguments, "filter"); var filter = new BsonDocumentFilterDefinition <BsonDocument>(arguments["filter"].AsBsonDocument); return(new DeleteManyModel <BsonDocument>(filter)); }
private void ProcessNeedMongoKeysState(CryptContext context, CancellationToken cancellationToken) { var filterBytes = context.GetOperation().ToArray(); var filterDocument = new RawBsonDocument(filterBytes); var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument); var cursor = _keyVaultCollection.Value.FindSync(filter, cancellationToken: cancellationToken); var results = cursor.ToList(cancellationToken); FeedResults(context, results); }
private ReplaceOneModel <BsonDocument> ParseReplaceOneModel(BsonDocument model) { JsonDrivenHelper.EnsureAllFieldsAreValid(model, "name", "arguments"); var arguments = model["arguments"].AsBsonDocument; JsonDrivenHelper.EnsureAllFieldsAreValid(arguments, "filter", "replacement"); var filter = new BsonDocumentFilterDefinition <BsonDocument>(arguments["filter"].AsBsonDocument); var replacement = arguments["replacement"].AsBsonDocument; return(new ReplaceOneModel <BsonDocument>(filter, replacement)); }
public async Task<Topic> Find(string id) { var filter = new BsonDocumentFilterDefinition<Topic>(new BsonDocument { { "_id", id } }); var result = await _collection.FindAsync(filter); return result.ToListAsync().Result.FirstOrDefault(); }
private async Task ProcessNeedMongoKeysStateAsync(CryptContext context, CancellationToken cancellationToken) { var filterBytes = context.GetOperation().ToArray(); var filterDocument = new RawBsonDocument(filterBytes); var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument); var cursor = await _keyVaultCollection.Value.FindAsync(filter, cancellationToken : cancellationToken).ConfigureAwait(false); var results = await cursor.ToListAsync(cancellationToken).ConfigureAwait(false); FeedResults(context, results); }
private void Test <TException>(string json) where TException : Exception { var collection = new FakeMongoCollection <SimpleTestDocument>(); var bson = BsonDocument.Parse(json); var filter = new BsonDocumentFilterDefinition <SimpleTestDocument>(bson); Action action = () => collection.Find(filter).ToList(); action.ShouldThrow <TException>(); }
public AgileHouseUser Get(string id) { ObjectId objectId; ObjectId.TryParse(id, out objectId); var filter = new BsonDocumentFilterDefinition <AgileHouseUser>(new BsonDocument(new BsonElement("_id", objectId))); return(_users.Find(filter).FirstOrDefault()); //return _users.Find<AgileHouseUser>().First(); }
public async Task <ReceivedMessage> GetNextAsync() { var now = DateTime.UtcNow; var receiveTimeCriteria = new BsonDocument { { "$lt", now.Subtract(_config.DefaultMessageLease) } }; var filter = new BsonDocumentFilterDefinition <BsonDocument>(new BsonDocument { { Fields.DestinationQueueName, QueueName }, { Fields.ReceiveTime, receiveTimeCriteria }, { Fields.DeliveryAttempts, new BsonDocument { { "$lt", _config.MaxDeliveryAttempts } } }, }); var update = new BsonDocumentUpdateDefinition <BsonDocument>(new BsonDocument { { "$set", new BsonDocument { { Fields.ReceiveTime, now } } }, { "$inc", new BsonDocument { { Fields.DeliveryAttempts, 1 } } } }); var options = new FindOneAndUpdateOptions <BsonDocument> { ReturnDocument = ReturnDocument.After }; var collection = _config.Collection; await _semaphore.WaitAsync(); try { var document = await collection.FindOneAndUpdateAsync(filter, update, options); if (document == null) { return(null); } return(GetReceivedMessage(document)); } finally { _semaphore.Release(); } }
/// <summary> /// Replace or insert document in DB /// </summary> /// <param name="objectToSave"></param> public async Task SaveAsync(Tdb objectToSave) { if (objectToSave.Id == ObjectId.Empty) { objectToSave.Id = ObjectId.GenerateNewId(DateTime.Now); } FilterDefinition <Tdb> filter = new BsonDocumentFilterDefinition <Tdb>(new BsonDocument("_id", objectToSave.Id)); var updateOptions = new ReplaceOptions { IsUpsert = true }; // update or insert / upsert await Collection.ReplaceOneAsync(filter, objectToSave, updateOptions); }
private ReplaceOneModel <BsonDocument> ParseReplaceOneModel(BsonDocument model) { JsonDrivenHelper.EnsureAllFieldsAreValid(model, "filter", "replacement", "upsert"); var filter = new BsonDocumentFilterDefinition <BsonDocument>(model["filter"].AsBsonDocument); var replacement = model["replacement"].AsBsonDocument; var isUpsert = model.GetValue("upsert", false).ToBoolean(); return(new ReplaceOneModel <BsonDocument>(filter, replacement) { IsUpsert = isUpsert }); }
public Task <DeleteResult> DeleteManyAsync <T>(FilterDefinition <T> filter = null) where T : DocumentBase { if (filter == null) { // empty filter to delete all filter = new BsonDocumentFilterDefinition <T>(new MongoDB.Bson.BsonDocument()); } var collection = CollectionResolver.Get <T>(_database); return(collection.DeleteManyAsync(filter)); }
private UpdateOneModel <BsonDocument> ParseUpdateOneModel(BsonDocument model) { JsonDrivenHelper.EnsureAllFieldsAreValid(model, "filter", "update", "upsert"); var filter = new BsonDocumentFilterDefinition <BsonDocument>(model["filter"].AsBsonDocument); var update = new BsonDocumentUpdateDefinition <BsonDocument>(model["update"].AsBsonDocument); var isUpsert = model.GetValue("upsert", false).ToBoolean(); return(new UpdateOneModel <BsonDocument>(filter, update) { IsUpsert = isUpsert }); }
// private methods private void ProcessNeedCollectionInfoState(CryptContext context, string databaseName, CancellationToken cancellationToken) { var database = _client.GetDatabase(databaseName); var filterBytes = context.GetOperation().ToArray(); var filterDocument = new RawBsonDocument(filterBytes); var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument); var options = new ListCollectionsOptions { Filter = filter }; var cursor = database.ListCollections(options, cancellationToken); var results = cursor.ToList(cancellationToken); FeedResults(context, results); }
private async Task ProcessNeedCollectionInfoStateAsync(CryptContext context, string databaseName, CancellationToken cancellationToken) { var database = _client.GetDatabase(databaseName); var filterBytes = context.GetOperation().ToArray(); var filterDocument = new RawBsonDocument(filterBytes); var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument); var options = new ListCollectionsOptions { Filter = filter }; var cursor = await database.ListCollectionsAsync(options, cancellationToken).ConfigureAwait(false); var results = await cursor.ToListAsync(cancellationToken).ConfigureAwait(false); FeedResults(context, results); }
public Task <UpdateResult> UpdateAsync <T>(UpdateDefinition <T> updateDefinition, FilterDefinition <T> filter = null, UpdateOptions updateOptions = null) where T : DocumentBase { if (filter == null) { //empty filter filter = new BsonDocumentFilterDefinition <T>(new BsonDocument()); } var collection = CollectionResolver.Get <T>(_database); return(collection.UpdateManyAsync(filter, updateDefinition, updateOptions)); }
private DeleteOneModel<BsonDocument> ParseDeleteOne(BsonDocument request) { var filter = new BsonDocumentFilterDefinition<BsonDocument>((BsonDocument)request["filter"]); return new DeleteOneModel<BsonDocument>(filter); }
private UpdateOneModel<BsonDocument> ParseUpdateOne(BsonDocument request) { var filter = new BsonDocumentFilterDefinition<BsonDocument>((BsonDocument)request["filter"]); var update = new BsonDocumentUpdateDefinition<BsonDocument>((BsonDocument)request["update"]); var model = new UpdateOneModel<BsonDocument>(filter, update); model.IsUpsert = request.GetValue("upsert", false).ToBoolean(); return model; }