private static void Select(NewExpression expression, QueryPack pack)
{
foreach (var argument in expression.Arguments)
{
ExpressionTranslator.Translate(argument as MemberExpression, pack);
}
}
internal static void Translate(ConstantExpression expression, QueryPack pack)
{
if (pack.State == QueryState.Where || pack.State == QueryState.Join)
{
InnerTranslate(expression, pack);
}
}
public static void Translate(NewExpression expression, QueryPack pack)
{
if (pack.State == QueryState.Select)
{
Select(expression, pack);
}
}
public static void Translate(MemberExpression expression, QueryPack pack)
{
if (pack.State == QueryState.Select)
{
Select(expression, pack);
}
else if (pack.State == QueryState.Where || pack.State == QueryState.Join || pack.State == QueryState.OrderBy || pack.State == QueryState.GroupBy)
{
InnerTranslate(expression, pack);
}
}
public static void Translate(BinaryExpression expression, QueryPack pack)
{
if (pack.State == QueryState.Where)
{
Where(expression, pack);
}
else if (pack.State == QueryState.Join)
{
Join(expression, pack);
}
}
private static void InnerTranslate(MemberExpression expression, QueryPack pack)
{
if (pack.Contains(expression.Expression.Type))
{
var table = pack.GetTable(expression.Expression.Type);
pack.Append($"{table.Alias}.{expression.Member.Name}");
}
else
{
var name = expression.Member.Name;
pack.Append($"@{name[0].ToString().ToUpperInvariant()}{name.Substring(1, name.Length - 1)}");
}
}
public static void Translate(MethodCallExpression expression, QueryPack pack)
{
var methodName = expression.Method.Name;
if (IsLikeMethod(methodName))
{
TranslateLikeMethod(methodName, expression, pack);
}
if (IsReplaceMethod(methodName))
{
TranslateReplace(methodName, expression, pack);
}
if (IsUpperMethod(methodName))
{
TranslateToUpper(methodName, expression, pack);
}
}
public static void Translate(Expression expression, QueryPack pack)
{
if (expression == null)
{
throw new ArgumentNullException("expression can not be null.");
}
if (expression is ConstantExpression)
{
ConstantExpressionTranslator.Translate(expression as ConstantExpression, pack);
}
else if (expression is BinaryExpression)
{
BinaryExpressionTranslator.Translate(expression as BinaryExpression, pack);
}
else if (expression is MemberExpression)
{
MemberExpressionTranslator.Translate(expression as MemberExpression, pack);
}
else if (expression is MethodCallExpression)
{
MethodCallExpressionTranslator.Translate(expression as MethodCallExpression, pack);
}
else if (expression is NewArrayExpression)
{
}
else if (expression is NewExpression)
{
NewExpressionTranslator.Translate(expression as NewExpression, pack);
}
else if (expression is UnaryExpression)
{
UnaryExpressionTranslator.Translate(expression as UnaryExpression, pack);
}
else if (expression is MemberInitExpression)
{
}
else if (expression is ListInitExpression)
{
}
else
{
throw new NotImplementedException("Unknow expression");
}
}
private static void InnerTranslate(ConstantExpression expression, QueryPack pack)
{
if (expression == null || expression.Value == null)
{
pack.Append("NULL");
}
else if (expression.Type == typeof(string) || expression.Type == typeof(Guid))
{
pack.AppendFormat("N'{0}' ", expression.Value.ToString());
}
else if (expression.Type == typeof(bool))
{
pack.Append((bool)expression.Value ? "1" : "0");
}
else
{
pack.AppendFormat("{0} ", expression.Value.ToString());
}
}
private static void Select(MemberExpression expression, QueryPack pack)
{
var table = pack.GetTable(expression.Member.DeclaringType);
pack.SelectFields.Add($"{table.Alias}.{expression.Member.Name}");
}
public static void Translate(UnaryExpression expression, QueryPack pack)
{
Select(expression, pack);
}
private static void Select(UnaryExpression expression, QueryPack pack)
{
ExpressionTranslator.Translate(expression.Operand, pack);
}
private static void TranslateLikeMethod(string methodName, MethodCallExpression expression, QueryPack pack)
{
ExpressionTranslator.Translate(expression.Object, pack);
pack.Append(" LIKE ");
if (StringHelper.Compare(methodName, "Contains") || StringHelper.Compare(methodName, "EndsWith"))
{
pack.Append("'%'+");
}
ExpressionTranslator.Translate(expression.Arguments[0], pack);
if (StringHelper.Compare(methodName, "Contains") || StringHelper.Compare(methodName, "StartsWith"))
{
pack.Append("+'%'");
}
}
private static void TranslateReplace(string methodName, MethodCallExpression expression, QueryPack pack)
{
pack.Append("REPLACE(");
ExpressionTranslator.Translate(expression.Object, pack);
for (int i = 0, j = 2; i < j; i++)
{
pack.Append(", ");
ExpressionTranslator.Translate(expression.Arguments[i], pack);
}
pack.Append(")");
}
private static void Join(BinaryExpression expression, QueryPack pack)
{
ExpressionTranslator.Translate(expression.Left, pack);
ExpressionTranslator.Translate(expression.NodeType, pack, false);
ExpressionTranslator.Translate(expression.Right, pack);
}
private static void Where(BinaryExpression expression, QueryPack pack)
{
ExpressionTranslator.Translate(expression.Left, pack);
ExpressionTranslator.Translate(expression.NodeType, pack, IsNull(expression.Right));
ExpressionTranslator.Translate(expression.Right, pack);
}
private static void TranslateToUpper(string methodName, MethodCallExpression expression, QueryPack pack)
{
pack.Append("UPPER(");
ExpressionTranslator.Translate(expression.Object, pack);
pack.Append(")");
}
public QueryTranslator()
{
this.pack = new QueryPack();
this.segments = new List <QuerySegment>();
}
public static void Translate(ExpressionType nodeType, QueryPack pack, bool isNull)
{
switch (nodeType)
{
case ExpressionType.And:
case ExpressionType.AndAlso:
pack.Append(" AND ");
break;
case ExpressionType.Equal:
pack.Append(isNull ? " IS " : "=");
break;
case ExpressionType.GreaterThan:
pack.Append(">");
break;
case ExpressionType.GreaterThanOrEqual:
pack.Append(">=");
break;
case ExpressionType.NotEqual:
pack.Append(isNull ? " IS NOT " : "!=");
break;
case ExpressionType.Or:
case ExpressionType.OrElse:
pack.Append(" OR ");
break;
case ExpressionType.LessThan:
pack.Append("<");
break;
case ExpressionType.LessThanOrEqual:
pack.Append("<=");
break;
case ExpressionType.Add:
pack.Append("+");
break;
case ExpressionType.Subtract:
pack.Append("-");
break;
case ExpressionType.Multiply:
pack.Append("*");
break;
case ExpressionType.Divide:
pack.Append("/");
break;
case ExpressionType.Modulo:
pack.Append("%");
break;
default:
throw new NotImplementedException("Unkonw type");
}
}
