Castle查询问题

   public abstract class DataBase<T> : ActiveRecordBase<T>
        where T : class
    ...{
        private int id;

        /**//// <summary>
        /// 主键
        /// </summary>
        [PrimaryKey(PrimaryKeyType.Identity, "Id")]
        public int Id
        ...{
            get ...{ return id; }
            set ...{ id = value; }
        }

        /**//// <summary>
        /// 查询所有对象
        /// </summary>
        /// <returns>对象集合</returns>
        public static IList<T> GetAll()
        ...{
            return DataBase<T>.FindAll();
        }

        /**//// <summary>
        /// 根据主键查询对象
        /// </summary>
        /// <param name="Id">主键</param>
        /// <returns>对象</returns>
        public static T GetInfoById(int Id)
        ...{
            T t = null;

            try
            ...{
                t = DataBase<T>.FindByPrimaryKey(Id);
            }
            catch
            ...{ }

            return t;
        }

        /**//// <summary>
        /// 根据属性查询对象集合
        /// </summary>
        /// <param name="parameter">属性</param>
        /// <returns>对象集合</returns>
        public static IList<T> GetListByProperty(QueryParameter parameter)
        ...{
            return DataBase<T>.FindAllByProperty(parameter.Name, parameter.Value);
        }

        /**//// <summary>
        /// 根据属性查询对象
        /// </summary>
        /// <param name="parameters">属性集合</param>
        /// <returns>对象集合</returns>
        public static IList<T> GetListByProperty(IList<QueryParameter> parameters)
        ...{
            IList<T> result = new List<T>();

            SimpleQuery simpleQuery = new SimpleQuery(typeof(T), GetHql(parameters), GetHqlQueryParameters(parameters));

            return (IList<T>)ExecuteQuery(simpleQuery);
        }

        /**//// <summary>
        /// 根据属性查询对象
        /// </summary>
        /// <param name="parameters">属性集合</param>
        /// <param name="orders">排序集合</param>
        /// <returns></returns>
        public static IList<T> GetListByProperty(IList<QueryParameter> parameters, IList<QueryOrder> orders)
        ...{
            IList<T> result = new List<T>();

            SimpleQuery simpleQuery = new SimpleQuery(typeof(T), GetHql(parameters, orders), GetHqlQueryParameters(parameters));

            return (IList<T>)ExecuteQuery(simpleQuery);
        }

        /**//// <summary>
        /// 根据属性查询对象(分页)
        /// </summary>
        /// <param name="parameters">属性集合</param>
        /// <param name="pageSize">页面大小</param>
        /// <param name="currentPage">当前页</param>
        /// <param name="rowCount">返回总记录数</param>
        /// <param name="resultPage">返回当前页</param>
        /// <returns>对象集合</returns>
        public static IList<T> GetListByProperty(IList<QueryParameter> parameters, IList<QueryOrder> orders, int pageSize, int currentPage, out int rowCount, out int resultPage)
        ...{
            string baseQuery = GetHql(parameters);
            object[] queryParameters = GetHqlQueryParameters(parameters);

            rowCount = 0;
            resultPage = 0;

            return GetListByProperty(baseQuery, queryParameters, orders, pageSize, currentPage, out rowCount, out resultPage);
        }

        /**//// <summary>
        /// 根据参数创建HQL
        /// </summary>
        /// <param name="parameters">参数集合</param>
        /// <returns>HQL</returns>
        private static string GetHql(IList<QueryParameter> parameters)
        ...{
            string query = "from " + typeof(T).ToString() + " o";

            if (parameters.Count > 0)
            ...{
                query += " where";

                for (int i = 0; i < parameters.Count; i++)
                ...{
                    if (i > 0)
                    ...{
                        query += " and";
                    }

                    query += " o." + parameters[i].Name;

                    switch (parameters[i].Expression)
                    ...{
                        case OperateExpression.Equal:
                            if (parameters[i].Value == null)
                            ...{
                                query += " is null";
                            }
                            else
                            ...{
                                query += "=";
                            }
                            break;
                        case OperateExpression.NotEqual:
                            if (parameters[i].Value == null)
                            ...{
                                query += " is not null";
                            }
                            else
                            ...{
                                query += "<>";
                            }
                            break;
                        case OperateExpression.Greater:
                            query += ">";
                            break;
                        case OperateExpression.GreaterOrEqual:
                            query += ">=";
                            break;
                        case OperateExpression.Less:
                            query += "<";
                            break;
                        case OperateExpression.LessOrEqual:
                            query += "<=";
                            break;
                        case OperateExpression.Like:
                            query += " like ";
                            break;
                        default:
                            query += "=";
                            break;
                    }

                    if (parameters[i].Value != null)
                    ...{
                        query += "?";
                    }
                }
            }

            return query;
        }

        /**//// <summary>
        /// 根据参数创建HQL
        /// </summary>
        /// <param name="parameters">参数集合</param>
        /// <param name="orders">排序方式</param>
        /// <returns>HQL</returns>
        private static string GetHql(IList<QueryParameter> parameters, IList<QueryOrder> orders)
        ...{
            string query = GetHql(parameters);

            return query += GetOrder(orders);
        }

        /**//// <summary>
        /// 根据排序对象集合创建排序HQL
        /// </summary>
        /// <param name="orders">排序对象集合</param>
        /// <returns>HQL</returns>
        private static string GetOrder(IList<QueryOrder> orders)
        ...{
            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < orders.Count; i++)
            ...{
                if (i == 0)
                ...{
                    sb.Append(" order by ");
                }
                else
                ...{
                    sb.Append(",");
                }

                sb.Append("o." + orders[i].OrderName);

                if (orders[i].IsDesc)
                ...{
                    sb.Append(" desc");
                }
            }

            return sb.ToString();
        }

        /**//// <summary>
        /// 将自定义参数集合转换为HQL参数集合
        /// </summary>
        /// <param name="parameters">自定义参数集合</param>
        /// <returns>HQL参数集合</returns>
        private static object[] GetHqlQueryParameters(IList<QueryParameter> parameters)
        ...{
            IList<object> objectList = new List<object>();

            for (int i = 0; i < parameters.Count; i++)
            ...{
                if (parameters[i].Expression == OperateExpression.Like)
                ...{
                    objectList.Add("%" + parameters[i].Value.ToString() + "%");
                }
                else if (parameters[i].Value == null)
                ...{
                    // Todo: nothing
                }
                else
                ...{
                    objectList.Add(parameters[i].Value);
                }
            }

            object[] objects = new object[objectList.Count];
            objectList.CopyTo(objects, 0);

            return objects;
        }

        /**//// <summary>
        /// HQL查询分页
        /// </summary>
        /// <param name="baseQuery">HQL</param>
        /// <param name="queryParameters">参数对象集合</param>
        /// <param name="orders">排序对象集合</param>
        /// <param name="pageSize">页面大小</param>
        /// <param name="currentPage">当前页</param>
        /// <param name="rowCount">记录总数</param>
        /// <param name="resultPage">查询结果页</param>
        /// <returns>对象集合</returns>
        internal static IList<T> GetListByProperty(string baseQuery, object[] queryParameters, IList<QueryOrder> orders, int pageSize, int currentPage, out int rowCount, out int resultPage)
        ...{
            string query = string.Empty; ;

            if (baseQuery.StartsWith("select"))
            ...{
                query = baseQuery.Replace(baseQuery.Substring(0, baseQuery.IndexOf("from")), "select count(*) ");
            }
            else
            ...{
                query = "select count(*) " + baseQuery;
            }

            ScalarQuery scalarQuery = new ScalarQuery(typeof(T), query, queryParameters);
            object o = ExecuteQuery(scalarQuery);
            rowCount = int.Parse(o.ToString());
            resultPage = currentPage;
            int pageCount = (rowCount - 1) / pageSize + 1;
            if (resultPage < 0)
            ...{
                resultPage = 0;
            }
            if (resultPage >= pageCount)
            ...{
                resultPage = pageCount - 1;
            }
            int startRow = resultPage * pageSize;
            if (startRow >= rowCount)
            ...{
                startRow = rowCount - 1;
            }

            IList<T> result = new List<T>();

            SimpleQuery simpleQuery = new SimpleQuery(typeof(T), baseQuery + GetOrder(orders), queryParameters);
            simpleQuery.SetQueryRange(startRow, pageSize);

            return (IList<T>)ExecuteQuery(simpleQuery);
        }

        internal static IList FillToArray(IDataReader rs)
        ...{
            IList result = new ArrayList();

            while (rs.Read())
            ...{
                int fieldCount = rs.FieldCount;
                object[] values = new Object[fieldCount];
                for (int i = 0; i < fieldCount; i++)
                ...{
                    values[i] = rs.GetValue(i);
                }
                result.Add(values);
            }

            return result;
        }
    }