SQL查询语句对象化的实现（C#）

在开发数据库应用的过程难免会编写大量的sql语句，其中大部份是查询语句；为不同情况编写查询语句是一件很烦琐的事件。用过hibernate或nhibernate会了解到把sql查询语句对象化后使用起非常方便和快捷；也大大减少在编写查询sql语句所带来的错误等问题。

       前段时间在编写一个数据处理类的时候同样遇到这个问题，经过一段时间思考和设计现实现了sql查询语句对象化的功能；在这里我把自己小小的成果共享一下。

在讲解前先看几个例子(数据是sqlserver的northwind)注意：例子中所涉及的除查询对象化外还包含整个数据处理类的使用，那部分还在设计和完善当中。

       1)以上语句是查询订单id为10264的订单信息

       using(hfsoft.data.idatasession session = hfsoft.data.datasessionfactory.opensession())

     {

         session.open();

         hfsoft.data.querycmd query = new querycmd("orders");

         query.expreesion.add(new hfsoft.data.eqexpression("orderid",10264));

          system.data.dataset myds = session.executedataset(query.buildercmd(session));

     }

     对象生成的sql语句：

select * from orders  where  1=1  and (orderid = @orderid0)

     2)以上语句是查询订单id大于10264并且小于10600的订单信息

       using(hfsoft.data.idatasession session = hfsoft.data.datasessionfactory.opensession())

     {

         session.open();

         hfsoft.data.querycmd query = new querycmd("orders");

         query.expreesion.add(  new hfsoft.data.leexpression("orderid",10264),

                                 new hfsoft.data.rtexpression("orderid",10600));

         system.data.dataset myds = session.executedataset(query.buildercmd(session));

     }

     对象生成的sql语句：

select * from orders  where  1=1  and (orderid > @orderid0) and (orderid < @orderid1)

4)以上语句是查询订单id大于10264并且小于10600或编号是10601,10602,10605的订单信息

using(hfsoft.data.idatasession session = hfsoft.data.datasessionfactory.opensession())

{

         session.open();

         hfsoft.data.querycmd query = new querycmd("orders");

         query.expreesion.add(  new hfsoft.data.leexpression("orderid",10264),

                       new hfsoft.data.rtexpression("orderid",10600));

         query.expreesion.add(hfsoft.data.uinttype.or,new hfsoft.data.inexpression("orderid",new int[]{10601,10602,10605}));

         system.data.dataset myds = session.executedataset(query.buildercmd(session));       }

对象生成的sql语句：

select * from orders  where  1=1  and (orderid > @orderid0) and (orderid < @orderid1) or (orderid in (@orderid20,@orderid21,@orderid22))

从上面的例子我们可以看到对不同的条件进行数据查询只是一件很简单的事情，你并不用为不同的查询情况写相应sql语句。

接下来讲术这个查询对象实现，对象的最终就是把不同字符串并起来生成相应的sql语句；sql语句查询语句主要分为以下几大部份：获取的字段，表名称，条件，排序，分组；了解select语句的对查询语句的组成部分比较了解。

其中比较难的就是条件部分处理,因为条件的组合是情况是比较多；所以设计起来相对比较复杂。在设计的过程中把条件单独抽取出来，并生成接口对条件的表达式进行描述：

/// <summary>

     /// 表达式描述接口

     /// 用于sql语句条件表达式的描述

     /// </summary>

     public interface iexpression

     {

         /// <summary>

         /// 获取表达式

         /// </summary>

         /// <param name="driver">数据处理设备提供者</param>

         /// <returns>string</returns>

         string getfilter(hfsoft.data.idrivertype driver);

         /// <summary>

         /// 获取表达式相关的参数

         /// </summary>

         /// <param name="driver">数据处理设备提供者</param>

         /// <returns>system.data.idataparameter[]</returns>

         system.data.idataparameter[] getdataparams(hfsoft.data.idrivertype driver);

         /// <summary>

         /// 序列标识

         /// 本属性用于内部处理

         /// </summary>

         string sequence

         {

              get;

              set;

         }

         /// <summary>

         /// 添加表达式

         /// </summary>

         /// <param name="unittype">合并类型(or|and)</param>

         /// <param name="expressions">表达式对象</param>

         void add(uinttype unittype,params iexpression[] expressions );

         /// <summary>

         /// 添加表达式

         /// </summary>

         /// <param name="expressions">表达式对象</param>

         void add(params iexpression[] expressions );

     }

