自己动手写ORM（01）：解析表达式树生成Sql碎片

最新推荐文章于 2023-05-11 19:12:45 发布
最新推荐文章于 2023-05-11 19:12:45 发布
阅读量240 收藏
点赞数
文章标签： c#
原文链接：http://www.cnblogs.com/sjqq/p/8428592.html
版权

 在EF中，我们查询数据时可能会用拉姆达表达式 Where（Func<T,ture> func）这个方法来筛选数据，例如，我们定义一个User实体类

public class User
{
public Guid Id { get; set; }
public string LoginId { get; set; }
public string Name { get; set; }
public bool Enabled { get; set; }
public DateTime CreateTime { get; set; }
}

现在我想查询用户Enabled为true 并且Name 中包含'lilei'的用户，在EF中我们可能会这样去写：

XXX.Where(u => u.Name.Contains("lilei") && u.Enabled==true)

那么现在我想将Where方法中的那个泛型委托翻译成Sql语句中的一部分应该怎么做呢？下面是我已经写好的一个解析表达式的类，可能写得不是很规范，大家尽量吐槽：

using LC.Factory.Code;
using LC.Factory.Entity;
using LC.Factory.Resource;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;


namespace LC.Factory.Common
{
public class ExpressionAnalyzer
{
/// <summary>
/// 表达式所有参数集合
/// </summary>
private Dictionary<string, object> _params;
/// <summary>
/// 命名参数别名
/// </summary>
private const string _argName = "TAB";
/// <summary>
/// 解析结果
/// </summary>
public AnalysisData ResultData { get; set; }
public ExpressionAnalyzer()
{
ResultData = new AnalysisData();
_params = new Dictionary<string, object>();

}
public ExpressionAnalyzer(LambdaExpression exp)
: this()
{
if (exp != null)
{
AppendParams(GetChildValue(exp.Body), _params);
foreach (var item in exp.Parameters)
{
AnalysisTables(item);
}
AnalysisExpression(exp.Body, true);
}
}
/// <summary>
/// 解析表达式
/// </summary>
/// <param name="exp"></param>
/// <param name="isLeftChild"></param>
private void AnalysisExpression(Expression exp, bool isLeftChild = true)
{
switch (exp.NodeType)
{
case ExpressionType.AndAlso:
ResultData.StackList.Add("(");
AnalysisExpression(GetChildExpression(exp));
ResultData.StackList.Add(")");
ResultData.StackList.Add("AND");
ResultData.StackList.Add("(");
AnalysisExpression(GetChildExpression(exp, false), false);
ResultData.StackList.Add(")");
break;
case ExpressionType.OrElse:
ResultData.StackList.Add("(");
AnalysisExpression(GetChildExpression(exp));
ResultData.StackList.Add(")");
ResultData.StackList.Add("OR");
ResultData.StackList.Add("(");
AnalysisExpression(GetChildExpression(exp, false), false);
ResultData.StackList.Add(")");
break;
case ExpressionType.Equal:
AnalysisExpression(GetChildExpression(exp));
ResultData.StackList.Add("=");
AnalysisExpression(GetChildExpression(exp, false), false);
break;
case ExpressionType.NotEqual:
AnalysisExpression(GetChildExpression(exp));
ResultData.StackList.Add("!=");
AnalysisExpression(GetChildExpression(exp, false), false);
break;
case ExpressionType.GreaterThanOrEqual:
AnalysisExpression(GetChildExpression(exp));
ResultData.StackList.Add(">=");
AnalysisExpression(GetChildExpression(exp, false), false);
break;
case ExpressionType.GreaterThan:
AnalysisExpression(GetChildExpression(exp));
ResultData.StackList.Add(">");
AnalysisExpression(GetChildExpression(exp, false), false);
break;
case ExpressionType.LessThan:
AnalysisExpression(GetChildExpression(exp));
ResultData.StackList.Add("<");
AnalysisExpression(GetChildExpression(exp, false), false);
break;
case ExpressionType.LessThanOrEqual:
AnalysisExpression(GetChildExpression(exp));
ResultData.StackList.Add("<=");
AnalysisExpression(GetChildExpression(exp, false), false);
break;
case ExpressionType.Call:
var imExp = exp as MethodCallExpression;
AnalysisExpression(imExp.Object, true);
ResultData.StackList.Add("LIKE");
if (imExp.Arguments.Count > 0)
{
var arg0 = imExp.Arguments[0] as MemberExpression;
ResultData.StackList.Add("'%'+");
AnalysisExpression(imExp.Arguments[0], false);
ResultData.StackList.Add("+'%'");
}
break;
case ExpressionType.MemberAccess:
if (isLeftChild)
{
AnalysisTables(exp);
var mberExp = exp as MemberExpression;
var parentName = GetExpressionName(mberExp.Expression);
if (!string.IsNullOrEmpty(parentName))
{
ResultData.StackList.Add(string.Format("[{0}].{1}", parentName, GetExpressionName(exp)));
break;
}
ResultData.StackList.Add(GetExpressionName(exp));
}
else
{
var paramName = GetParamName(exp);
ResultData.ParamList.Add(paramName, _params[paramName]);
ResultData.StackList.Add(paramName);
}
break;
case ExpressionType.Constant:
var constent = exp as ConstantExpression;
if (constent.Value == null)
{
var op = ResultData.StackList.ElementAt(ResultData.StackList.Count - 1);
ResultData.StackList.RemoveAt(ResultData.StackList.Count - 1);
if (string.Equals(op, "="))
{
ResultData.StackList.Add("IS NULL");
}
else
{
ResultData.StackList.Add("IS NOT NULL");
}
break;
}
if (constent.Value.GetType() == typeof(String))
{
ResultData.StackList.Add(string.Format("'{0}'", constent.Value));
break;
}
if (constent.Value.GetType() == typeof(bool))
{
if (ResultData.StackList.Count > 0)
{
var value = Convert.ToBoolean(constent.Value);
ResultData.StackList.Add(string.Format("{0}", value ? "1" : "0"));
}

break;
}
ResultData.StackList.Add(string.Format("{0}", constent.Value));
break;
case ExpressionType.Convert:
var uExp = exp as UnaryExpression;
AnalysisExpression(uExp.Operand, isLeftChild);
break;
case ExpressionType.New:
var newExp = exp as NewExpression;
//解析查询字段
for (int i = 0; i < newExp.Arguments.Count; i++)
{
AnalysisExpression(newExp.Arguments[i]);
ResultData.StackList.Add("AS");
ResultData.StackList.Add(string.Format("'{0}'", newExp.Members[i].Name));
}
break;
case ExpressionType.Parameter:
throw new BusinessException(BusinessRes.SelectObjectMastBeAnNewObject);
//AnalysisExpression(Expression.New(exp.Type));
//break;
default:
break;
}

}
/// <summary>
/// 获取孩子节点
/// </summary>
/// <param name="exp"></param>
/// <param name="getLeft"></param>
/// <returns></returns>
private Expression GetChildExpression(Expression exp, bool getLeft = true)
{
var className = exp.GetType().Name;
switch (className)
{
case "BinaryExpression":
case "LogicalBinaryExpression":
var bExp = exp as BinaryExpression;
return getLeft ? bExp.Left : bExp.Right;
case "PropertyExpression":
case "FieldExpression":
var mberExp = exp as MemberExpression;
return mberExp;
case "MethodBinaryExpression":
var mbExp = exp as BinaryExpression;
return getLeft ? mbExp.Left : mbExp.Right;
case "UnaryExpression":
var unaryExp = exp as UnaryExpression;
return unaryExp;
case "ConstantExpression":
var cExp = exp as ConstantExpression;
return cExp;
case "InstanceMethodCallExpressionN":
var imExp = exp as MethodCallExpression;
return imExp;
default:
return null;
}
}
/// <summary>
/// 获取变量名
/// </summary>
/// <param name="exp"></param>
/// <param name="isLeftChild"></param>
/// <returns></returns>
private string GetExpressionName(Expression exp)
{
var className = exp.GetType().Name;
switch (className)
{
case "PropertyExpression":
case "FieldExpression":
var mberExp = exp as MemberExpression;
return string.Format("{0}", mberExp.Member.Name);
case "TypedParameterExpression":
return _argName;
default:
return string.Empty;
}
}
/// <summary>
/// 获取参数名
/// </summary>
/// <param name="exp"></param>
/// <param name="isLeftChild"></param>
/// <returns></returns>
private string GetParamName(Expression exp)
{
var className = exp.GetType().Name;
switch (className)
{
case "PropertyExpression":
case "FieldExpression":
var mberExp = exp as MemberExpression;
return string.Format("@{0}", mberExp.Member.Name);
case "TypedParameterExpression":
var texp = exp as ParameterExpression;
return string.Format("@{0}", texp.Name);
default:
return string.Empty;
}
}
/// <summary>
/// 解析表信息
/// </summary>
/// <param name="exp"></param>
private void AnalysisTables(Expression exp)
{
var className = exp.GetType().Name;
switch (className)
{
case "PropertyExpression":
case "FieldExpression":
var mberExp = exp as MemberExpression;
if (!IsDefaultType(mberExp.Type))
{
if (!ResultData.TableList.ContainsKey(mberExp.Member.Name))
{
ResultData.TableList.Add(mberExp.Member.Name, new AnalysisTable()
{
Name = mberExp.Type.Name,
TableType = mberExp.Type,
IsMainTable = false
});
}
}
AnalysisTables(mberExp.Expression);
break;
case "TypedParameterExpression":
//命名参数表达式
var texp = exp as ParameterExpression;
if (!IsDefaultType(texp.Type))
{
if (!ResultData.TableList.ContainsKey(_argName))
{
ResultData.TableList.Add(_argName, new AnalysisTable()
{
Name = texp.Type.Name,
TableType = texp.Type,
IsMainTable = true
});
}
}
break;
default:
break;
}
}
/// <summary>
/// 解析获取表达式的值
/// </summary>
/// <param name="exp"></param>
/// <param name="leftChild"></param>
/// <returns></returns>
private object GetChildValue(Expression exp)
{
var className = exp.GetType().Name;
switch (className)
{
case "BinaryExpression":
case "LogicalBinaryExpression":
var lExp = exp as BinaryExpression;
var ret = GetChildValue(lExp.Left);
if (IsNullDefaultType(ret))
{
ret = GetChildValue(lExp.Right);
}
return ret;
case "MethodBinaryExpression":
var mbExp = exp as BinaryExpression;
var ret1 = GetChildValue(mbExp.Left);
if (IsNullDefaultType(ret1))
{
ret1 = GetChildValue(mbExp.Right);
}
return ret1;

case "PropertyExpression":
case "FieldExpression":
var mberExp = exp as MemberExpression;
return GetChildValue(mberExp.Expression);
case "ConstantExpression":
var cExp = exp as ConstantExpression;
return cExp.Value;
case "UnaryExpression":
var unaryExp = exp as UnaryExpression;
return GetChildValue(unaryExp.Operand);
case "InstanceMethodCallExpressionN":
var imExp = exp as MethodCallExpression;
if (imExp.Arguments.Count > 0)
{
return GetChildValue(imExp.Arguments[0]);
}
return null;
default:
return null;
}

}
/// <summary>
/// 初始化所有参数
/// </summary>
/// <param name="paramObj"></param>
private void AppendParams(object paramObj, Dictionary<string, object> _params)
{
if (IsNullDefaultType(paramObj))
{
return;
}
if (_params == null)
{
_params = new Dictionary<string, object>();
}
foreach (var item in paramObj.GetType().GetProperties())
{
if (IsDefaultType(item.PropertyType))
{
var value = item.GetValue(paramObj, null);
if (value != null)
{
_params.Add(string.Format("@{0}", item.Name), value);
}
continue;
}

AppendParams(item.GetValue(paramObj), _params);
}

foreach (var item in paramObj.GetType().GetFields())
{
if (IsDefaultType(item.FieldType))
{
var value = item.GetValue(paramObj);
if (value != null)
{
_params.Add(string.Format("@{0}", item.Name), value);
}
continue;
}
AppendParams(item.GetValue(paramObj), _params);
}
}
public Dictionary<string, object> GetParams(object paramObj)
{
Dictionary<string, object> dicParams = new Dictionary<string, object>();
AppendParams(paramObj, dicParams);
return dicParams;
}
/// <summary>
/// 判断是否是系统默认基本类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private bool IsNullDefaultType(object obj)
{
if (obj == null)
{
return true;
}
return IsDefaultType(obj.GetType());
}
private bool IsDefaultType(Type type)
{
string defaultType = @"String|Boolean|Double|Int32|Int64|Int16|Single|DateTime|Decimal|Char|Object|Guid";

Regex e = new Regex(defaultType, RegexOptions.IgnoreCase);
if (type.Name.ToLower().Contains("nullable"))
{
if (type.GenericTypeArguments.Count() > 0)
{
return e.IsMatch(type.GenericTypeArguments[0].Name);
}
}
return e.IsMatch(type.Name);
}
}
}

