1

*这里是Mongo新手

我有一个包含数百个数字字段的文档，我需要组合查询这些字段。

var collection = _myDB.GetCollection<MyDocument>("collection");
IMongoQuery mongoQuery; // = Query.GT("field", value1).LT(value2);
foreach (MyObject queryObj in Queries)
{
    // I have several hundred fields such as Height, that are in queryObj
    // how do I build a "boolean" query in C# 
    mongoQuery = Query.GTE("Height", Convert.ToInt16(queryObj.Height * lowerbound));
}

我有数百个字段，例如高度（例如宽度、面积、周长等），在 queryObj 中我如何在 C# 中构建一个“布尔”查询，将每个字段的范围查询结合起来。

我尝试使用示例 Query.GT("field", value1).LT(value2);，但是编译器不接受 LT(Value) 构造。无论如何，我需要能够通过循环遍历每个数字字段值来构建复杂的布尔查询。

感谢您帮助新手。

4

1 回答 1

4

编辑 3：

好的，看起来您已经有了构建复杂查询的代码。在这种情况下，您只需要修复编译器问题。我假设您要执行以下操作(x > 20 && x < 40) && (y > 30 && y < 50)...

var collection = _myDB.GetCollection<MyDocument>("collection");
var queries = new List<IMongoQuery>();

foreach (MyObject queryObj in Queries)
{
    //I have several hundred fields such as Height, that are in queryObj
    //how do I build a "boolean" query in C# 

    var lowerBoundQuery = Query.GTE("Height", Convert.ToInt16(queryObj.Height * lowerbound));
    var upperBoundQuery = Query.LTE("Height", Convert.ToInt16(queryObj.Height * upperbound));

    var query = Query.And(lowerBoundQuery, upperBoundQuery);
    queries.Add(query);
}

var finalQuery = Query.And(queries); 
/*
    if you want to instead do an OR,
    var finalQuery = Query.Or(queries); 
*/

原始答案。

var list = _myDb.GetCollection<MyDoc>("CollectionName")
                .AsQueryable<MyDoc>()
                .Where(x => 
                         x.Height > 20 && 
                         x.Height < 40)
                .ToList();

我尝试使用示例 Query.GT("field", value1).LT(value2);，但是编译器不接受 LT(Value) 构造。

如果您使用的是官方 C# 驱动程序，则可以使用 linq 查询 MongoDB。这应该可以解决我认为的编译器问题。

我想到的更有趣的问题是，你将如何构造那个复杂的布尔查询？

一种选择是动态构建一个Expression，然后将其传递给Where

我的同事正在使用以下代码进行类似的操作...

    public static IQueryable<T> Where<T>(this IQueryable<T> query,
        string column, object value, WhereOperation operation)
    {
        if (string.IsNullOrEmpty(column))
            return query;

        ParameterExpression parameter = Expression.Parameter(query.ElementType, "p");

        MemberExpression memberAccess = null;
        foreach (var property in column.Split('.'))
            memberAccess = MemberExpression.Property
               (memberAccess ?? (parameter as Expression), property);

        //change param value type
        //necessary to getting bool from string
        ConstantExpression filter = Expression.Constant
            (
                Convert.ChangeType(value, memberAccess.Type)
            );

        //switch operation
        Expression condition = null;
        LambdaExpression lambda = null;
        switch (operation)
        {
            //equal ==
            case WhereOperation.Equal:
                condition = Expression.Equal(memberAccess, filter);
                lambda = Expression.Lambda(condition, parameter);
                break;
            //not equal !=
            case WhereOperation.NotEqual:
                condition = Expression.NotEqual(memberAccess, filter);
                lambda = Expression.Lambda(condition, parameter);
                break;
            //string.Contains()
            case WhereOperation.Contains:
                condition = Expression.Call(memberAccess,
                    typeof(string).GetMethod("Contains"),
                    Expression.Constant(value));
                lambda = Expression.Lambda(condition, parameter);
                break;
        }


        MethodCallExpression result = Expression.Call(
               typeof(Queryable), "Where",
               new[] { query.ElementType },
               query.Expression,
               lambda);

        return query.Provider.CreateQuery<T>(result);
    }

public enum WhereOperation
{
    Equal,
    NotEqual,
    Contains
}

目前它只支持==&& !=，但它应该不难实现>=或<=......

您可以从 Expression 类中获得一些提示：http: //msdn.microsoft.com/en-us/library/system.linq.expressions.expression.aspx

编辑：

var props = ["Height", "Weight", "Age"];
var query = _myDb.GetCollection<MyDoc>("CName").AsQueryable<MyDoc>();
foreach (var prop in props) 
{
   query = query.Where(prop, GetLowerLimit(queryObj, prop), WhereOperation.Between, GetUpperLimit(queryObj, prop));  
}
// the above query when iterated over, will result in a where clause that joins each individual `prop\condition` with an `AND`. 
// The code above will not compile. The `Where` function I wrote doesnt accept 4 parameters. You will need to implement the logic for that yourself. Though it ought to be straight forward I think...

编辑2：

如果你不想使用 linq，你仍然可以使用 Mongo Query。您只需要使用Query.And()and来制作您的查询Query.Or()。

        // I think this might be deprecated. Please refer the release notes for the C# driver version 1.5.0  
        Query.And(Query.GTE("Salary", new BsonDouble(20)), Query.LTE("Salary", new BsonDouble(40)), Query.GTE("Height", new BsonDouble(20)), Query.LTE("Height", new BsonDouble(40)))

        // strongly typed version
        new QueryBuilder<Employee>().And(Query<Employee>.GTE(x => x.Salary, 40), Query<Employee>.LTE(x => x.Salary, 60), Query<Employee>.GTE(x => x.HourlyRateToClients, 40), Query<Employee>.LTE(x => x.HourlyRateToClients, 60))
于 2012-07-26T11:45:55.493 回答