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