转载

左求值表达式,堆栈,调试陷阱与动态构造查询条件

1,表达式的求值顺序与堆栈结构

“表达式”是程序语言一个很重要的术语,也是大家天天写的程序中很常见的东西,但是表达式的求值顺序一定是从左到右么?  C/C++语言中没有明确规定表达式的运算顺序(从左到右,或是从右到左) ,这点与C#及Java语言都不同。不过可以确定的是,C#表达式的求值顺序一定是从左到右的。这个问题虽然对于大多数情况来说不重要,甚至很多普通C#,Java开发者都会忽略的问题,但是对于语言设计者,框架设计者,这是有可能需要考虑的问题。

堆栈是2种数据结构,“栈” 是一种后进先出的数据结构,也就是说后存放的先取,先存放的后取。这就如同我们要取出放在箱子里面底下的东西,我们首先要移开压在它上面的物体。这个特点常用于函数的嵌套调用,用于记录每一次函数调用的点,以便下级函数调用完毕后返回该记录点继续执行,最典型的应用就是函数的递归调用。

根据表达式的求值顺序,再结合堆栈结构,程序语言就可以知道表达式的调用结构,知道方法参数的求值顺序, SOD框架 恰好利用了这个特征来构建ORM查询语言--OQL。

2,“字段堆栈”与实体类属性调用的“秘密”

OQL内置了一个堆栈对象:

/// <summary> /// 字段堆栈 /// </summary> protected internal Stack<TableNameField> fieldStack = new Stack<TableNameField>();

这个堆栈内存放的是表名称字段对象,它的定义是:

左求值表达式,堆栈,调试陷阱与动态构造查询条件
public class TableNameField {  /// <summary>  /// 获取表名称  /// </summary>  public string Name {  get;}  /// <summary>  /// 原始字段名  /// </summary>  public string Field;  /// <summary>  /// 关联的实体类  /// </summary>  public EntityBase Entity;  /// <summary>  /// 在一系列字段使用中的索引号  /// </summary>  public int Index;  /// <summary>  /// 字段对应的值  /// </summary>  public object FieldValue;  /// <summary>  /// 在SQL语句中使用的字段名  /// </summary>  public string SqlFieldName  {     get;set;  } } 
TableNameField

在每一个OQL对象上,都有关联的SOD框架的实体类,它有一个“属性访问事件”,OQL对象订阅了该事件:

public class OQL {  /// <summary>  /// 字段堆栈  /// </summary>  protected internal Stack<TableNameField> fieldStack = new Stack<TableNameField>();  public OQL(EntityBase e)  {      //其它略      e.PropertyGetting += new EventHandler<PropertyGettingEventArgs>(e_PropertyGetting);  }  void e_PropertyGetting(object sender, PropertyGettingEventArgs e)  {      TableNameField tnf = new TableNameField()      {   Field = e.PropertyName,   Entity = (EntityBase)sender,   Index = this.GetFieldGettingIndex()      };      fieldStack.Push(tnf);  }  //其它方法略 } 

这样,在OQL实例表达式中,每一次调用关联的实体类的属性,就会将该属性对应的字段名信息,压入字段堆栈。这些字段信息,将用来构造SQL的 Select,Where,Order 子句,本篇将讲解它是如何构造Where条件子句的。

OQL的Where方法支持多种条件构造方式,其中一种是使用OQLCompare对象来做条件。由于OQLCompare 对象设计成了OQL的子对象,因此它也能访问 fieldStack 对象,利用它提供的信息,构造条件信息。

/// <summary>  /// 实体对象条件比较类,用于复杂条件比较表达式  /// </summary>  public class OQLCompare //: IDisposable  {     /// <summary>   /// 关联的OQL对象   /// </summary>   public OQL LinkedOQL { get;protected internal set; }   public OQLCompare(OQL oql)   {    if (oql == null)     throw new ArgumentException("OQLCompare 关联的OQL对象为空!");    this.LinkedOQL = oql;   }     //其它内容略    } 

此后,就可以像下面这样构造并使用一个OQL查询对象:

User user=new User(); OQL q=OQL.From(user)   .Select(user.ID,user.Name)   .Where(cmp=>cmp.Comparer(user.Age,">",18)) .END; List<User> users=EntityQuery<User>.QueryList(q);

这个查询是查询所有年龄大于18岁的用户,在Where方法中,cmp对象就是一个OQLCompare 对象,它的Comparer方法使用了user对象的Age属性,在方法执行的时候,user.Age 被求值,字段名“Age” 被压入OQL的字段堆栈,于是,OQL可以构造出类似下面的SQL语句:

Select ID ,Name From Tb_User   Where Age > @P0 -- P0 = 18

当然我们可以直接调用OQL的方法,打印出SQL语句和参数信息,下面会说。

聪明的读者你可能想到了,这是在利用表达式求值得“副作用”啊,本来只是对 user.Age 属性求值而已,但却利用该属性求值过程中引发的事件,得到了使用的字段信息,然后利用这个信息来构造SQL语句!

这是一个“巧妙”的运用, OQL避开了反射,也没有使用"表达式树",所以OQL生成SQL的过程非常高效,不会有EF的第一次查询非常慢的问题。

在OQLCompare对象的Comparer方法上,第三个参数除了是一个要比较的值,也可以是另外一个字段,例如下面的查询规则定义的符合最低年龄设置的用户:

User user=new User(); Rule rule = new Rule(); OQL q=OQL.From(user)   .InnerJoin(rule).On(user.RuleID,rule.ID)   .Select(user.ID,user.Name)   .Where(cmp=>cmp.Comparer(user.Age,">",rule.LowAge)) .END; List<User> users=EntityQuery<User>.QueryList(q);

该查询会生成下面的SQL语句:

Select M.ID,M.Name   From Tb_User M     Inner Join Tb_Rule T0 ON M.RuleID = T0.ID      Where M.Age > T0.LowAge

在这个查询中,OQLCompare对象使用的OQL字段堆栈的情况是:

