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

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

var sql=Sql.Builder.Select(“*”).From(“person”).Where(“ID=@0”,”1345”)
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 > 0)
                {
                    sb.Append("
");
                }
                var sql = ParametersHelper.ProcessParams(mInitialSQL, mInitialArgs, args);
                //累加where条件
                if (Is(lhs, "WHERE ") && Is(this, "WHERE "))
                    sql = "AND " + sql.Substring(6);
                //累加Order by 条件
                if (Is(lhs, "ORDER BY ") && Is(this, "ORDER BY "))
                    sql = ", " + sql.Substring(9);
                //累加set语句
                if (Is(lhs, "SET ") && Is(this, "SET "))
                    sql = ", " + sql.Substring(4);

                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);
        }
    }