在这个类中主要的方法是AnalysisExpression(Expression exp, bool isLeftChild = true)，次啊面我们来测试一下上面的那个表达式：

 

[TestMethod]
public void TestExpression()
{

Expression<Func<User, bool>> exp = u => u.Name.Contains("lilei") && u.Enabled == true;
var result = new ExpressionAnalyzer(exp).ResultData;

if (result.TableList.Count > 0)
{
foreach (var item in result.TableList)
{
Console.WriteLine("{0} AS {1}", item.Value.Name, item.Key);
}
}
Console.WriteLine("***************************************************");
if (result.StackList.Count > 0)
{
Console.WriteLine(string.Join(" ", result.StackList));
}
Console.WriteLine("***************************************************");
if (result.ParamList.Count > 0)
{
foreach (var item in result.ParamList)
{
Console.WriteLine("{0} {1}", item.Key, item.Value);
}
}
}

输出结果：

　　

再测试带参数的查询：

[TestMethod]
public void TestExpression()
{
var keyWord = "lilei";
var enable = true;

Expression<Func<User, bool>> exp = u => u.Name.Contains(keyWord) && u.Enabled == enable;
var result = new ExpressionAnalyzer(exp).ResultData;

if (result.TableList.Count > 0)
{
foreach (var item in result.TableList)
{
Console.WriteLine("{0} AS {1}", item.Value.Name, item.Key);
}
}
Console.WriteLine("***************************************************");
if (result.StackList.Count > 0)
{
Console.WriteLine(string.Join(" ", result.StackList));
}
Console.WriteLine("***************************************************");
if (result.ParamList.Count > 0)
{
foreach (var item in result.ParamList)
{
Console.WriteLine("{0} {1}", item.Key, item.Value);
}
}
}

