在開發數據庫應用的過程難免會編寫大量的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查詢語句中除了這些條件外其它地方都是固定的，剩下的就是把些不同的字符串合并起來，這些東西就不詳細說了大家比較了解。