Lambda转sql部分代码保存
2024-08-25 08:07:26
public class SqlExpressionTree
{
public string GetQuerySql<T>(Expression<Func<T, bool>> condi)
{
string condition = "select * from "+typeof(T).Name+" "+ typeof(T).Name + " where ";
BinaryExpression body = (BinaryExpression)condi.Body;
condition+= GetSqlByExpression(body);
return condition;
}
/// <summary>
/// 通过Lambda解析为Sql
/// </summary>
/// <param name="func"></param>
/// <returns></returns>
public static string GetSqlByExpression(Expression func)
{
var funcType = CheckExpressionType(func);
switch (funcType)
{
case EnumNodeType.BinaryOperator:
return VisitBinaryExpression(func as BinaryExpression);
case EnumNodeType.Constant:
return VisitConstantExpression(func as ConstantExpression);
case EnumNodeType.Call:
return VisitMethodCallExpression(func as MethodCallExpression);
case EnumNodeType.UndryOperator:
return VisitUnaryExpression(func as UnaryExpression);
case EnumNodeType.MemberAccess:
return VisitMemberAccessExpression(func as MemberExpression);
default:
throw new NotSupportedException("不支持的操作在表达式处理中：");
}
}
public string CheckExpression(Expression exp)
{
string leftClude = "", rightClude = "";
if (exp.ToString().IndexOf("((") == )
{
leftClude = "("; rightClude = ")";
}
if (exp.NodeType == ExpressionType.MemberAccess || exp.NodeType == ExpressionType.Constant)
{
return exp.ToString();
}
if (exp as MethodCallExpression == null && exp as BinaryExpression == null)
throw new ArgumentException("不支持表达式的类型", "exp");
if (exp as MethodCallExpression != null)
{
MethodCallExpression cexp = exp as MethodCallExpression;
return "";
}
else
{
switch (exp.NodeType)
{
case ExpressionType.Equal:
return leftClude + CheckExpression(((BinaryExpression)exp).Left) + " = " + CheckExpression(((BinaryExpression)exp).Right) + rightClude;
case ExpressionType.Or:
return leftClude + CheckExpression(((BinaryExpression)exp).Left) + " or " + CheckExpression(((BinaryExpression)exp).Right) + rightClude;
case ExpressionType.OrElse:
return leftClude + CheckExpression(((BinaryExpression)exp).Left) + " or " + CheckExpression(((BinaryExpression)exp).Right) + rightClude;
case ExpressionType.AndAlso:
return leftClude + CheckExpression(((BinaryExpression)exp).Left) + " and " + CheckExpression(((BinaryExpression)exp).Right) + rightClude;
default:
return "";
}
}
}
/// <summary>
/// 判断表达式类型
/// </summary>
/// <param name="func">lambda表达式</param>
/// <returns></returns>
private static EnumNodeType CheckExpressionType(Expression func)
{
switch (func.NodeType)
{
case ExpressionType.AndAlso:
case ExpressionType.OrElse:
case ExpressionType.Equal:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LessThanOrEqual:
case ExpressionType.GreaterThan:
case ExpressionType.LessThan:
case ExpressionType.NotEqual:
return EnumNodeType.BinaryOperator;
case ExpressionType.Constant:
return EnumNodeType.Constant;
case ExpressionType.MemberAccess:
return EnumNodeType.MemberAccess;
case ExpressionType.Call:
return EnumNodeType.Call;
case ExpressionType.Not:
case ExpressionType.Convert:
return EnumNodeType.UndryOperator;
default:
return EnumNodeType.Unknown;
}
}
private static string ExpressionTypeToString(ExpressionType type)
{
switch (type)
{
case ExpressionType.Equal:
return " = ";
case ExpressionType.Or:
return " or ";
case ExpressionType.OrElse:
return " or ";
case ExpressionType.AndAlso:
return " and ";
default:
return "";
}
}
/// <summary>
/// 判断一元表达式
/// </summary>
/// <param name="func"></param>
/// <returns></returns>
private static string VisitUnaryExpression(UnaryExpression func)
{
var result = ExpressionTypeToString(func.NodeType);
var funcType = CheckExpressionType(func.Operand);
switch (funcType)
{
case EnumNodeType.BinaryOperator:
return result + VisitBinaryExpression(func.Operand as BinaryExpression);
case EnumNodeType.Constant:
return result + VisitConstantExpression(func.Operand as ConstantExpression);
case EnumNodeType.Call:
return result + VisitMethodCallExpression(func.Operand as MethodCallExpression);
case EnumNodeType.UndryOperator:
return result + VisitUnaryExpression(func.Operand as UnaryExpression);
case EnumNodeType.MemberAccess:
return result + VisitMemberAccessExpression(func.Operand as MemberExpression);
default:
throw new NotSupportedException("不支持的操作在一元操作处理中：");
}
} /// <summary>
/// 判断常量表达式
/// </summary>
/// <param name="func"></param>
/// <returns></returns>
private static string VisitConstantExpression(ConstantExpression func)
{
if (func.Value.ToString() == "")
{
return "\'\' ";
}
else if (func.Value.ToString() == "True")
{
return "1 = 1 ";
}
else if (func.Value.ToString() == "False")
{
return "0 = 1 ";
}
else
{
return "'" + func.Value.ToString() + "' "; }
} /// <summary>
/// 判断包含变量的表达式
/// </summary>
/// <param name="func"></param>
/// <returns></returns>
private static string VisitMemberAccessExpression(MemberExpression func)
{
try
{
var tablename = func.Expression.Type.Name;
return tablename + "." + func.Member.Name + " ";
}
catch
{
object value;
switch (func.Type.Name)
{
case "Int32":
{
var getter = Expression.Lambda<Func<int>>(func).Compile();
value = getter();
}
break;
case "String":
{
var getter = Expression.Lambda<Func<string>>(func).Compile();
value = "'" + getter() + "'";
}
break;
case "DateTime":
{
var getter = Expression.Lambda<Func<DateTime>>(func).Compile();
value = "'" + getter() + "'";
}
break;
default:
{
var getter = Expression.Lambda<Func<object>>(func).Compile();
value = getter();
}
break;
}
return value.ToString();
}
}
/// <summary>
/// 判断包含函数的表达式
/// </summary>
/// <param name="func"></param>
/// <returns></returns>
private static String VisitMethodCallExpression(MethodCallExpression func)
{
if (func.Method.Name.Contains("Contains"))
{
if (func.Object.Type.Name.ToLower() == "string")
{
//获得调用者的内容元素
var field = VisitMemberAccessExpression(func.Object as MemberExpression);
//获得字段
var caller = func.Arguments[];
var param = Expression.Lambda<Func<object>>(caller).Compile();
return field + " like '%" + param() + "%'";
}
else
{
//获得调用者的内容元素
var getter = Expression.Lambda<Func<object>>(func.Object).Compile();
var data = getter() as IEnumerable;
//获得字段
var caller = func.Arguments[];
while (caller.NodeType == ExpressionType.Call)
{
caller = (caller as MethodCallExpression).Object;
}
var field = VisitMemberAccessExpression(caller as MemberExpression);
var list = (from object i in data select "'" + i + "'").ToList();
return field + " IN (" + string.Join(",", list.Cast<string>().ToArray()) + ") ";
}
}
else
{
throw new NotSupportedException("不支持的函数操作:" + func.Method.Name);
}
}
/// <summary>
/// 判断包含二元运算符的表达式
/// </summary>
/// <remarks>注意，这个函数使用了递归，修改时注意不要修改了代码顺序和逻辑</remarks>
/// <param name="func"></param>
private static string VisitBinaryExpression(BinaryExpression func)
{
var result = "(";
var leftType = CheckExpressionType(func.Left);
switch (leftType)
{
case EnumNodeType.BinaryOperator:
result += VisitBinaryExpression(func.Left as BinaryExpression); break;
case EnumNodeType.Constant:
result += VisitConstantExpression(func.Left as ConstantExpression); break;
case EnumNodeType.MemberAccess:
result += VisitMemberAccessExpression(func.Left as MemberExpression); break;
case EnumNodeType.UndryOperator:
result += VisitUnaryExpression(func.Left as UnaryExpression); break;
case EnumNodeType.Call:
result += VisitMethodCallExpression(func.Left as MethodCallExpression); break;
default:
throw new NotSupportedException("不支持的操作在二元操作处理中：");
} result += ExpressionTypeToString(func.NodeType) + " "; var rightType = CheckExpressionType(func.Right);
switch (rightType)
{
case EnumNodeType.BinaryOperator:
result += VisitBinaryExpression(func.Right as BinaryExpression); break;
case EnumNodeType.Constant:
result += VisitConstantExpression(func.Right as ConstantExpression); break;
case EnumNodeType.MemberAccess:
result += VisitMemberAccessExpression(func.Right as MemberExpression); break;
case EnumNodeType.UndryOperator:
result += VisitUnaryExpression(func.Right as UnaryExpression); break;
case EnumNodeType.Call:
result += VisitMethodCallExpression(func.Right as MethodCallExpression); break;
default:
throw new NotSupportedException("不支持的操作在二元操作处理中：");
} result += ") ";
return result;
}
} public enum EnumNodeType
{
[Description("二元运算符")]
BinaryOperator = ,
[Description("一元运算符")]
UndryOperator = ,
[Description("常量表达式")]
Constant = ,
[Description("成员（变量）")]
MemberAccess = ,
[Description("函数")]
Call = ,
[Description("未知")]
Unknown = -,
[Description("不支持")]
NotSupported = -
}
最新文章
- webpack + vuejs 基本配置（一）
- 安卓log4k问题解决
- HTTPS 进阶
- 网络请求怎么样和UI线程交互？ Activity2怎么通知Activity1 更新数据
- IIS线程池与ASP.NET线程池
- iOS 5.0 后UIViewController新增：willMoveToParentViewController和didMoveToParentViewCon［转］
- DTCMS中部分IE8不支持webupload上传附件的控件，更改为ajaxfileupload
- C# 框架是什么？MVC是什么 ？工厂模式是什么？设计模式是什么？三层架构是什
- SharePoint 2010 master page 控件介绍(3) :页面主体内容
- 【原】现有市场上H264 IPCamerad的功能
- jquery datagrid添加冻结列等
- Android主线程的消息系统(Handler\Looper)
- syslog-ng 学习
- HDU 1285：确定比赛名次（拓扑排序）
- 我与虚拟机的初次接触及初探Liux命令 20155338
- navicat批量导入数据
- Windows x64 栈帧结构
- 【UVA11806 Cheerleaders】 题解
- Deep Learning论文笔记之（三）单层非监督学习网络分析
- 【BZOJ2832&&3874】宅男小C [模拟退火][贪心]