在接口描述中有很多地方离不开hfsoft.data.idrivertype它是用于描述数据库类型。根据hfsoft.data.idrivertype    对应生成sqlserver,mysql,oracle等数据库的条件表达式。

为什么iexpression具有add方法，并且添加的对象也是iexpression；因为条件自己可以包含多个子表达式，只有这样才能够灵活组合成复杂的条件表达式。

/// <summary>

     /// 表达式基础类

     /// </summary>

     [serializable]

     public  class expression:iexpression

     {

         private string mname;

         /// <summary>

         /// 获取或设置相关的字段名

         /// </summary>

         public string name

         {

              get

              {

                   return mname;

              }

              set

              {

                   mname = value;

              }

         }

         private object mvalue;

         /// <summary>

         /// 获取或设置相关的字段值

         /// </summary>

         public object value

         {

              get

              {

                   return mvalue;

              }

              set

              {

                   mvalue = value;

              }

         }

         private string msequence = "";

         /// <summary>

         /// 获取或设置相关标识

         /// 本属性用于内部处理

         /// </summary>

         public  string sequence

         {

              get

              {

                   return msequence;

              }

              set

              {

                   msequence = value;

              }

         }

         #region iexpression 成员

         /// <summary>

         /// 获取表达式

         /// </summary>

         /// <param name="driver">数据处理设备提供者</param>

         /// <returns>string</returns>

         public virtual string getfilter(hfsoft.data.idrivertype driver)

         {

              return " 1=1 " + getsubstring(driver);

         }

         /// <summary>

         /// 获取表达式相关的参数

         /// </summary>

         /// <param name="driver">数据处理设备提供者</param>

         /// <returns>system.data.idataparameter[]</returns>

         public virtual system.data.idataparameter[] getdataparams(hfsoft.data.idrivertype driver)

         {

              return getsubparams(driver);

         }

         #endregion

         private  system.collections.arraylist _expressions = new system.collections.arraylist();

         private  system.collections.arraylist _units = new system.collections.arraylist();

         /// <summary>

         /// 添加相关表达式

         /// </summary>

         /// <param name="expressions">表达式对象</param>

         public  void add(params iexpression[] expressions )

         {

              add(uinttype.and,expressions);

         }

         /// <summary>

         /// 添加相关表达式

         /// </summary>

         /// <param name="unittype">表达式合并类型</param>

         /// <param name="expressions">表达式对象</param>

         public  void add(uinttype unittype,params iexpression[] expressions )

         {

              if(expressions != null)

                   foreach(iexpression exp in expressions)

                   {

                       if(exp != null)

                       {

                            _units.add(unittype.tostring());

                            exp.sequence = this.sequence +_expressions.count;

                            _expressions.add(exp);

                       }

                   }

         }

         /// <summary>

         /// 获取内部表达式

         /// </summary>

         /// <param name="driver">数据设备提供者</param>

         /// <returns>string</returns>

         protected string getsubstring(hfsoft.data.idrivertype driver)

         {

              if(_units.count == 0)

                   return "";

              system.text.stringbuilder sb = new system.text.stringbuilder();

              for(int i =0;i< this._units.count;i++)

              {

                   sb.append(" " +this._units[i] +" ("+ ((iexpression)_expressions[i]).getfilter(driver)+")");

              }

              return sb.tostring();

         }

         /// <summary>

         /// 获以内部表达式的参数值

         /// </summary>

         /// <param name="driver">数据设备提供者</param>

         /// <returns>system.data.idataparameter[]</returns>

         protected system.data.idataparameter[] getsubparams(hfsoft.data.idrivertype driver)

         {

              if(_expressions.count ==0)

                   return null;

              if(_expressions.count ==1)

              {

                   return ((iexpression)_expressions[0]).getdataparams(driver);

              }

              system.collections.arraylist lst = new system.collections.arraylist();

              foreach(iexpression exp in this._expressions)

              {

                   system.data.idataparameter[] ps = exp.getdataparams(driver);

                   if(ps !=null && ps.length >0)

                   {

                       foreach(system.data.idataparameter dp in ps)

                       {

                            lst.add(dp);

                       }

                   }

              }

              array array = array.createinstance(typeof(system.data.idataparameter),lst.count);

              lst.copyto(array);

              return array as system.data.idataparameter[];

         }

     }

其实expression只是一个模板类，它自己本生并没有条件处理的能力只是一个简单的1=1；下面我们根据这个模板类派生出具体表达式类型。

