Question

*Mongo Newbie here

I have a document containing several hundred numeric fields which I need to query in combination.

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

I have several hundred fields such as Height (e.g. Width, Area, Perimeter etc.), that are in queryObj how do I build a “boolean” query in C# that combines range queries for each field in conjunction.

I have tried to use the example Query.GT(“field”, value1).LT(value2);, however the compiler does not accept the LT(Value) construct. In any event I need to be able to build a complex boolean query by looping through each of the numeric field values.

Thanks for helping a newbie out.

Answer 1

EDIT 3:

Ok, it looks like you already have code in place to build the complicated query. In that case, you just needed to fix the compiler issue. Am assuming you want to do the following (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); 
*/

---

Original Answer.

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

I have tried to use the example Query.GT(“field”, value1).LT(value2);,
however the compiler does not accept the LT(Value) construct.

You can query MongoDB using linq, if you are using the official C# driver. That ought to solve the compiler issue I think.

The more interesting question I have in mind is, how are you going to construct that complicated boolean query?

One option is to dynamically build an Expression and then pass that to the Where

My colleague is using the following code for something similar…

    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
}

Currently it only supports == && !=, but it shouldn’t be that difficult to implement >= or <= …

You could get some hints from the Expression class: http://msdn.microsoft.com/en-us/library/system.linq.expressions.expression.aspx

EDIT:

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... 

EDIT 2:

If you don’t want to use linq, you can still use Mongo Query. You will just need to craft your queries using the 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))