PetaPoco源代码学习--3.Sql类

　　PetaPoco对数据库的操作直接使用SQL语句，在代码中进行调用既可以直接传递SQL语句，也可以使用提供的SQL类来获取到SQL语句进行操作，直接传递SQL语句在内部实现中也是封装成Sql类传递到底层来操作的。Sql类实际上就是对SQL语句的一种封装，使你能够向操作类的方法一样来使用SQL语句。比如，

 var sql=Sql.Builder.Select(“*”).From(“person”).Where(“ID=@”,””)
 var sqlStr=sql.SQL;//select * from person where ID=’1345’;

　　Sql类采用函数式编程的思想，对SQL语句进行了抽象。当然，如果觉得这种表达方式不好，也可以直接传递SQL语句。

备注：使用Sql类时，如果传递参数，则在sql语句中@X进行占位，每次调用一个方法都从0开始，依次增加。

以下是对Sql类的详细描述：

 /// <summary>
     /// SQL语句类
     /// </summary>
     public class Sql
     {
         /// <summary>
         /// 初始SQL语句
         /// </summary>
         private string mInitialSQL;

         /// <summary>
         /// 初始SQL参数
         /// </summary>
         private object[] mInitialArgs;

         /// <summary>
         /// 最终SQL语句
         /// </summary>
         private string mFinalSQL;

         /// <summary>
         /// 最终SQL参数
         /// </summary>
         private object[] mFinalArgs;

         /// <summary>
         /// right-hand-side 引用，理解为后继
         /// </summary>
         private Sql mRHS;

         /// <summary>
         ///  获取实例
         /// </summary>
         public static Sql Builder
         {
             get { return new Sql(); }
         }

         /// <summary>
         ///  获取SQL语句
         /// </summary>
         public string SQL
         {
             get
             {
                 Build();
                 return mFinalSQL;
             }
         }

         /// <summary>
         /// 获取构建SQL语句的参数
         /// </summary>
         public object[] Arguments
         {
             get
             {
                 Build();
                 return mFinalArgs;
             }
         }

         /// <summary>
         /// 默认构造器
         /// </summary>
         public Sql()
         {
         }

         /// <summary>
         /// 构造函数
         /// </summary>
         /// <param name="sql">SQL语句</param>
         /// <param name="args">SQL语句对应的参数</param>
         public Sql(string sql, params object[] args)
         {
             mInitialSQL = sql;
             mInitialArgs = args;
         }

         private void Build()
         {
             //只需要构建一次即可
             if (mFinalSQL != null)
                 return;
             //根据SQL语句和参数构建最终语句
             var sb = new StringBuilder();
             var args = new List<object>();
             Build(sb, args, null);
             mFinalSQL = sb.ToString();
             mFinalArgs = args.ToArray();
         }

         /// <summary>
         ///  向当前SQL实例添加后继SQL实例   Append another SQL builder instance to the right-hand-side of this SQL builder
         /// </summary>
         /// <param name="sql">后继SQL实例</param>
         /// <returns>返回对象自身</returns>
         public Sql Append(Sql sql)
         {
             //若当前对象包括后继对象，则向其后继对象添加后继对象
             if (mRHS != null)
                 mRHS.Append(sql);
             else
                 mRHS = sql;
             mFinalSQL = null;
             return this;
         }

         /// <summary>
         ///  向当前SQL实例添加SQL语句和对应参数
         /// </summary>
         /// <param name="sql">SQL语句</param>
         /// <param name="args">对应参数</param>
         /// <returns>返回对象自身</returns>
         public Sql Append(string sql, params object[] args)
         {
             return Append(new Sql(sql, args));
         }

         /// <summary>
         /// 判断SQL语句是否与参数表示类型相同
         /// </summary>
         /// <param name="sql">SQL帮助类</param>
         /// <param name="sqltype">SQL类型</param>
         /// <returns></returns>
         private static bool Is(Sql sql, string sqltype)
         {
             return sql != null && sql.mInitialSQL != null && sql.mInitialSQL.StartsWith(sqltype, StringComparison.InvariantCultureIgnoreCase);
         }

         /// <summary>
         /// 构建SQL语句
         /// </summary>
         /// <param name="sb">StringBuilder保存Sql语句</param>
         /// <param name="args">SQL参数</param>
         /// <param name="lhs">SQL实例</param>
         private void Build(StringBuilder sb, List<object> args, Sql lhs)
         {
             if (!string.IsNullOrEmpty(mInitialSQL))
             {
                 if (sb.Length > )
                 {
                     sb.Append("\n");
                 }
                 var sql = ParametersHelper.ProcessParams(mInitialSQL, mInitialArgs, args);
                 //累加where条件
                 if (Is(lhs, "WHERE ") && Is(this, "WHERE "))
                     sql = "AND " + sql.Substring();
                 //累加Order by 条件
                 if (Is(lhs, "ORDER BY ") && Is(this, "ORDER BY "))
                     sql = ", " + sql.Substring();
                 //累加set语句
                 if (Is(lhs, "SET ") && Is(this, "SET "))
                     sql = ", " + sql.Substring();

                 sb.Append(sql);
             }
             //处理当前实例的后继实例（递归）
             if (mRHS != null)
                 mRHS.Build(sb, args, this);
         }

         /// <summary>
         /// 向SQL实例添加set语句
         /// </summary>
         /// <param name="sql">update中的set语句，形如"{field} = {value}" </param>
         /// <param name="args">可选参数</param>
         /// <returns>当前SQL实例</returns>
         public Sql Set(string sql, params object[] args)
         {
             return Append(new Sql("SET " + sql, args));
         }

         /// <summary>
         /// 向SQL实例添加where语句
         /// </summary>
         /// <param name="sql">where语句</param>
         /// <param name="args">可选参数</param>
         /// <returns>当前SQL实例</returns>
         public Sql Where(string sql, params object[] args)
         {
             return Append(new Sql("WHERE (" + sql + ")", args));
         }

         /// <summary>
         /// 向SQL实例添加order by语句
         /// </summary>
         /// <param name="columns">待排序的列名称</param>
         /// <returns>当前SQL实例</returns>
         public Sql OrderBy(params object[] columns)
         {
             return Append(new Sql("ORDER BY " + string.Join(", ", (from x in columns select x.ToString()).ToArray())));
         }

         /// <summary>
         /// 向SQL实例添加select语句
         /// </summary>
         /// <param name="columns">查询的结果列名称</param>
         /// <returns>当前SQL实例</returns>
         public Sql Select(params object[] columns)
         {
             return Append(new Sql("SELECT " + string.Join(", ", (from x in columns select x.ToString()).ToArray())));
         }

         /// <summary>
         /// 向SQL实例添加查询表（多个表相互连接，数量指数级增长）
         /// </summary>
         /// <param name="tables">查询的表名称</param>
         /// <returns>当前SQL实例</returns>
         public Sql From(params object[] tables)
         {
             return Append(new Sql("FROM " + string.Join(", ", (from x in tables select x.ToString()).ToArray())));
         }

         /// <summary>
         /// 向SQL实例添加group by语句
         /// </summary>
         /// <param name="columns">待分组列名称</param>
         /// <returns>当前SQL实例</returns>
         public Sql GroupBy(params object[] columns)
         {
             return Append(new Sql("GROUP BY " + string.Join(", ", (from x in columns select x.ToString()).ToArray())));
         }

         /// <summary>
         /// 数据表连接
         /// </summary>
         /// <param name="joinType">连接类型</param>
         /// <param name="table">待连接表名称</param>
         /// <returns>SqlJoinClause实例</returns>
         private SqlJoinClause Join(string joinType, string table)
         {
             return new SqlJoinClause(Append(new Sql(joinType + table)));
         }

         /// <summary>
         /// 数据表内连接
         /// </summary>
         /// <param name="table">待连接表名称</param>
         /// <returns>SqlJoinClause实例</returns>
         public SqlJoinClause InnerJoin(string table)
         {
             return Join("INNER JOIN ", table);
         }

         /// <summary>
         /// 数据表外连接
         /// </summary>
         /// <param name="table">待连接表名称</param>
         /// <returns>SqlJoinClause实例</returns>
         public SqlJoinClause LeftJoin(string table)
         {
             return Join("LEFT JOIN ", table);
         }

         /// <summary>
         /// 获取最终的SQL语句
         /// </summary>
         public override string ToString()
         {
             return SQL;
         }
     }

     /// <summary>
     ///  SQL连接语句
     /// </summary>
     public class SqlJoinClause
     {
         /// <summary>
         /// 待连接的SQL对象
         /// </summary>
         private readonly Sql _sql;

         /// <summary>
         /// 构造函数
         /// </summary>
         /// <param name="sql"></param>
         public SqlJoinClause(Sql sql)
         {
             _sql = sql;
         }

         /// <summary>
         /// 向SQL对象添加表连接条件
         /// </summary>
         /// <param name="onClause">表连接条件</param>
         /// <param name="args">可选参数</param>
         /// <returns>SQL对象</returns>
         public Sql On(string onClause, params object[] args)
         {
             return _sql.Append("ON " + onClause, args);
         }
     }