private WherePart Recurse(ref int i, Expression expression, bool isUnary = false, string prefix = null, string postfix = null)
{
if (expression is UnaryExpression)
{
var unary = (UnaryExpression)expression;
return(WherePart.Concat(NodeTypeToString(unary.NodeType), Recurse(ref i, unary.Operand, true)));
}
if (expression is BinaryExpression)
{
var body = (BinaryExpression)expression;
return(WherePart.Concat(Recurse(ref i, body.Left), NodeTypeToString(body.NodeType), Recurse(ref i, body.Right)));
}
if (expression is ConstantExpression)
{
var constant = (ConstantExpression)expression;
var value = constant.Value;
if (value is bool && isUnary)
{
return(WherePart.Concat(WherePart.IsParameter(i++, value), "=", WherePart.IsSql("1")));
}
if (value is string)
{
if (prefix == null && postfix == null)
{
value = (string)value;
}
else
{
value = prefix + (string)value + postfix;
}
}
return(WherePart.IsParameter(i++, value));
}
if (expression is MemberExpression)
{
var member = (MemberExpression)expression;
if (member.Member is PropertyInfo)
{
var property = (PropertyInfo)member.Member;
var colName = property.Name;
if (member.Expression is MemberExpression)
{
member = (MemberExpression)member.Expression;
if (member.Member is FieldInfo)
{
var value = GetValue(member);
return(WherePart.IsParameter(i++, property.GetValue(value)));
}
}
if (member.Expression is ConstantExpression)
{
var constant = (ConstantExpression)member.Expression;
var value = constant.Value;
return(WherePart.IsParameter(i++, property.GetValue(value)));
}
if (isUnary && member.Type == typeof(bool))
{
return(WherePart.Concat(Recurse(ref i, expression), "=", WherePart.IsParameter(i++, true)));
}
return(WherePart.IsSql("[" + colName + "]"));
}
if (member.Member is FieldInfo)
{
var value = GetValue(member);
if (value is string)
{
value = prefix + (string)value + postfix;
}
return(WherePart.IsParameter(i++, value));
}
throw new Exception($"Expression does not refer to a property or field: {expression}");
}
if (expression is MethodCallExpression)
{
var methodCall = (MethodCallExpression)expression;
// LIKE queries:
if (methodCall.Method == typeof(string).GetMethod("Contains", new[] { typeof(string) }))
{
return(WherePart.Concat(Recurse(ref i, methodCall.Object), "LIKE", Recurse(ref i, methodCall.Arguments[0], prefix: "%", postfix: "%")));
}
if (methodCall.Method == typeof(string).GetMethod("StartsWith", new[] { typeof(string) }))
{
return(WherePart.Concat(Recurse(ref i, methodCall.Object), "LIKE", Recurse(ref i, methodCall.Arguments[0], prefix: "", postfix: "%")));
}
if (methodCall.Method == typeof(string).GetMethod("EndsWith", new[] { typeof(string) }))
{
return(WherePart.Concat(Recurse(ref i, methodCall.Object), "LIKE", Recurse(ref i, methodCall.Arguments[0], prefix: "%", postfix: "")));
}
// IN queries:
if (methodCall.Method.Name == "Contains")
{
Expression collection;
Expression property;
if (methodCall.Method.IsDefined(typeof(ExtensionAttribute)) && methodCall.Arguments.Count == 2)
{
collection = methodCall.Arguments[0];
property = methodCall.Arguments[1];
}
else if (!methodCall.Method.IsDefined(typeof(ExtensionAttribute)) && methodCall.Arguments.Count == 1)
{
collection = methodCall.Object;
property = methodCall.Arguments[0];
}
else
{
throw new Exception("Unsupported method call: " + methodCall.Method.Name);
}
var values = (IEnumerable)GetValue(collection);
return(WherePart.Concat(Recurse(ref i, property), "IN", WherePart.IsCollection(ref i, values)));
}
throw new Exception("Unsupported method call: " + methodCall.Method.Name);
}
throw new Exception("Unsupported expression: " + expression.GetType().Name);
}
private IWherePart Recurse(ref int i, Expression expression, bool isUnary = false, string prefix = null, string postfix = null)
{
switch (expression)
{
case UnaryExpression unaryExpression:
var unary = unaryExpression;
return(WherePart.Concat(NodeTypeToString(unary.NodeType), Recurse(ref i, unary.Operand, true)));
case BinaryExpression binaryExpression:
var body = binaryExpression;
return(WherePart.Concat(Recurse(ref i, body.Left), NodeTypeToString(body.NodeType), Recurse(ref i, body.Right)));
case ConstantExpression constantExpression:
var constant = constantExpression;
var value = constant.Value;
if (value is int)
{
return(WherePart.IsSql(value.ToString()));
}
if (value is string)
{
value = prefix + (string)value + postfix;
}
if (value is bool && isUnary)
{
return(WherePart.Concat(WherePart.IsParameter(i++, value), "=", WherePart.IsSql("1")));
}
i++;
var constantParametrizedName = Fragments.ParametrizedValue.Format(i);
var constantResponse = WherePart.IsSql(Fragments.InlineValue.Format(constantParametrizedName));
constantResponse.Parameters.Add(constantParametrizedName, value);
return(constantResponse);
// return WherePart.IsParameter(i++, value);
case MemberExpression memberExpression:
var member = memberExpression;
var parametrizedName = "";
IWherePart response = null;
var valueSet = GetMemberValueSet(member);
switch (member.Member)
{
case PropertyInfo info:
var property = info;
var colName = _modelDescriptor.Members[property.Name].TargetName;
if (member.Type == typeof(bool))
{
parametrizedName = Fragments.ParametrizedValue.Format(colName);
response = WherePart.IsSql($"{colName} {Fragments.Markers.Equality} {Fragments.InlineValue.Format(parametrizedName)}");
response.Parameters.Add(parametrizedName, Fragments.Values.True);
}
else if (member.Expression is ConstantExpression)
{
parametrizedName = Fragments.ParametrizedValue.Format(colName);
response = WherePart.IsSql(Fragments.InlineValue.Format(parametrizedName));
response.Parameters.Add(parametrizedName, GetValue(member));
}
else
{
if (valueSet.HasValue)
{
response = WherePart.IsSql(Fragments.Column.Format(colName));
}
else
{
response = WherePart.IsSql(Fragments.Column.Format(colName));
}
}
break;
case FieldInfo _:
if (valueSet.HasValue)
{
i++;
parametrizedName = Fragments.ParametrizedValue.Format(i);
response = WherePart.IsSql(Fragments.InlineValue.Format(parametrizedName));
response.Parameters.Add(parametrizedName, valueSet.Value);
}
else
{
response = WherePart.IsSql(Fragments.Column.Format(valueSet.Member));
}
break;
default: throw new Exception($"Expression does not refer to a property or field: {expression}");
}
return(response);
case MethodCallExpression callExpression:
var methodCall = callExpression;
// LIKE queries:
if (methodCall.Method == typeof(string).GetMethod("Contains", new[] { typeof(string) }))
{
return(WherePart.Concat(Recurse(ref i, methodCall.Object), "LIKE", Recurse(ref i, methodCall.Arguments[0], prefix: "%", postfix: "%")));
}
if (methodCall.Method == typeof(string).GetMethod("StartsWith", new[] { typeof(string) }))
{
return(WherePart.Concat(Recurse(ref i, methodCall.Object), "LIKE", Recurse(ref i, methodCall.Arguments[0], postfix: "%")));
}
if (methodCall.Method == typeof(string).GetMethod("EndsWith", new[] { typeof(string) }))
{
return(WherePart.Concat(Recurse(ref i, methodCall.Object), "LIKE", Recurse(ref i, methodCall.Arguments[0], prefix: "%")));
}
// IN queries:
if (methodCall.Method.Name == "Contains")
{
Expression collection;
Expression property;
if (methodCall.Method.IsDefined(typeof(ExtensionAttribute)) && methodCall.Arguments.Count == 2)
{
collection = methodCall.Arguments[0];
property = methodCall.Arguments[1];
}
else if (!methodCall.Method.IsDefined(typeof(ExtensionAttribute)) && methodCall.Arguments.Count == 1)
{
collection = methodCall.Object;
property = methodCall.Arguments[0];
}
else
{
throw new Exception("Unsupported method call: " + methodCall.Method.Name);
}
var values = (IEnumerable)GetValue(collection);
return(WherePart.Concat(Recurse(ref i, property), "IN", WherePart.IsCollection(ref i, values)));
}
throw new Exception("Unsupported method call: " + methodCall.Method.Name);
}
throw new Exception("Unsupported expression: " + expression.GetType().Name);
}
