/// <summary>Prepare the given expression for passing as a predicate to a filter function
/// i.e. Queryable.Where()/Enumerable.Any()/Enumerable.All().
/// </summary>
/// <param name="expr">Input expression.</param>
/// <returns>Expression converted to boolean expression.</returns>
internal static Expression EnsurePredicateExpressionIsBoolean(Expression expr)
{
if (OpenTypeMethods.IsOpenPropertyExpression(expr))
{
expr = OpenTypeMethods.EqualExpression(expr, Expression.Constant(true, typeof(object)));
expr = Expression.Convert(expr, typeof(bool));
}
else if (IsNullConstant(expr))
{
expr = falseLiteral;
}
else if (expr.Type == typeof(bool?))
{
Expression test = Expression.Equal(expr, Expression.Constant(null, typeof(bool?)));
expr = Expression.Condition(test, falseLiteral, Expression.Property(expr, "Value"));
}
if (expr.Type != typeof(bool))
{
string message = Strings.RequestQueryParser_ExpressionTypeMismatch(WebUtil.GetTypeName(typeof(bool)));
throw DataServiceException.CreateSyntaxError(message);
}
return(expr);
}
/// <summary>Generates a Logical Or expression.</summary>
/// <param name="left">Left expression.</param>
/// <param name="right">Right expression.</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateLogicalOr(Expression left, Expression right)
{
if (OpenTypeMethods.IsOpenPropertyExpression(left) || OpenTypeMethods.IsOpenPropertyExpression(right))
{
return(OpenTypeMethods.OrElseExpression(left, right));
}
return(Expression.OrElse(left, right));
}
/// <summary>Generates a logical And expression.</summary>
/// <param name="left">Left expression.</param>
/// <param name="right">Right expression.</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateLogicalAnd(Expression left, Expression right)
{
if (OpenTypeMethods.IsOpenPropertyExpression(left) || OpenTypeMethods.IsOpenPropertyExpression(right))
{
return(OpenTypeMethods.AndAlsoExpression(left, right));
}
return(Expression.AndAlso(left, right));
}
/// <summary>Generates a modulo expression.</summary>
/// <param name="left">Left expression.</param>
/// <param name="right">Right expression.</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateModulo(Expression left, Expression right)
{
if (OpenTypeMethods.IsOpenPropertyExpression(left) || OpenTypeMethods.IsOpenPropertyExpression(right))
{
return(OpenTypeMethods.ModuloExpression(left, right));
}
return(Expression.Modulo(left, right));
}
/// <summary>Generates a divide expression.</summary>
/// <param name="left">Left expression.</param>
/// <param name="right">Right expression.</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateDivide(Expression left, Expression right)
{
if (OpenTypeMethods.IsOpenPropertyExpression(left) || OpenTypeMethods.IsOpenPropertyExpression(right))
{
return(OpenTypeMethods.DivideExpression(left, right));
}
return(Expression.Divide(left, right));
}
/// <summary>Generates a negative of expression.</summary>
/// <param name="expr">Input expression.</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateNegate(Expression expr)
{
if (OpenTypeMethods.IsOpenPropertyExpression(expr))
{
return(OpenTypeMethods.NegateExpression(expr));
}
return(Expression.Negate(expr));
}
/// <summary>Generates a subtract expression.</summary>
/// <param name="left">Left expression.</param>
/// <param name="right">Right expression.</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateSubtract(Expression left, Expression right)
{
if (OpenTypeMethods.IsOpenPropertyExpression(left) || OpenTypeMethods.IsOpenPropertyExpression(right))
{
return(OpenTypeMethods.SubtractExpression(left, right));
}
return(Expression.Subtract(left, right));
}
/// <summary>Generates a NotEqual expression.</summary>
/// <param name="left">Left expression.</param>
/// <param name="right">Right expression.</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateNotEqual(Expression left, Expression right)
{
if (OpenTypeMethods.IsOpenPropertyExpression(left) || OpenTypeMethods.IsOpenPropertyExpression(right))
{
return(OpenTypeMethods.NotEqualExpression(left, right));
}
if (left.Type == typeof(byte[]))
{
return(Expression.NotEqual(left, right, false, AreByteArraysNotEqualMethodInfo));
}
return(Expression.NotEqual(left, right));
}
/// <summary>Generates a GreaterThanOrEqual comparsion expression.</summary>
/// <param name="left">Left expression.</param>
/// <param name="right">Right expression.</param>
/// <param name="comparisonMethodInfo">MethodInfo for comparison method used for string, bool, guid types</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateGreaterThanEqual(Expression left, Expression right, MethodInfo comparisonMethodInfo)
{
if (OpenTypeMethods.IsOpenPropertyExpression(left) || OpenTypeMethods.IsOpenPropertyExpression(right))
{
return(OpenTypeMethods.GreaterThanOrEqualExpression(left, right));
}
if (comparisonMethodInfo != null)
{
left = Expression.Call(null, comparisonMethodInfo, left, right);
right = Expression.Constant(0, typeof(int));
}
return(Expression.GreaterThanOrEqual(left, right));
}
/// <summary>Generates a not of expression.</summary>
/// <param name="expr">Input expression.</param>
/// <returns>The generated expression.</returns>
internal static Expression GenerateNot(Expression expr)
{
if (OpenTypeMethods.IsOpenPropertyExpression(expr))
{
return(OpenTypeMethods.NotExpression(expr));
}
if (expr.Type == typeof(bool) || expr.Type == typeof(Nullable <bool>))
{
// Expression.Not will take numerics and apply '~' to them, thus the extra check here.
return(Expression.Not(expr));
}
else
{
string message = Strings.RequestQueryParser_NotDoesNotSupportType(expr.Type);
throw DataServiceException.CreateSyntaxError(message);
}
}
