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