statler
commented
6 years ago First up, this is essential, but I don't think that 'contains' is the right operator. I would prefer to see the collection annotated as such, and normal operators used - for example for a person object with a collection of tasks
[['Tasks[].DateActioned', '=', null] to get open tasks.
The reason for this is that it provides full access to all operators. Also, it ensures that grouping is available with the original intent. For example, if you apply two contains operators to the same collection, it is unclear whether you want records where the collection contains at least one object meeting each condition separately, or the same object meeting both conditions. In contrast, the following is unambiguous.
[['Tasks[].ActionRequiredDate', '<=', new Date],'and', ['Tasks[].DateActioned', '<>', null]])Anyway, it turns out that this is also far easier and more concise to code. If you replace your FilterExpressionCompiler with the following, then filtering by nested collections works. It would be great if you could tidy it up as you require and integrate this into the code base. Anyone else can feel free to use it.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace DevExtreme.AspNet.Data {
class FilterExpressionCompiler<T> : ExpressionCompiler {
const string
CONTAINS = "contains",
NOT_CONTAINS = "notcontains",
STARTS_WITH = "startswith",
ENDS_WITH = "endswith";
bool _stringToLower;
ParameterExpression rootParamExpression;
public FilterExpressionCompiler(bool guardNulls, bool stringToLower = false)
: base(guardNulls) {
rootParamExpression = CreateItemParam(typeof(T));
_stringToLower = stringToLower;
}
public LambdaExpression Compile(IList criteriaJson) {
var result = Expression.Lambda(CompileCore(rootParamExpression, criteriaJson), rootParamExpression);
var a = result.Compile();
return result;
}
Expression CompileCore(ParameterExpression dataItemExpr, IList criteriaJson) {
if(IsCriteria(criteriaJson[0]))
return CompileGroup(dataItemExpr, criteriaJson);
if(IsUnary(criteriaJson)) {
return CompileUnary(dataItemExpr, criteriaJson);
}
var clientAccessor = Convert.ToString(criteriaJson[0]);
if(clientAccessor.Contains("[]")) return CompileCollection(dataItemExpr, criteriaJson);
return CompileBinary(dataItemExpr, criteriaJson);
}
Expression CompileGroup(ParameterExpression dataItemExpr, IList criteriaJson) {
var operands = new List<Expression>();
var isAnd = true;
var nextIsAnd = true;
ArrayList CollectionCriteria = new ArrayList();
foreach(var item in criteriaJson) {
var operandJson = item as IList;
if(IsCriteria(operandJson)) {
if(operands.Count > 1 && isAnd != nextIsAnd)
throw new ArgumentException("Mixing of and/or is not allowed inside a single group");
isAnd = nextIsAnd;
bool isCollection = !(operandJson[0] is IList) && operandJson[0].ToString().Contains("[]");
if(isCollection) CollectionCriteria.Add(item);
else operands.Add(CompileCore(dataItemExpr, operandJson));
nextIsAnd = true;
} else {
nextIsAnd = Regex.IsMatch(Convert.ToString(item), "and|&", RegexOptions.IgnoreCase);
}
}
if(CollectionCriteria.Count > 0) {
List<Expression> CollectionOperands = GetCollectionOperands(dataItemExpr, CollectionCriteria, isAnd);
operands.AddRange(CollectionOperands);
}
Expression result = null;
var op = isAnd ? ExpressionType.AndAlso : ExpressionType.OrElse;
foreach(var operand in operands) {
if(result == null)
result = operand;
else
result = Expression.MakeBinary(op, result, operand);
}
return result;
}
//This doesnt get called but left it here for reference. Work is done in CompileGroups
Expression CompileCollection(ParameterExpression dataItemExpr, IList criteriaJson) {
var CollectionOperators = GetCollectionOperands(dataItemExpr, new ArrayList() { criteriaJson }, true);
return CollectionOperators[0];
}
Expression CompileBinary(ParameterExpression dataItemExpr, IList criteriaJson) {
var hasExplicitOperation = criteriaJson.Count > 2;
var clientAccessor = Convert.ToString(criteriaJson[0]);
var clientOperation = hasExplicitOperation ? Convert.ToString(criteriaJson[1]).ToLower() : "=";
var clientValue = criteriaJson[hasExplicitOperation ? 2 : 1];
var isStringOperation = clientOperation == CONTAINS || clientOperation == NOT_CONTAINS || clientOperation == STARTS_WITH || clientOperation == ENDS_WITH;
var accessorExpr = CompileAccessorExpression(dataItemExpr, clientAccessor, progression => {
if(isStringOperation || clientAccessor is String && progression.Last().Type == typeof(Object))
ForceToString(progression);
if(_stringToLower)
AddToLower(progression);
});
if(isStringOperation) {
return CompileStringFunction(accessorExpr, clientOperation, Convert.ToString(clientValue));
} else {
var useDynamicBinding = accessorExpr.Type == typeof(Object);
var expressionType = TranslateBinaryOperation(clientOperation);
if(!useDynamicBinding) {
try {
clientValue = Utils.ConvertClientValue(clientValue, accessorExpr.Type);
} catch {
return Expression.Constant(false);
}
}
if(clientValue == null && !Utils.CanAssignNull(accessorExpr.Type)) {
switch(expressionType) {
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
return Expression.Constant(false);
case ExpressionType.Equal:
case ExpressionType.NotEqual:
accessorExpr = Expression.Convert(accessorExpr, Utils.MakeNullable(accessorExpr.Type));
break;
}
}
if(_stringToLower && clientValue is String)
clientValue = ((string)clientValue).ToLower();
Expression valueExpr = Expression.Constant(clientValue, accessorExpr.Type);
if(accessorExpr.Type == typeof(String) && IsInequality(expressionType)) {
var compareMethod = typeof(String).GetMethod(nameof(String.Compare), new[] { typeof(String), typeof(String) });
accessorExpr = Expression.Call(null, compareMethod, accessorExpr, valueExpr);
valueExpr = Expression.Constant(0);
} else if(useDynamicBinding) {
accessorExpr = Expression.Call(typeof(Utils).GetMethod(nameof(Utils.DynamicCompare)), accessorExpr, valueExpr);
valueExpr = Expression.Constant(0);
}
return Expression.MakeBinary(expressionType, accessorExpr, valueExpr);
}
}
bool IsInequality(ExpressionType type) {
return type == ExpressionType.LessThan || type == ExpressionType.LessThanOrEqual || type == ExpressionType.GreaterThanOrEqual || type == ExpressionType.GreaterThan;
}
Expression CompileStringFunction(Expression accessorExpr, string clientOperation, string value) {
if(_stringToLower && value != null)
value = value.ToLower();
var invert = false;
if(clientOperation == NOT_CONTAINS) {
clientOperation = CONTAINS;
invert = true;
}
if(GuardNulls)
accessorExpr = Expression.Coalesce(accessorExpr, Expression.Constant(""));
var operationMethod = typeof(String).GetMethod(GetStringOperationMethodName(clientOperation), new[] { typeof(String) });
Expression result = Expression.Call(accessorExpr, operationMethod, Expression.Constant(value));
if(invert)
result = Expression.Not(result);
return result;
}
Expression CompileUnary(ParameterExpression dataItemExpr, IList criteriaJson) {
return Expression.Not(CompileCore(dataItemExpr, (IList)criteriaJson[1]));
}
ExpressionType TranslateBinaryOperation(string clientOperation) {
switch(clientOperation) {
case "=":
return ExpressionType.Equal;
case "<>":
return ExpressionType.NotEqual;
case ">":
return ExpressionType.GreaterThan;
case ">=":
return ExpressionType.GreaterThanOrEqual;
case "<":
return ExpressionType.LessThan;
case "<=":
return ExpressionType.LessThanOrEqual;
}
throw new NotSupportedException();
}
bool IsCriteria(object item) {
return item is IList && !(item is String);
}
internal bool IsUnary(IList criteriaJson) {
return Convert.ToString(criteriaJson[0]) == "!";
}
string GetStringOperationMethodName(string clientOperation) {
if(clientOperation == STARTS_WITH)
return nameof(String.StartsWith);
if(clientOperation == ENDS_WITH)
return nameof(String.EndsWith);
return nameof(String.Contains);
}
static void AddToLower(List<Expression> progression) {
var last = progression.Last();
if(last.Type != typeof(String))
return;
var toLowerMethod = typeof(String).GetMethod(nameof(String.ToLower), Type.EmptyTypes);
var toLowerCall = Expression.Call(last, toLowerMethod);
if(last is MethodCallExpression lastCall && lastCall.Method.Name == nameof(ToString))
progression.RemoveAt(progression.Count - 1);
progression.Add(toLowerCall);
}
private List<Expression> GetCollectionOperands(ParameterExpression dataItemExpr, IList CollectionCriteria, bool isAnd) {
Dictionary<string, IList> dctCollection = GetCollectionCriteriaDictionary(isAnd, CollectionCriteria);
var operands = new List<Expression>();
foreach(KeyValuePair<string, IList> coll in dctCollection) {
Expression fieldCondition = CompileCollectionFunction(dataItemExpr, coll.Key, coll.Value);
operands.Add(fieldCondition);
}
return operands;
}
private Expression CompileCollectionFunction(ParameterExpression dataItemExpr, string CollectionProperty, IList CollectionCriteria) {
var accessorExpr = CompileAccessorExpression(dataItemExpr, CollectionProperty, progression => {
if(CollectionProperty is String && progression.Last().Type == typeof(Object))
ForceToString(progression);
if(_stringToLower)
AddToLower(progression);
});
Type genericType = accessorExpr.Type.GetGenericArguments().Single();
var fieldParameter = Expression.Parameter(genericType, "field");
var oper = CompileCore(fieldParameter, CollectionCriteria as IList);
var anyPredicate = Expression.Lambda(oper, fieldParameter);
var fieldCondition = Expression.Call(typeof(Enumerable), "Any", new[] { fieldParameter.Type }, accessorExpr, anyPredicate);
return fieldCondition;
}
private static Dictionary<string, IList> GetCollectionCriteriaDictionary(bool isAnd, IList CollectionCriteria) {
Dictionary<string, IList> dctCollection = new Dictionary<string, IList>();
foreach(object c in CollectionCriteria) {
var operandJson = c as IList;
if(operandJson is null) continue;
var collSplit = operandJson[0].ToString().Split(new string[] { "[]." }, StringSplitOptions.None);
ArrayList newoperandJson = new ArrayList();
for(int i = 0; i < operandJson.Count; i++) {
if(i == 0) newoperandJson.Add(collSplit[1]);
else newoperandJson.Add(operandJson[i]);
}
if(collSplit.Count() > 1) {
string collection = collSplit[0];
if(dctCollection.ContainsKey(collection)) {
dctCollection[collection].Add(isAnd ? "and" : "or");
dctCollection[collection].Add(newoperandJson);
} else dctCollection.Add(collection, new ArrayList() { newoperandJson });
}
}
return dctCollection;
}
}
}
AlekseyMartynov
Bykiev
frankiDotNet
shahabfar
MattDBP
Requested by DevExtreme users:
Potentially useful for non-relational LINQ providers (Mongo, etc).