LINQ to Entities - where..in clause with multiple columns

Question

I\'m trying to query data of the form with LINQ-to-EF:

class Location {
    string Country;
    string City;
    string Address;
    …
}

by

Answer 1

Although I couldn't get @YvesDarmaillac's code to work, it pointed me to this solution.

You can build an expression and then add each condition separately. To do this, you can use the Universal PredicateBuilder (source at the end).

Here's my code:

// First we create an Expression. Since we can't create an empty one,
// we make it return false, since we'll connect the subsequent ones with "Or".
// The following could also be: Expression> condition = (x => false); 
// but this is clearer.
var condition = PredicateBuilder.Create(x => false);

foreach (var key in keys)
{
    // each one returns a new Expression
    condition = condition.Or(
        x => x.Country == key.Country && x.City == key.City && x.Address == key.Address
    );
}

using (var ctx = new MyContext())
{
    var locations = ctx.Locations.Where(condition);
}

One thing to beware of, though, is that the filter list (the keys variable in this example) can't be too large, or you may reach the parameters limit, with an exception like this:

SqlException: The incoming request has too many parameters. The server supports a maximum of 2100 parameters. Reduce the number of parameters and resend the request.

So, in this example (with three parameters per line), you can't have more than 700 Locations to filter.

Using two items to filter, it will generate 6 parameters in the final SQL. The generated SQL will look like below (formatted to be clearer):

exec sp_executesql N'
SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent1].[Country] AS [Country], 
    [Extent1].[City] AS [City], 
    [Extent1].[Address] AS [Address]
FROM [dbo].[Locations] AS [Extent1]
WHERE 
    (
        (
            ([Extent1].[Country] = @p__linq__0) 
            OR 
            (([Extent1].[Country] IS NULL) AND (@p__linq__0 IS NULL))
        )
        AND 
        (
            ([Extent1].[City] = @p__linq__1) 
            OR 
            (([Extent1].[City] IS NULL) AND (@p__linq__1 IS NULL))
        ) 
        AND 
        (
            ([Extent1].[Address] = @p__linq__2) 
            OR 
            (([Extent1].[Address] IS NULL) AND (@p__linq__2 IS NULL))
        )
    )
    OR
    (
        (
            ([Extent1].[Country] = @p__linq__3) 
            OR 
            (([Extent1].[Country] IS NULL) AND (@p__linq__3 IS NULL))
        )
        AND 
        (
            ([Extent1].[City] = @p__linq__4) 
            OR 
            (([Extent1].[City] IS NULL) AND (@p__linq__4 IS NULL))
        ) 
        AND 
        (
            ([Extent1].[Address] = @p__linq__5) 
            OR 
            (([Extent1].[Address] IS NULL) AND (@p__linq__5 IS NULL))
        )
    )
',
N'
    @p__linq__0 nvarchar(4000),
    @p__linq__1 nvarchar(4000),
    @p__linq__2 nvarchar(4000),
    @p__linq__3 nvarchar(4000),
    @p__linq__4 nvarchar(4000),
    @p__linq__5 nvarchar(4000)
',
@p__linq__0=N'USA',
@p__linq__1=N'NY',
@p__linq__2=N'Add1',
@p__linq__3=N'UK',
@p__linq__4=N'London',
@p__linq__5=N'Add2'

Notice how the initial "false" expression is properly ignored and not included in the final SQL by EntityFramework.

Finally, here's the code for the Universal PredicateBuilder, for the record.

/// 

/// Enables the efficient, dynamic composition of query predicates.
/// 
public static class PredicateBuilder
{
    /// 

    /// Creates a predicate that evaluates to true.
    /// 
    public static Expression> True() { return param => true; }

    /// 

    /// Creates a predicate that evaluates to false.
    /// 
    public static Expression> False() { return param => false; }

    /// 

    /// Creates a predicate expression from the specified lambda expression.
    /// 
    public static Expression> Create(Expression> predicate) { return predicate; }

    /// 

    /// Combines the first predicate with the second using the logical "and".
    /// 
    public static Expression> And(this Expression> first, Expression> second)
    {
        return first.Compose(second, Expression.AndAlso);
    }

    /// 

    /// Combines the first predicate with the second using the logical "or".
    /// 
    public static Expression> Or(this Expression> first, Expression> second)
    {
        return first.Compose(second, Expression.OrElse);
    }

    /// 

    /// Negates the predicate.
    /// 
    public static Expression> Not(this Expression> expression)
    {
        var negated = Expression.Not(expression.Body);
        return Expression.Lambda>(negated, expression.Parameters);
    }

    /// 

    /// Combines the first expression with the second using the specified merge function.
    /// 
    static Expression Compose(this Expression first, Expression second, Func merge)
    {
        // zip parameters (map from parameters of second to parameters of first)
        var map = first.Parameters
            .Select((f, i) => new { f, s = second.Parameters[i] })
            .ToDictionary(p => p.s, p => p.f);

        // replace parameters in the second lambda expression with the parameters in the first
        var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);

        // create a merged lambda expression with parameters from the first expression
        return Expression.Lambda(merge(first.Body, secondBody), first.Parameters);
    }

    class ParameterRebinder : ExpressionVisitor
    {
        readonly Dictionary map;

        ParameterRebinder(Dictionary map)
        {
            this.map = map ?? new Dictionary();
        }

        public static Expression ReplaceParameters(Dictionary map, Expression exp)
        {
            return new ParameterRebinder(map).Visit(exp);
        }

        protected override Expression VisitParameter(ParameterExpression p)
        {
            ParameterExpression replacement;

            if (map.TryGetValue(p, out replacement))
            {
                p = replacement;
            }

            return base.VisitParameter(p);
        }
    }
}