输出结果：

　　以上是根据表达式树解析出来的Sql碎片，这为后续生成Sql语句奠定了基础。

 

http://www.cnblogs.com/lispring/p/5324348.html

转载于:https://www.cnblogs.com/sjqq/p/8428592.html

weixin_30608503
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
gosql:golang orm和sql生成器
04-13
Gosql的 gosql是Golang的简单ORM库。风格： var userList [] UserModelerr := db . FetchAll ( & userList , gosql . Columns ( "id" , "name" ), gosql . Where ( "status" , 1 ), gosql . Where ( "[like]name" , ...
java AST 表达式_Atitit.sql ast 表达式 语法树 语法 解析原理与实现 java php c#.net js python...
weixin_30989583的博客
02-16 254
Atitit.sqlast表达式语法树语法解析原理与实现javaphpc#.netjspython1.1.Sql语法树ast如下图锁死2.SQL语句解析的思路和过程2.1.lexer作为一个工具，完成了对SQL字符串的切割，将语句转化成一个tokens数组。2.2.Parser完成了SQL解析的后序部分：使用一个lexer对象作为工具，切出tokens，然后解析语义，绑定相关的系...
史上最强的JS:要求根据字符串生成树结构
phphot
02-22 4782
目的：由字符串生成树结构，树结构包含在一个div内，该div能独立放置。禁止treeview控件，禁止ActiveX，XP上自带的IE6顺利浏览就可以了。 字符串命名规则： 1.符号“&”为节点分隔符 2.无须根节点，从第一子节点开始遍历，用字符串+数字表示不同的节点，其中字符串是任意的，字符串最后一位不可以包含数字。第i层子节点就有i个数字，同一父节点下的子结点最后一位用数字从小到大标识
解析树学习笔记
m0_72410588的博客
05-11 590
本文介绍了解析树、抽象语法树以及优化后的解析树的定义和应用。解析树是一种表示语法结构的树形结构，可以用于编译器、解释器、自然语言处理等领域。抽象语法树是从解析树派生出来的树形结构，只保留与程序语义相关的信息。优化后的解析树通常用于提高程序的性能。
C#通过表达式树解析出sql语句
Ling、bug
01-07 1600
C#通过表达式树解析出sql语句，写自己的ORM必备；
（十一）.net表达式目录树Expression
lwy
11-25 1457
表达式目录树Expression拆解，动态拼装，生成sql等
simplestack.orm：SimpleStack.Orm是Dapper项目之上的一层，可基于lambda表达式生成SQL查询
01-28
是出色的项目之上的一层，该项目基于lambda表达式生成SQL查询。 它旨在通过最少的入侵和配置就可以保留类型。 所有生成的sql查询都使用参数来提高性能和安全性。 通过使用动态查询，也可以生成没有相应类型的有关...
function-orm：100％类型安全SQL querybuilder
02-08
它们都是根据您的数据库结构生成的，并提供100％的类型安全性！ 示例（草稿语法） Gostek根据您的数据库架构生成类型和模型，例如： const User = { name : 'user' , columns : { id : { type : 'int4' , not...
SQLBuilder：表达式表达式转换为SQL语句，支持SqlServer，MySql，Oracle，Sqlite，PostgreSql；基于Dapper实现了不同数据库对应的数据存储库；
01-28
SQLBuilder的 项目介绍 表达式表达式树转换为SQL语句，支持SqlServer，MySql，Oracle，Sqlite，PostgreSql 编码云地址
Rafy领域实体框架设计-重构ORM中的Sql生成
02-26
这个ORM框架可以生成比较简单的Sql语句，以处理一般性的情况。随着不断使用，我们也不断对ORM的源码做了不少改动，让它在支持简单语句生成的同时，也支持让开发人员直接使用手动编写的Sql语句来查询领域实体。但是...
基于Lambda表达式的SQL语句生成器SqlLink V0.1
03-25
基于Lambda表达式的SQL语句生成器SqlLink，增删改查……
ORM Django 终端打印 SQL 语句实现解析
09-18
主要介绍了ORM Django 终端打印 SQL 语句实现解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C# Expression 树转化为SQL语句（一）
weixin_34206899的博客
02-26 588
　　　sql有有四中基本语句，分别是增删改查，在建立model后如何生成这四中sql语句，降低开发时间。 　　　我们先模拟出一张学生表： public class Student { public int id { get; set; } public string name { get; set; } ...
c# 解析表达式目录树 写自己的ORM
Ling、bug
09-29 713
public class ExpressionAnalyzer { /// <summary> /// 表达式所有参数集合 /// </summary> private Dictionary<string, object> _params; /// <summary&...
将简单的lambda表达式树转为对应的sqlwhere条件
aitui8236的博客
05-27 2283
1、Lambda的介绍 　　园中已经有很多关于lambda的介绍了。简单来讲就是vs编译器给我带来的语法糖，本质来讲还是匿名函数。在开发中，lambda给我们带来了很多的简便。关于lambda的演变过程可以看 Lambda的演变过程 　　在这里简单的写个lambda的写法： 　　Func<int, int, int> calculate = (x, y) => {...
动态拼接Lambda表达式-表达式目录树动态构建及修改-----表达式树的访问过程，并转化成sql语句
LongtengGensSupreme博客
12-02 542
代码如下 #region 表达式树的访问过程，并转化成sql语句 /// <summary> /// 访问 表达式树 Expression<Func<MyClass, bool>> expressionFunc = x => x.Age > 5 && x.Id == 8; /// 并转化成sql语句 select * from MyClass where age > 5 and id
【手撸一个ORM】第四步、Expression（表达式目录树）扩展
weixin_30765505的博客
04-06 295
到这里，Orm的基架已经搭起来了，接下来就是激动人心的部分，表达式目录树转Sql语句，SqlDataReader转数据实体等等，但是在这之前，我们需要扩展下表达式目录树的方法，以方便后面的相关操作。 表达式目录树解析时需要的扩展方法 表达式操作符转SQL操作符，这个没什么好说的，根据表达式类型获取相应的sql操作符，如 NodeType == ExpressionType.Equal，则返...
java 统计sql_JAVA正则表达式根据查询SQL自动生成统计SQL
weixin_33013787的博客
02-16 300
/***********本人原创，欢迎转载，转载请保留本人信息*************/作者：wallimn电邮：[email protected]博客：http://blog.csdn.net/wallimn网络硬盘：http://wallimn.ys168.com时间：2009-02-05/***********文章发表请与本人联系，作者保留所有权利*************/JAVA的JDB...
使用表达式树+反射实现简易ORM对象映射操作
飞权的博客
10-19 885
使用表达式树+反射实现简易ORM对象映射操作为了简单起见我就创建一个文件 BaseDAL.cs , 使用方法也非常简单,看代码吧先创建一个Modelusing System; using System.Collections.Generic; using System.Linq; using System.Text;namespace BaseDAL.Model { [Table("User
自己动手做框架——orm,mvc,ioc框架
最新发布
01-24
自己动手做框架是一种非常有挑战性的任务，尤其是对于 ORM（对象关系映射）、MVC（模型-视图-控制器）和IOC（控制反转）这三个框架而言。以下是对这三个框架的简要介绍，以及它们的实现过程。 首先，ORM（对象关系...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值