/// <summary>

     /// 基础表达式抽象类

     /// </summary>

     [serializable]

     public abstract class baseexpression:expression

     {

         /// <summary>

         /// 获取表达式参数对象集

         /// </summary>

         /// <param name="driver">数据设备提供者</param>

         /// <returns>system.data.idataparameter[]</returns>

         public override system.data.idataparameter[] getdataparams(hfsoft.data.idrivertype driver)

         {

              system.data.idataparameter p1 = driver.getparameter(name+ sequence,value);

              return paramsconcat(new system.data.idataparameter[]{p1},getsubparams(driver));

         }

         /// <summary>

         /// 获取表达式

         /// </summary>

         /// <param name="driver">数据设备提供者</param>

         /// <returns>string</returns>

         public override string getfilter(hfsoft.data.idrivertype driver)

         {

              system.text.stringbuilder sb = new system.text.stringbuilder();

              sb.append(name);

              sb.append(getcomparetype());

              sb.append(driver.formatnameforparameter(name + this.sequence));

              return sb.tostring();

         }

         /// <summary>

         /// 表达式类型

         /// =,like等

         /// </summary>

         /// <returns>string</returns>

         protected abstract string getcomparetype();

     }

     /// <summary>

     /// 等于表达式

     /// </summary>

     [serializable]

     public class eqexpression:baseexpression

     {

         /// <summary>

         /// 构造等于表达式对象

         /// </summary>

         public eqexpression()

         {

         }

         /// <summary>

         /// 构造指定名称和值的等于表达式对象

         /// </summary>

         /// <param name="name">名称</param>

         /// <param name="value">值</param>

         public eqexpression(string name,object value)

         {

              name = name;

              value = value;

         }

         /// <summary>

         /// 表达式比较符

         /// </summary>

         /// <returns>string</returns>

         protected override string getcomparetype()

         {

              return " = ";

         }

     }

整个条件对象的设计就完成了，文章代码中只有实现了等于的表达式对象；我们可以按自己情况编写更复杂的表达式。条件表达式对象在整个查询对象中是比较核心的部心，因为在整个sql查询语句中除了这些条件外其它地方都是固定的，剩下的就是把些不同的字符串合并起来，这些东西就不详细说了大家比较了解。

其实expression只是一个模板类，它自己本生并没有条件处理的能力只是一个简单的1=1；下面我们根据这个模板类派生出具体表达式类型。

/// <summary>

     /// 基础表达式抽象类

     /// </summary>

     [serializable]

     public abstract class baseexpression:expression

     {

         /// <summary>

         /// 获取表达式参数对象集

         /// </summary>

         /// <param name="driver">数据设备提供者</param>

         /// <returns>system.data.idataparameter[]</returns>

         public override system.data.idataparameter[] getdataparams(hfsoft.data.idrivertype driver)

         {

              system.data.idataparameter p1 = driver.getparameter(name+ sequence,value);

              return paramsconcat(new system.data.idataparameter[]{p1},getsubparams(driver));

         }

         /// <summary>

         /// 获取表达式

         /// </summary>

         /// <param name="driver">数据设备提供者</param>

         /// <returns>string</returns>

         public override string getfilter(hfsoft.data.idrivertype driver)

         {

              system.text.stringbuilder sb = new system.text.stringbuilder();

              sb.append(name);

              sb.append(getcomparetype());

              sb.append(driver.formatnameforparameter(name + this.sequence));

              return sb.tostring();

         }

         /// <summary>

         /// 表达式类型

         /// =,like等

         /// </summary>

         /// <returns>string</returns>

         protected abstract string getcomparetype();

     }

     /// <summary>

     /// 等于表达式

     /// </summary>

     [serializable]

     public class eqexpression:baseexpression

     {

         /// <summary>

         /// 构造等于表达式对象

         /// </summary>

         public eqexpression()

         {

         }

         /// <summary>

         /// 构造指定名称和值的等于表达式对象

         /// </summary>

         /// <param name="name">名称</param>

         /// <param name="value">值</param>

         public eqexpression(string name,object value)

         {

              name = name;

              value = value;

         }

         /// <summary>

         /// 表达式比较符

         /// </summary>

         /// <returns>string</returns>

         protected override string getcomparetype()

         {

              return " = ";

         }

     }

整个条件对象的设计就完成了，文章代码中只有实现了等于的表达式对象；我们可以按自己情况编写更复杂的表达式。条件表达式对象在整个查询对象中是比较核心的部心，因为在整个sql查询语句中除了这些条件外其它地方都是固定的，剩下的就是把些不同的字符串合并起来，这些东西就不详细说了大家比较了解。