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