  1. 调用方法 Comparer
  2. 求取 uer.Age属性,得到 "M.Age" 字段名,压入字段堆栈;
  3. 求取 rule.LowAg属性, 得到 "T0.LowAge" 字段名,压入字段堆栈;

假设此时程序运行在调试状态,在这里有一个断点中断了,在VS的IDE 上查看了其它属性的值,比如看了下 user.ID,user.Name,那么此时OQL的堆栈数据是:

Stack:(0--“M.ID”,1--“M.Name”)

当方法Comparer 执行后,堆栈的结果是:

Stack:(0--“T0.LowAge”,1--“M.Age”, 2--“M.ID”,3--“M.Name”)

调用OQL方法,生成条件字符串的时候,从该堆栈弹出字段信息:

Pop Stack:0--“T0.LowAge”  Pop Stack:1--“M.Age”

实际上,在OQLComare对象的Comparer方法中进行了上面的堆栈“弹出”操作,并且返回了一个新的 OQLCompare 对象,根据C#语言的“左求值表达式”原则 ,这个新的OQLCompare 对象获得了下面的信息:

compare.ComparedFieldName ="M.Age" ; compare.ComparedParameterName ="T0.LowAge" ; compare.ComparedType =">" ;

该信息完全表达了构建OQL ”查询的原意“,并指导生成正确的查询条件:

M.Age > T0.LowAge

由于每次调用Comparer方法都生成了这样的一个新的 OQLCompare 对象,所以整个OQLCompare 对象是一个“组合对象”,组合中有根,有枝条,有叶子,组合成为一个“条件对象树”,有这样一棵树,那么再复杂的查询条件,都可以表示了。

3,动态构造查询条件与“调试陷阱”

从上面的举例,我们发现OQLCompare对象即能够进行【字段与值】进行比较,又能够进行【字段与字段】的条件比较,而且也能识别不同表的字段在一起进行比较。

但是,在这个过程中,有可能遭遇”调试陷阱“。

3.1,字段堆栈--避免“调试陷阱”

回看开始的例子:

User user=new User(); OQL q=OQL.From(user)   .Select(user.ID,user.Name)   .Where(cmp=>cmp.Comparer(user.Age,">",18)) .END; List<User> users=EntityQuery<User>.QueryList(q);

加入有色背景处是一个断点,程序运行到这里进入调试模式,而此时鼠标放在了 user.ID上面,那么当方法执行到 Comparer里面去以后,我们来看看堆栈的结果:

Stack:(0--“Age”,1--“ID”)

在方法执行过程中,首先弹出第一个值:

Pop Stack:0--“Age”

但是SOD框架并不知道这个字段信息是 Comparer方法的第一个参数,还是第三个参数,不过拿 user.Age 的值跟第三个参数的值 18 进行比较,user.Age !=18 ,所以可以断定,字段信息”Age“ 发生在方法的第一个参数调用上,而不是第三个参数,因此,字段堆栈的第二个元素,(1-- ”ID“) 也就没有必要弹出了,等到方法执行完成,将Stack 字段堆栈清除即可,这样在下一次调用开始的时候,不会造成干扰。

3.2,动态构造查询条件的 类“调试陷阱”

但是这个处理方案并不能完全化解”调试陷阱“的问题,而且,有时候这个问题不是发生在调试状态,也有可能发生在动态构造条件的过程中,请参考下面的例子:

  void TestIfCondition2() {  Users user = new Users() { ID = 0, NickName = "abc", UserName="zhang san", Password="pwd111" };  OQL q7 = OQL.From(user)   .Select()   .Where<Users>(CreateCondition)   .END;  Console.WriteLine("OQL by 动态构建 OQLCompare Test(委托函数方式):/r/n{0}", q7);  Console.WriteLine(q7.PrintParameterInfo()); } OQLCompare CreateCondition(OQLCompare cmp, Users user) {  OQLCompare cmpResult = null;  if (user.NickName != "")   cmpResult = cmp.Comparer(user.NickName, "=", user.NickName);  // 上面一行,也可以采用这样的写法: cmpResult = cmp.EqualValue(user.NickName);  if (user.ID > 0)   cmpResult = cmpResult & cmp.Comparer(user.ID, "=", user.ID);  else   cmpResult = cmpResult & cmp.Comparer(user.UserName, "=", "zhang san")            & cmp.Comparer(user.Password, "=", "pwd111");  return cmpResult; } 

运行这个程序,会输出下面的SQL语句和参数信息:

OQL by 动态构建 OQLCompare Test(委托函数方式): SELECT  [ID],[UserName],[Password],[NickName],[RoleID],[Authority],[IsEnable], [LastLoginTime],[LastLoginIP],[Remarks],[AddTime] FROM [LT_Users]      WHERE    [NickName] = @P0 AND  [ID] =  [UserName]  AND  [Password] = @P1 --------OQL Parameters information----------  have 2 parameter,detail:   @P0=abc        Type:String   @P1=pwd111     Type:String ------------------End------------------------

请注意SQL条件中的背景标注部分,[ID] =  [UserName] 这个条件,显然不是我们期望的,出现这个问题的原因是什么呢?原来问题出在这个程序段:

if (user.ID > 0)                 cmpResult = cmpResult & cmp.Comparer(user.ID, "=", user.ID);             else                 cmpResult = cmpResult & cmp.Comparer(user.UserName, "=", "zhang san")                                         & cmp.Comparer(user.Password, "=", "pwd111");

程序选择了 else 分支,执行了cmp.Comparer( user.UserName, " = ", "zhang san")  这句,但是,在本例中,user.UserName 的值恰好就是 “zhang san”,所以 Comparer方法的第一个参数和第三个参数的值是一样的,而此时的OQL堆栈的数据是:

Stack:(0--“UserName”,1--“ID”)

OQL会首先弹出堆栈的元素 "UserName" 字段,然后让它对应的实体类属性值与Comparer方法的第三个参数值进行比较,发现这2个值是相同的,于是假设"UserName"字段调用发生在Comparer方法的第三个参数上,于是继续弹出OQL字段堆栈的下一个元素:

Pop Stack:1--“ID”

于是将字段名“ID” 作为Comparer方法的第一个参数调用的“副作用”结果,构造成了 [ID] =  [UserName] 这个条件。

这个错误出现的情况并不常见,简单说就是当Comparer方法第一个参数和第三个参数的值一样的时候,OQL可能会出现错误。

3.3,消除复杂查询条件的“字段堆栈“干扰

要解决这个问题也很容易,将上面的代码改写成下面这个样子:

 OQLCompare CreateCondition(OQLCompare cmp, Users user) {  OQLCompare cmpResult = null;  if (user.NickName != "")   cmpResult = cmp.Comparer(user.NickName, "=", user.NickName);  // 上面一行,也可以采用这样的写法: cmpResult = cmp.EqualValue(user.NickName);  if (user.ID > 0)   cmpResult = cmpResult & cmp.Comparer(user.ID, "=", user.ID);  else   cmpResult = cmpResult & cmp.EqualValue(user.UserName)            & cmp.Comparer(user.Password, "=", "pwd111");  return cmpResult; } 

这里将使用 user.UserName 自身的值进行相等比较,避免了字段堆栈的影响。如果不是自身的值相等比较,那么还可以利用操作符重载,进行更多的比较方式,比如大于,小于等:

 OQLCompare CreateCondition(OQLCompare cmp, Users user) {  OQLCompare cmpResult = null;  if (user.NickName != "")   cmpResult = cmp.Comparer(user.NickName, "=", user.NickName);  // 上面一行,也可以采用这样的写法: cmpResult = cmp.EqualValue(user.NickName);  if (user.ID > 0)   cmpResult = cmpResult & cmp.Comparer(user.ID, "=", user.ID);  else   cmpResult = cmpResult & cmp.Property(user.UserName) == "zhang san"           & cmp.Comparer(user.Password, "=", "pwd111");  return cmpResult; } 

如果出于性能上的考虑或者进行Like 查询等,必须使用Comparer 方法,要解决这种“属性与比较的值相等”的OQL堆栈字段干扰问题,还可调用OQLCompare对象的的NewCompare方法:

 OQLCompare CreateCondition(OQLCompare cmp, Users user) {  OQLCompare cmpResult = null;  if (user.NickName != "")   cmpResult = cmp.Comparer(user.NickName, "=", user.NickName);  // 上面一行,也可以采用这样的写法: cmpResult = cmp.EqualValue(user.NickName);  if (user.ID > 0)   cmpResult = cmpResult & cmp.Comparer(user.ID, "=", user.ID);  else   cmpResult = cmpResult & cmp.NewCompare().Comparer(user.UserName,"=", "zhang san")           & cmp.Comparer(user.Password, "=", "pwd111");  return cmpResult; } 

如果觉得上面的方式繁琐,那么还有一个更直接的办法,就是动态构造条件的时候,不在 关联的实体类上调用属性 进行条件判断,而是 创建另外一个实体类对象 (不可以使用克隆的方式):

 OQLCompare CreateCondition(OQLCompare cmp, Users user) {  Users testUser = new Users {  NickName =user.NickName , ID =user.ID};  OQLCompare cmpResult = null;  if (testUser.NickName != "")   cmpResult = cmp.Comparer(user.NickName, "=", user.NickName);  // 上面一行,也可以采用这样的写法: cmpResult = cmp.EqualValue(user.NickName);  if (testUser.ID > 0)   cmpResult = cmpResult & cmp.Comparer(user.ID, "=", user.ID);  else   cmpResult = cmpResult & cmp.Comparer(user.UserName,"=", "zhang san")           & cmp.Comparer(user.Password, "=", "pwd111");  return cmpResult; } 

当然,可能最简单的方式,还是你有意让Comparer 方法的第一实体类属性值参数和第三个普通值参数的值不要相等,这在大多数情况下都是可以做到的。

采用上面的方式处理后,对于OQL动态构造查询条件,可以得到下面正确的SQL信息:

OQL by 动态构建 OQLCompare Test(委托函数方式): SELECT  [ID],[UserName],[Password],[NickName],[RoleID],[Authority],[IsEnable], [LastLoginTime],[LastLoginIP],[Remarks],[AddTime] FROM [LT_Users]      WHERE    [NickName] = @P0 AND  [UserName] = @P1  AND  [Password] = @P2 --------OQL Parameters information----------  have 3 parameter,detail:   @P0=abc        Type:String   @P1=zhang san          Type:String   @P2=pwd111     Type:String ------------------End------------------------

小节

本篇说明了编程语言左求值表达式规则,堆栈数据结构,并利用这两个特征,结合属性调用事件 ,巧妙的设计了SOD框架的”ORM查询语言“--OQL,并详细的分析了可能产生的问题与解决方案。如果使用PDF.NET SOD框架来处理动态的查询条件,那么本篇文章一定要仔细阅读一下。

感谢大家一直以来对于PDF.NET SOD框架的支持,

框架官网地址:http://www.pwmis.com/sqlmap

开源项目地址:http://pwms.codeplex.com

注意:本文的解决方案和实例程序,需要SOD框架的新版本 5.2.3.0429 以上支持,如果程序中有动态构造查询条件的情况,请大家及时获取最新的源代码。

正文到此结束
Loading...