Azure Cosmos DB - Where 查询中的动态 OR 子句

Question

In my cosmos storage, my items have a collection of keywords. I would like to make a query which can filter the items which have at least one keyword of a list.

I tried the Intersect method:

query = query.Where(x => x.Keywords.Intersect(research.Kewords).Any())

But I got the exception "Method 'Intersect' is not supported"

So I tried the PredicateBuilder Method:

var pred = PredicateBuilder.False<Item>();
foreach (var k in research.Keywords)
   pred = pred.Or(x => x.Keywords.Contains(k));
 query = query.Where(pred);

But I got the exception "Expression with NodeType 'Invoke' is not supported"

Here my predicateBuilder:

public static Expression<Func<T, bool>> False<T>() { return f => false; }
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
{
    var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
    return Expression.Lambda<Func<T, bool>>
          (Expression.OrElse(expr1.Body, invokedExpr), expr1.Parameters);
}

Is there a way to achieve this inside Cosmos? Or I have to filter after the query result?

Answer 1

I've used a similar PredicateBuilder class in the past with a somewhat different implementation than you show. I can't go very far explaining it, as it was probably cribbed from SO and I neglected to document:).

With it, you should be able to use the form you show:

expression = PredicateBuilder.Or(expression, x.Keywords.Contains(k));

Implementation

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> True<T>() { return f => true; }
    public static Expression<Func<T, bool>> False<T>() { return f => false; }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
    {
        var secondBody = expr2.Body.Replace(expr2.Parameters[0], expr1.Parameters[0]);
        return Expression.Lambda<Func<T, bool>>(Expression.OrElse(expr1.Body, secondBody), expr1.Parameters);
    }

    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
    {
        if (expr2 != null)
        {
            var secondBody = expr2.Body.Replace(expr2.Parameters[0], expr1.Parameters[0]);
            return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(expr1.Body, secondBody), expr1.Parameters);
        }
        else
        {
            return expr1;
        }
    }

    public static Expression Replace(this Expression expression, Expression searchEx, Expression replaceEx)
    {
        return new ReplaceVisitor(searchEx, replaceEx).Visit(expression);
    }
}

internal class ReplaceVisitor : ExpressionVisitor
{
    private readonly Expression from, to;

    public ReplaceVisitor(Expression from, Expression to)
    {
        this.from = from;
        this.to = to;
    }

    public override Expression Visit(Expression node)
    {
        return node == from ? to : base.Visit(node);
    }
}