public static object GetAlphabeticValue <T>(ParameterExpression parameter, ExpressionValue expressionValue,
RSqlQueryParser.ComparisonContext context,
JsonNamingPolicy jsonNamingPolicy = null)
{
if (IsChar(expressionValue.Property.PropertyType))
{
return(GetChar <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
return(GetString <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
public static object GetTemporalValue <T>(ParameterExpression parameter, ExpressionValue expressionValue,
RSqlQueryParser.ComparisonContext context,
JsonNamingPolicy jsonNamingPolicy = null)
{
if (IsDateTimeOffset(expressionValue.Property.PropertyType))
{
return(GetDateTimeOffset <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
return(GetDateTime <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
public static object GetValue <T>(ParameterExpression parameter, ExpressionValue expressionValue,
RSqlQueryParser.ComparisonContext context,
JsonNamingPolicy jsonNamingPolicy = null)
{
CheckParameters(parameter, expressionValue, context);
if (IsNumeric(expressionValue.Property.PropertyType))
{
return(GetNumericValue <T>(parameter, expressionValue, context, jsonNamingPolicy));
}
if (IsTemporal(expressionValue.Property.PropertyType))
{
return(GetTemporalValue <T>(parameter, expressionValue, context, jsonNamingPolicy));
}
if (IsAlphabetic(expressionValue.Property.PropertyType))
{
return(GetAlphabeticValue <T>(parameter, expressionValue, context, jsonNamingPolicy));
}
if (IsBool(expressionValue.Property.PropertyType))
{
return(GetBoolean <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
if (IsEnum(expressionValue.Property.PropertyType))
{
return(GetEnum <T>(parameter, context.arguments().value()[0],
expressionValue.Property.PropertyType, jsonNamingPolicy));
}
if (IsGuid(expressionValue.Property.PropertyType))
{
return(GetGuid <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
return(null);
}
/// <summary>
/// extract the unique value
/// </summary>
/// <param name="parameter"></param>
/// <param name="expressionValue"></param>
/// <param name="context"></param>
/// <param name="jsonNamingPolicy"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
/// <exception cref="ComparisonNotEnoughArgumentException"></exception>
/// <exception cref="ComparisonTooManyArgumentException"></exception>
private static object GetUniqueValue <T>(ParameterExpression parameter, ExpressionValue expressionValue,
RSqlQueryParser.ComparisonContext context,
JsonNamingPolicy jsonNamingPolicy = null)
{
var value = context.arguments().value();
if (value.Length > 1)
{
throw new ComparisonTooManyArgumentException(context);
}
return(RSqlQueryGetValueHelper.GetValue <T>(parameter, expressionValue, context, jsonNamingPolicy));
}
/// <summary>
/// create is null expression ( operator "=is-null=" or "=nil=" )
/// </summary>
/// <param name="parameter"></param>
/// <param name="context"></param>
/// <param name="jsonNamingPolicy"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Expression <Func <T, bool> > GetIsNullExpression <T>(ParameterExpression parameter,
RSqlQueryParser.ComparisonContext context,
JsonNamingPolicy jsonNamingPolicy = null)
{
var expressionValue = GetSelector <T>(parameter, context, jsonNamingPolicy);
if (!RSqlQueryGetValueHelper.IsNullableComparisonType(expressionValue.Property.PropertyType))
{
throw new ComparisonInvalidComparatorSelectionException(context);
}
var values = RSqlQueryGetValueHelper.GetValues(typeof(bool), context.arguments());
if (!values.Any())
{
throw new ComparisonNotEnoughArgumentException(context);
}
if (values.Count > 1)
{
throw new ComparisonTooManyArgumentException(context);
}
var result = Expression.Lambda <Func <T, bool> >(Expression.Equal(
expressionValue.Expression,
Expression.Constant(null, typeof(object))), parameter);
if ((bool)values[0])
{
return(result);
}
var body = Expression.Not(result.Body);
result = Expression.Lambda <Func <T, bool> >(body, parameter);
return(result);
}
public static object GetNumericValue <T>(ParameterExpression parameter, ExpressionValue expressionValue,
RSqlQueryParser.ComparisonContext context,
JsonNamingPolicy jsonNamingPolicy = null)
{
if (IsShort(expressionValue.Property.PropertyType))
{
return(GetShort <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
if (IsLong(expressionValue.Property.PropertyType))
{
return(GetLong <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
if (IsFloat(expressionValue.Property.PropertyType))
{
return(GetFloat <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
if (IsDouble(expressionValue.Property.PropertyType))
{
return(GetDouble <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
if (IsDecimal(expressionValue.Property.PropertyType))
{
return(GetDecimal <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
if (IsByte(expressionValue.Property.PropertyType))
{
return(GetByte <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
return(GetInt <T>(parameter, context.arguments().value()[0], jsonNamingPolicy));
}
public ComparisonInvalidMatchTypeException(RSqlQueryParser.ComparisonContext origin,
Exception innerException = null) : base(origin,
$"Invalid comparison match type : {origin?.selector()?.GetText()} and {origin?.arguments()?.GetText()}",
innerException)
{
}
/// <summary>
/// create like expression
/// </summary>
/// <returns></returns>
private static Expression <Func <T, bool> > GetLkExpression <T>(ParameterExpression parameter,
RSqlQueryParser.ComparisonContext context,
JsonNamingPolicy jsonNamingPolicy = null)
{
var expressionValue = GetSelector <T>(parameter, context, jsonNamingPolicy);
var values = RSqlQueryGetValueHelper.GetValues(expressionValue.Property.PropertyType, context.arguments());
if (values.Count > 1)
{
throw new ComparisonTooManyArgumentException(context);
}
var criteria = Convert.ToString(values[0]) ?? string.Empty;
var maskStar = "{" + Guid.NewGuid() + "}";
criteria = criteria.Replace(@"\*", maskStar);
MethodInfo method;
if (!criteria.Contains('*'))
{
criteria += '*';
}
if (criteria.StartsWith("*", StringComparison.Ordinal) && criteria.EndsWith("*", StringComparison.Ordinal))
{
method = QueryReflectionHelper.MethodStringContains;
}
else if (criteria.StartsWith("*", StringComparison.Ordinal))
{
method = QueryReflectionHelper.MethodStringEndsWith;
}
else
{
method = QueryReflectionHelper.MethodStringStartsWith;
}
criteria = criteria.Replace("*", "").Replace(maskStar, "*");
return(Expression.Lambda <Func <T, bool> >(Expression.Call(expressionValue.Expression,
method,
Expression.Constant(criteria, expressionValue.Property.PropertyType)), parameter));
}
/// <summary>
/// extract the multi value
/// </summary>
/// <param name="expressionValue"></param>
/// <param name="context"></param>
/// <returns></returns>
/// <exception cref="ComparisonNotEnoughArgumentException"></exception>
private static List <object> GetMultipleValue(ExpressionValue expressionValue,
RSqlQueryParser.ComparisonContext context)
{
return(RSqlQueryGetValueHelper.GetValues(expressionValue.Property.PropertyType, context.arguments()));
}
