public Expression <Func <T, bool> > IsNullComparator <T>(ParameterExpression parameter, RsqlParser.ComparisonContext context) { parameter = parameter ?? throw new ArgumentNullException(nameof(parameter)); context = context ?? throw new ArgumentNullException(nameof(context)); var expressionPath = this._propertyAccessor.ParsePath(parameter, context.selector().GetText()); var value = (bool)ComparisonBuilder.GetSingleValue(typeof(bool), context); var lastNullableExpression = expressionPath.ExpressionSteps.LastOrDefault(e => ComparisonBuilder.CanBeNull(e.Type)); if (lastNullableExpression == null) { // Can never be null return(Expression.Lambda <Func <T, bool> >(Expression.Constant(!value), parameter)); } var result = Expression.Lambda <Func <T, bool> >( ComparisonBuilder.PathCanBeNull( expressionPath, Expression.Equal( lastNullableExpression, Expression.Constant(null, typeof(object)))), parameter); if (value) { return(result); } var body = Expression.Not(result.Body); result = Expression.Lambda <Func <T, bool> >(body, parameter); return(result); }
private static Expression CheckNullInPath( IReadOnlyList <Expression> steps, bool canBeNull, Expression compare, bool ignoreLast) { steps = steps ?? throw new ArgumentNullException(nameof(steps)); compare = compare ?? throw new ArgumentNullException(nameof(compare)); var result = compare; var combiner = canBeNull ? (Func <Expression, Expression, Expression>)Expression.OrElse : Expression.AndAlso; var comparer = canBeNull ? (Func <Expression, Expression, Expression>)Expression.Equal : Expression.NotEqual; var until = ignoreLast ? steps.Count - 1 : steps.Count; for (var i = until - 1; i >= 0; i--) { var property = steps[i]; if (ComparisonBuilder.CanBeNull(property.Type)) { result = combiner( comparer( property, Expression.Constant(null, typeof(object))), result); } } return(result); }
public Expression <Func <T, bool> > GreaterOrEqualComparator <T>(ParameterExpression parameter, RsqlParser.ComparisonContext context) { parameter = parameter ?? throw new ArgumentNullException(nameof(parameter)); context = context ?? throw new ArgumentNullException(nameof(context)); var expressionPath = this._propertyAccessor.ParsePath(parameter, context.selector().GetText()); this.EnsureComparable(expressionPath.Type, context); var value = ComparisonBuilder.GetSingleValue(expressionPath.Type, context); return(Expression.Lambda <Func <T, bool> >( ComparisonBuilder.PathNotNull( expressionPath, Expression.GreaterThanOrEqual( expressionPath.Expression, Expression.Constant(value, expressionPath.Type))), parameter)); }
public Expression <Func <T, bool> > LikeComparator <T>(ParameterExpression parameter, RsqlParser.ComparisonContext context) { parameter = parameter ?? throw new ArgumentNullException(nameof(parameter)); context = context ?? throw new ArgumentNullException(nameof(context)); var expressionPath = this._propertyAccessor.ParsePath(parameter, context.selector().GetText()); if (expressionPath.Type != typeof(string)) { throw new InvalidComparatorException(context); } var like = (string)ComparisonBuilder.GetSingleValue(expressionPath.Type, context); like = like.Replace(@"\*", ComparisonBuilder.EscapedLikePlaceholder); MethodInfo method; var startsWild = like.StartsWith("*"); var endsWild = like.EndsWith("*"); if (!startsWild && endsWild) { method = ContainsHelper.StringStartsWithMethod; } else if (startsWild && !endsWild) { method = ContainsHelper.StringEndsWithMethod; } else { method = ContainsHelper.StringContainsMethod; } like = like.Replace("*", string.Empty).Replace(ComparisonBuilder.EscapedLikePlaceholder, "*"); return(Expression.Lambda <Func <T, bool> >( ComparisonBuilder.FullPathNotNull( expressionPath, Expression.Call( expressionPath.Expression, method, Expression.Constant(like, expressionPath.Type))), parameter)); }
public Expression <Func <T, bool> > InComparator <T>(ParameterExpression parameter, RsqlParser.ComparisonContext context) { parameter = parameter ?? throw new ArgumentNullException(nameof(parameter)); context = context ?? throw new ArgumentNullException(nameof(context)); var expressionPath = this._propertyAccessor.ParsePath(parameter, context.selector().GetText()); this.EnsureEquatable(expressionPath.Type, context); var values = ValueParser.GetValues(expressionPath.Type, context.arguments()); var methodContainsInfo = ContainsHelper.GetOrRegistryContainsMethodInfo(expressionPath.Type); return(Expression.Lambda <Func <T, bool> >( ComparisonBuilder.PathNotNull( expressionPath, Expression.Call( Expression.Constant(methodContainsInfo.Convert(values)), methodContainsInfo.ContainsMethod, expressionPath.Expression)), parameter)); }
public Expression <Func <T, bool> > EqualComparator <T>(ParameterExpression parameter, RsqlParser.ComparisonContext context) { parameter = parameter ?? throw new ArgumentNullException(nameof(parameter)); context = context ?? throw new ArgumentNullException(nameof(context)); var expressionPath = this._propertyAccessor.ParsePath(parameter, context.selector().GetText()); this.EnsureEquatable(expressionPath.Type, context); var value = ComparisonBuilder.GetSingleValue(expressionPath.Type, context); if (expressionPath.Type != typeof(string)) { return(Expression.Lambda <Func <T, bool> >( ComparisonBuilder.PathNotNull( expressionPath, Expression.Equal( expressionPath.Expression, Expression.Constant(value, expressionPath.Type) )), parameter)); } var escapedLike = ((string)value).Replace(@"\*", ComparisonBuilder.EscapedLikePlaceholder); if (escapedLike.Contains('*')) { return(this.LikeComparator <T>(parameter, context)); } escapedLike = escapedLike.Replace(ComparisonBuilder.EscapedLikePlaceholder, "*"); return(Expression.Lambda <Func <T, bool> >( ComparisonBuilder.PathNotNull( expressionPath, Expression.Equal( expressionPath.Expression, Expression.Constant(escapedLike, expressionPath.Type))), parameter)); }
public RsqlVisitor(ComparisonBuilder expressionHelper) { this._expressionHelper = expressionHelper ?? throw new ArgumentNullException(nameof(expressionHelper)); this._parameter = Expression.Parameter(typeof(T), "x"); }
public static Expression FullPathNotNull(ExpressionPath expressionPath, Expression compare) { expressionPath = expressionPath ?? throw new ArgumentNullException(nameof(expressionPath)); return(ComparisonBuilder.CheckNullInPath(expressionPath.ExpressionSteps, false, compare, false)); }