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