示例#1
0
        /// <summary>
        /// 获取选择语句内容
        /// </summary>
        /// <param name="baseCommand">源选择语句</param>
        /// <param name="orderReverse">是否反转排序</param>
        /// <returns>选择语句内容</returns>
        internal static String InternalGetPagerCommand(SelectCommand baseCommand, Boolean orderReverse)
        {
            SqlCommandBuilder sb = new SqlCommandBuilder(baseCommand.Database);

            sb.AppendSelectPrefix();

            if (baseCommand.PageSize > 0 && baseCommand.RecordStart > 0)//分页模式
            {
                /*
                 *  SELECT * FROM
                 *  (
                 *      SELECT TOP 30 *, ROW_NUMBER() OVER(ORDER BY ID ASC) AS RN
                 *      FROM TABLE_NAME
                 *  ) AS T
                 *  WHERE RN > 20
                 */

                sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.UseDistinct, baseCommand.InternalGetQueryFieldList());

                SqlCommandBuilder innerBuilder = new SqlCommandBuilder(baseCommand.Database);
                innerBuilder.AppendSelectOrderBys(baseCommand.InternalGetOrderList(), false);

                SelectCommand innerCommand = baseCommand.Database.InternalCreateSelectCommand(baseCommand, baseCommand.TableName);
                innerCommand.InternalQuerys(baseCommand.QueryFields);
                innerCommand.InternalQuerys(SqlQueryField.InternalCreateFromFunction(baseCommand, "ROW_NUMBER() OVER( " + innerBuilder.ToString() + ")", "RN"));
                innerCommand.PageSize = baseCommand.RecordStart + baseCommand.PageSize;
                innerCommand.InternalSetJoinList(baseCommand);
                innerCommand.InternalSetWhereCondition(baseCommand);
                innerCommand.InternalSetGroupByFieldList(baseCommand);
                innerCommand.InternalSetHavingCondition(baseCommand);

                sb.AppendSelectFrom(innerCommand.GetCommandText("T"), true);
                sb.AppendWhere(baseCommand.ConditionBuilder.GreaterThanColumn("RN", baseCommand.RecordStart.ToString()));
            }
            else//正常模式
            {
                if (baseCommand.PageSize > 0)
                {
                    sb.AppendSelectTop(baseCommand.PageSize);
                }

                sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.UseDistinct, baseCommand.InternalGetQueryFieldList());
                sb.AppendSelectFromAndJoins(baseCommand.TableName, baseCommand.IsFromSql, baseCommand.InternalGetJoinList());

                sb.AppendWhere(baseCommand.WhereCondition);
                sb.AppendSelectGroupBys(baseCommand.InternalGetGroupByFieldList());
                sb.AppendHaving(baseCommand.InternalGetHavingCondition());
                sb.AppendSelectOrderBys(baseCommand.InternalGetOrderList(), orderReverse);
            }

            return(sb.ToString());
        }
        /// <summary>
        /// 获取选择语句内容
        /// </summary>
        /// <param name="baseCommand">源选择语句</param>
        /// <param name="orderReverse">是否反转排序</param>
        /// <returns>选择语句内容</returns>
        internal static String InternalGetPagerCommand(SelectCommand baseCommand, Boolean orderReverse)
        {
            SqlCommandBuilder sb = new SqlCommandBuilder(baseCommand.Database);
            sb.AppendSelectPrefix();

            if (baseCommand.PageSize > 0 && baseCommand.RecordStart > 0)//分页模式
            {
                /*
                    SELECT * FROM
                    (
                        SELECT TOP 30 *, ROW_NUMBER() OVER(ORDER BY ID ASC) AS RN
                        FROM TABLE_NAME
                    ) AS T
                    WHERE RN > 20
                */

                sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.QueryFields);

                SqlCommandBuilder innerBuilder = new SqlCommandBuilder(baseCommand.Database);
                innerBuilder.AppendSelectOrderBys(baseCommand.SqlOrders, false);

                SelectCommand innerCommand = new SelectCommand(baseCommand.Database, baseCommand.TableName);
                innerCommand.InternalQuerys(baseCommand.QueryFields.ToArray());
                innerCommand.InternalQuerys(SqlQueryField.InternalCreateFromFunction(baseCommand, "ROW_NUMBER() OVER( " + innerBuilder.ToString() + ")", "RN"));
                innerCommand.PageSize = baseCommand.RecordStart + baseCommand.PageSize;
                innerCommand.SqlJoins = baseCommand.SqlJoins;
                innerCommand.SqlWhere = baseCommand.SqlWhere;
                innerCommand.GroupByColumns = baseCommand.GroupByColumns;
                innerCommand.SqlHaving = baseCommand.SqlHaving;

                sb.AppendSelectFrom(innerCommand.GetCommandText("T"), true);
                sb.AppendWhere(SqlCondition.GreaterThanColumn(baseCommand, "RN", baseCommand.RecordStart.ToString()));
            }
            else//正常模式
            {
                if (baseCommand.PageSize > 0)
                {
                    sb.AppendSelectTop(baseCommand.PageSize);
                }

                sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.QueryFields);
                sb.AppendSelectFromAndJoins(baseCommand.TableName, baseCommand.IsFromSql, baseCommand.SqlJoins);

                sb.AppendWhere(baseCommand.SqlWhere);
                sb.AppendSelectGroupBys(baseCommand.GroupByColumns);
                sb.AppendHaving(baseCommand.SqlHaving);
                sb.AppendSelectOrderBys(baseCommand.SqlOrders, orderReverse);
            }

            return sb.ToString();
        }
        /// <summary>
        /// 获取选择语句内容
        /// </summary>
        /// <param name="cmd">选择语句类</param>
        /// <param name="realPageIndex">实际页索引</param>
        /// <param name="realPageCount">实际页数量</param>
        /// <param name="orderReverse">是否反转排序</param>
        /// <returns>选择语句内容</returns>
        internal static String InternalGetSelectCommand(SelectCommand cmd, Int32 realPageIndex, Int32 realPageCount, Boolean orderReverse)
        {
            SqlCommandBuilder sb = new SqlCommandBuilder(cmd.DatabaseType);

            sb.AppendSelectPrefix();

            if (realPageIndex == 1)//第一页
            {
                if (cmd.PageSize > 0)
                {
                    sb.AppendSelectTop(cmd.PageSize);
                }

                sb.AppendSelectDistinct(cmd.UseDistinct).AppendAllColumnNames(cmd.QueryFields);
                sb.AppendSelectFromAndJoins(cmd.TableName, cmd.IsFromSql, cmd.SqlJoins);

                sb.AppendWhere(cmd.SqlWhere);
                sb.AppendSelectGroupBys(cmd.GroupByColumns);
                sb.AppendHaving(cmd.SqlHaving);
                sb.AppendSelectOrderBys(cmd.SqlOrders, orderReverse);
            }
            else if (realPageIndex == realPageCount)//最后一页
            {
                sb.AppendSelectDistinct(cmd.UseDistinct).AppendAllColumnNames(cmd.QueryFields);

                SelectCommand innerCommand = new SelectCommand(cmd.Database, cmd.TableName);
                innerCommand.QueryFields    = cmd.QueryFields;
                innerCommand.PageSize       = cmd.RecordCount - cmd.PageSize * (realPageIndex - 1);
                innerCommand.SqlJoins       = cmd.SqlJoins;
                innerCommand.SqlWhere       = cmd.SqlWhere;
                innerCommand.GroupByColumns = cmd.GroupByColumns;
                innerCommand.SqlHaving      = cmd.SqlHaving;
                innerCommand.SqlOrders      = cmd.SqlOrders;

                sb.AppendSelectFrom(innerCommand.ToString("T", !orderReverse), true);
                sb.AppendSelectOrderBys(cmd.SqlOrders, orderReverse);
            }
            else if (realPageIndex < (realPageCount / 2 + realPageCount % 2))//前1/2部分页
            {
                sb.AppendSelectDistinct(cmd.UseDistinct).AppendAllColumnNames(cmd.QueryFields);

                SelectCommand innestCommand = new SelectCommand(cmd.Database, cmd.TableName);
                innestCommand.QueryFields    = cmd.QueryFields;
                innestCommand.PageSize       = cmd.PageSize * realPageIndex;
                innestCommand.SqlJoins       = cmd.SqlJoins;
                innestCommand.SqlWhere       = cmd.SqlWhere;
                innestCommand.GroupByColumns = cmd.GroupByColumns;
                innestCommand.SqlHaving      = cmd.SqlHaving;
                innestCommand.SqlOrders      = cmd.SqlOrders;

                SelectCommand innerCommand = new SelectCommand(cmd.Database, innestCommand, "T");
                innerCommand.QueryFields = cmd.QueryFields;
                innerCommand.PageSize    = cmd.PageSize;
                innerCommand.SqlOrders   = cmd.SqlOrders;

                sb.AppendSelectFrom(innerCommand.ToString("T", !orderReverse), true);
                sb.AppendSelectOrderBys(cmd.SqlOrders, orderReverse);
            }
            else//后1/2部分页
            {
                sb.AppendSelectTop(cmd.PageSize);
                sb.AppendSelectDistinct(cmd.UseDistinct).AppendAllColumnNames(cmd.QueryFields);

                SelectCommand innerCommand = new SelectCommand(cmd.Database, cmd.TableName);
                innerCommand.QueryFields    = cmd.QueryFields;
                innerCommand.PageSize       = cmd.RecordCount - cmd.PageSize * (realPageIndex - 1);
                innerCommand.SqlJoins       = cmd.SqlJoins;
                innerCommand.SqlWhere       = cmd.SqlWhere;
                innerCommand.GroupByColumns = cmd.GroupByColumns;
                innerCommand.SqlHaving      = cmd.SqlHaving;
                innerCommand.SqlOrders      = cmd.SqlOrders;

                sb.AppendSelectFrom(innerCommand.ToString("T", !orderReverse), true);
                sb.AppendSelectOrderBys(cmd.SqlOrders, orderReverse);
            }

            return(sb.ToString());
        }
        /// <summary>
        /// 获取选择语句内容
        /// </summary>
        /// <param name="cmd">选择语句类</param>
        /// <param name="realPageIndex">实际页索引</param>
        /// <param name="realPageCount">实际页数量</param>
        /// <param name="orderReverse">是否反转排序</param>
        /// <returns>选择语句内容</returns>
        internal static String InternalGetSelectCommand(SelectCommand cmd, Int32 realPageIndex, Int32 realPageCount, Boolean orderReverse)
        {
            SqlCommandBuilder sb = new SqlCommandBuilder(cmd.DatabaseType);
            sb.AppendSelectPrefix();

            if (realPageIndex == 1)//第一页
            {
                if (cmd.PageSize > 0)
                {
                    sb.AppendSelectTop(cmd.PageSize);
                }

                sb.AppendSelectDistinct(cmd.UseDistinct).AppendAllColumnNames(cmd.QueryFields);
                sb.AppendSelectFromAndJoins(cmd.TableName, cmd.IsFromSql, cmd.SqlJoins);

                sb.AppendWhere(cmd.SqlWhere);
                sb.AppendSelectGroupBys(cmd.GroupByColumns);
                sb.AppendHaving(cmd.SqlHaving);
                sb.AppendSelectOrderBys(cmd.SqlOrders, orderReverse);
            }
            else if (realPageIndex == realPageCount)//最后一页
            {
                sb.AppendSelectDistinct(cmd.UseDistinct).AppendAllColumnNames(cmd.QueryFields);

                SelectCommand innerCommand = new SelectCommand(cmd.Database, cmd.TableName);
                innerCommand.QueryFields = cmd.QueryFields;
                innerCommand.PageSize = cmd.RecordCount - cmd.PageSize * (realPageIndex - 1);
                innerCommand.SqlJoins = cmd.SqlJoins;
                innerCommand.SqlWhere = cmd.SqlWhere;
                innerCommand.GroupByColumns = cmd.GroupByColumns;
                innerCommand.SqlHaving = cmd.SqlHaving;
                innerCommand.SqlOrders = cmd.SqlOrders;

                sb.AppendSelectFrom(innerCommand.ToString("T", !orderReverse), true);
                sb.AppendSelectOrderBys(cmd.SqlOrders, orderReverse);
            }
            else if (realPageIndex < (realPageCount / 2 + realPageCount % 2))//前1/2部分页
            {
                sb.AppendSelectDistinct(cmd.UseDistinct).AppendAllColumnNames(cmd.QueryFields);

                SelectCommand innestCommand = new SelectCommand(cmd.Database, cmd.TableName);
                innestCommand.QueryFields = cmd.QueryFields;
                innestCommand.PageSize = cmd.PageSize * realPageIndex;
                innestCommand.SqlJoins = cmd.SqlJoins;
                innestCommand.SqlWhere = cmd.SqlWhere;
                innestCommand.GroupByColumns = cmd.GroupByColumns;
                innestCommand.SqlHaving = cmd.SqlHaving;
                innestCommand.SqlOrders = cmd.SqlOrders;

                SelectCommand innerCommand = new SelectCommand(cmd.Database, innestCommand, "T");
                innerCommand.QueryFields = cmd.QueryFields;
                innerCommand.PageSize = cmd.PageSize;
                innerCommand.SqlOrders = cmd.SqlOrders;

                sb.AppendSelectFrom(innerCommand.ToString("T", !orderReverse), true);
                sb.AppendSelectOrderBys(cmd.SqlOrders, orderReverse);
            }
            else//后1/2部分页
            {
                sb.AppendSelectTop(cmd.PageSize);
                sb.AppendSelectDistinct(cmd.UseDistinct).AppendAllColumnNames(cmd.QueryFields);

                SelectCommand innerCommand = new SelectCommand(cmd.Database, cmd.TableName);
                innerCommand.QueryFields = cmd.QueryFields;
                innerCommand.PageSize = cmd.RecordCount - cmd.PageSize * (realPageIndex - 1);
                innerCommand.SqlJoins = cmd.SqlJoins;
                innerCommand.SqlWhere = cmd.SqlWhere;
                innerCommand.GroupByColumns = cmd.GroupByColumns;
                innerCommand.SqlHaving = cmd.SqlHaving;
                innerCommand.SqlOrders = cmd.SqlOrders;

                sb.AppendSelectFrom(innerCommand.ToString("T", !orderReverse), true);
                sb.AppendSelectOrderBys(cmd.SqlOrders, orderReverse);
            }

            return sb.ToString();
        }
        /// <summary>
        /// 获取选择语句内容
        /// </summary>
        /// <param name="baseCommand">源选择语句</param>
        /// <param name="recordCount">记录数量</param>
        /// <param name="orderReverse">是否反转排序</param>
        /// <returns>选择语句内容</returns>
        internal static String InternalGetPagerCommand(SelectCommand baseCommand, Int32 recordCount, Boolean orderReverse)
        {
            SqlCommandBuilder sb = new SqlCommandBuilder(baseCommand.Database);
            sb.AppendSelectPrefix();

            if (baseCommand.PageSize > 0 && baseCommand.RecordStart > 0)//分页模式
            {
                Int32 realPageCount = (recordCount + baseCommand.PageSize - 1) / baseCommand.PageSize;
                Int32 realPageIndex = (baseCommand.RecordStart / baseCommand.PageSize) + 1;

                if (realPageIndex >= realPageCount)//最后一页
                {
                    sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.QueryFields);

                    SelectCommand innerCommand = new SelectCommand(baseCommand.Database, baseCommand.TableName);
                    innerCommand.QueryFields = baseCommand.QueryFields;
                    innerCommand.PageSize = recordCount - baseCommand.RecordStart;
                    innerCommand.SqlJoins = baseCommand.SqlJoins;
                    innerCommand.SqlWhere = baseCommand.SqlWhere;
                    innerCommand.GroupByColumns = baseCommand.GroupByColumns;
                    innerCommand.SqlHaving = baseCommand.SqlHaving;
                    innerCommand.SqlOrders = baseCommand.SqlOrders;

                    sb.AppendSelectFrom(innerCommand.GetCommandText("T", !orderReverse), true);
                    sb.AppendSelectOrderBys(baseCommand.SqlOrders, orderReverse);
                }
                else if (realPageIndex < (realPageCount / 2 + realPageCount % 2))//前1/2部分页
                {
                    /*
                        SELECT * FROM
                        (
                            SELECT TOP 10 * FROM
                            (
                                SELECT TOP 30 * 
                                FROM TABLE_NAME
                                ORDER BY ID ASC
                            ) AS T1
                            ORDER BY ID DESC
                        ) AS T2
                        ORDER BY ID ASC
                    */

                    sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.QueryFields);

                    SelectCommand innestCommand = new SelectCommand(baseCommand.Database, baseCommand.TableName);
                    innestCommand.QueryFields = baseCommand.QueryFields;
                    innestCommand.PageSize = baseCommand.RecordStart + baseCommand.PageSize;
                    innestCommand.SqlJoins = baseCommand.SqlJoins;
                    innestCommand.SqlWhere = baseCommand.SqlWhere;
                    innestCommand.GroupByColumns = baseCommand.GroupByColumns;
                    innestCommand.SqlHaving = baseCommand.SqlHaving;
                    innestCommand.SqlOrders = baseCommand.SqlOrders;

                    SelectCommand innerCommand = new SelectCommand(baseCommand.Database, innestCommand, "T1");
                    innerCommand.QueryFields = baseCommand.QueryFields;
                    innerCommand.PageSize = baseCommand.PageSize;
                    innerCommand.SqlOrders = baseCommand.SqlOrders;

                    sb.AppendSelectFrom(innerCommand.GetCommandText("T2", !orderReverse), true);
                    sb.AppendSelectOrderBys(baseCommand.SqlOrders, orderReverse);
                }
                else//后1/2部分页
                {
                    sb.AppendSelectTop(baseCommand.PageSize);
                    sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.QueryFields);

                    SelectCommand innerCommand = new SelectCommand(baseCommand.Database, baseCommand.TableName);
                    innerCommand.QueryFields = baseCommand.QueryFields;
                    innerCommand.PageSize = recordCount - baseCommand.RecordStart;
                    innerCommand.SqlJoins = baseCommand.SqlJoins;
                    innerCommand.SqlWhere = baseCommand.SqlWhere;
                    innerCommand.GroupByColumns = baseCommand.GroupByColumns;
                    innerCommand.SqlHaving = baseCommand.SqlHaving;
                    innerCommand.SqlOrders = baseCommand.SqlOrders;

                    sb.AppendSelectFrom(innerCommand.GetCommandText("T", !orderReverse), true);
                    sb.AppendSelectOrderBys(baseCommand.SqlOrders, orderReverse);
                }
            }
            else//正常模式
            {
                if (baseCommand.PageSize > 0)
                {
                    sb.AppendSelectTop(baseCommand.PageSize);
                }

                sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.QueryFields);
                sb.AppendSelectFromAndJoins(baseCommand.TableName, baseCommand.IsFromSql, baseCommand.SqlJoins);

                sb.AppendWhere(baseCommand.SqlWhere);
                sb.AppendSelectGroupBys(baseCommand.GroupByColumns);
                sb.AppendHaving(baseCommand.SqlHaving);
                sb.AppendSelectOrderBys(baseCommand.SqlOrders, orderReverse);
            }

            return sb.ToString();
        }
        /// <summary>
        /// 获取选择语句内容
        /// </summary>
        /// <param name="baseCommand">源选择语句</param>
        /// <param name="recordCount">记录数量</param>
        /// <param name="orderReverse">是否反转排序</param>
        /// <returns>选择语句内容</returns>
        internal static String InternalGetPagerCommand(SelectCommand baseCommand, Int32 recordCount, Boolean orderReverse)
        {
            SqlCommandBuilder sb = new SqlCommandBuilder(baseCommand.Database);

            sb.AppendSelectPrefix();

            if (baseCommand.PageSize > 0 && baseCommand.RecordStart > 0)//分页模式
            {
                Int32 realPageCount = (recordCount + baseCommand.PageSize - 1) / baseCommand.PageSize;
                Int32 realPageIndex = (baseCommand.RecordStart / baseCommand.PageSize) + 1;

                if (realPageIndex >= realPageCount)//最后一页
                {
                    sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.UseDistinct, baseCommand.InternalGetQueryFieldList());

                    SelectCommand innerCommand = baseCommand.Database.InternalCreateSelectCommand(baseCommand, baseCommand.TableName);
                    innerCommand.PageSize = recordCount - baseCommand.RecordStart;
                    innerCommand.InternalSetQueryFieldList(baseCommand);
                    innerCommand.InternalSetJoinList(baseCommand);
                    innerCommand.InternalSetWhereCondition(baseCommand);
                    innerCommand.InternalSetGroupByFieldList(baseCommand);
                    innerCommand.InternalSetHavingCondition(baseCommand);
                    innerCommand.InternalSetOrderList(baseCommand);

                    sb.AppendSelectFrom(innerCommand.GetCommandText("T", !orderReverse), true);
                    sb.AppendSelectOrderBys(baseCommand.InternalGetOrderList(), orderReverse);
                }
                else if (realPageIndex < (realPageCount / 2 + realPageCount % 2))//前1/2部分页
                {
                    /*
                     *  SELECT * FROM
                     *  (
                     *      SELECT TOP 10 * FROM
                     *      (
                     *          SELECT TOP 30 *
                     *          FROM TABLE_NAME
                     *          ORDER BY ID ASC
                     *      ) AS T1
                     *      ORDER BY ID DESC
                     *  ) AS T2
                     *  ORDER BY ID ASC
                     */

                    sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.UseDistinct, baseCommand.InternalGetQueryFieldList());

                    SelectCommand innestCommand = baseCommand.Database.InternalCreateSelectCommand(baseCommand, baseCommand.TableName);
                    innestCommand.PageSize = baseCommand.RecordStart + baseCommand.PageSize;
                    innestCommand.InternalSetQueryFieldList(baseCommand);
                    innestCommand.InternalSetJoinList(baseCommand);
                    innestCommand.InternalSetWhereCondition(baseCommand);
                    innestCommand.InternalSetGroupByFieldList(baseCommand);
                    innestCommand.InternalSetHavingCondition(baseCommand);
                    innestCommand.InternalSetOrderList(baseCommand);

                    SelectCommand innerCommand = baseCommand.Database.InternalCreateSelectCommand(baseCommand, innestCommand, "T1");
                    innerCommand.PageSize = baseCommand.PageSize;
                    innerCommand.InternalSetQueryFieldList(baseCommand);
                    innerCommand.InternalSetOrderList(baseCommand);

                    sb.AppendSelectFrom(innerCommand.GetCommandText("T2", !orderReverse), true);
                    sb.AppendSelectOrderBys(baseCommand.InternalGetOrderList(), orderReverse);
                }
                else//后1/2部分页
                {
                    sb.AppendSelectTop(baseCommand.PageSize);
                    sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.UseDistinct, baseCommand.InternalGetQueryFieldList());

                    SelectCommand innerCommand = baseCommand.Database.InternalCreateSelectCommand(baseCommand, baseCommand.TableName);
                    innerCommand.PageSize = recordCount - baseCommand.RecordStart;
                    innerCommand.InternalSetQueryFieldList(baseCommand);
                    innerCommand.InternalSetJoinList(baseCommand);
                    innerCommand.InternalSetWhereCondition(baseCommand);
                    innerCommand.InternalSetGroupByFieldList(baseCommand);
                    innerCommand.InternalSetHavingCondition(baseCommand);
                    innerCommand.InternalSetOrderList(baseCommand);

                    sb.AppendSelectFrom(innerCommand.GetCommandText("T", !orderReverse), true);
                    sb.AppendSelectOrderBys(baseCommand.InternalGetOrderList(), orderReverse);
                }
            }
            else//正常模式
            {
                if (baseCommand.PageSize > 0)
                {
                    sb.AppendSelectTop(baseCommand.PageSize);
                }

                sb.AppendSelectDistinct(baseCommand.UseDistinct).AppendAllColumnNames(baseCommand.UseDistinct, baseCommand.InternalGetQueryFieldList());
                sb.AppendSelectFromAndJoins(baseCommand.TableName, baseCommand.IsFromSql, baseCommand.InternalGetJoinList());

                sb.AppendWhere(baseCommand.WhereCondition);
                sb.AppendSelectGroupBys(baseCommand.InternalGetGroupByFieldList());
                sb.AppendHaving(baseCommand.InternalGetHavingCondition());
                sb.AppendSelectOrderBys(baseCommand.InternalGetOrderList(), orderReverse);
            }

            return(sb.ToString());
        }