Пример #1
0
 public FutureQueryOf(DetachedCriteria detachedCriteria, int firstResult, int maxResults)
     : this(detachedCriteria
            .SetFirstResult(firstResult)
            .SetMaxResults(maxResults),
            FutureQueryOptions.WithTotalCount)
 {
 }
Пример #2
0
        public IPagedList <Album> GetAlbums(ILoadOptions options)
        {
            IPagedList <Album> result = new PagedList <Album>();

            if (options == null)
            {
                return(result);
            }

            if (options.MaxResults <= 0)
            {
                return(result);
            }

            ISession session = SessionFactory.GetSession();

            try
            {
                DetachedCriteria countCriteria = GetAlbumsImpl(options);
                DetachedCriteria listCriteria  = GetAlbumsImpl(options);

                countCriteria.SetProjection(Projections.RowCount());
                countCriteria.ClearOrders();

                listCriteria.
                SetFirstResult(options.FirstResult).
                SetMaxResults(options.MaxResults);

                IMultiCriteria multiCriteria = session.CreateMultiCriteria();
                multiCriteria.Add(countCriteria);
                multiCriteria.Add(listCriteria);


                IList queryResult = multiCriteria.List();

                result.TotalItems = (int)((IList)queryResult[0])[0];

                IList recordsList = (IList)queryResult[1];

                EntityConverter entityConverter = new EntityConverter();

                foreach (var e in recordsList)
                {
                    AlbumEntity dataEntity     = e as AlbumEntity;
                    Album       businessEntity = entityConverter.FromDataEntity(dataEntity, AlbumConvertOptions.Small);
                    result.Add(businessEntity);
                }
            }
            catch (Exception ex)
            {
                Logger.Write(ex);
            }
            finally
            {
                session.Close();
            }

            return(result);
        }
Пример #3
0
        public IEnumerable <T> GetByCrit(DetachedCriteria query, int pageIndex, int pageSize, out int count, string sortFieldName, SortDirection sortDirection)
        {
            if (pageSize > 0)
            {
                query.SetFirstResult(pageIndex * pageSize)
                .SetMaxResults(pageSize)//Rizwan:24-Jun-2011  Commented this line ignore as next line contains same thing as well
                .SetMaxResults(pageSize);
            }
            query.AddOrder(new Order(sortFieldName, sortDirection == SortDirection.Ascending ? true : false));
            IList <T> result = query.GetExecutableCriteria(this._session).List <T>();
            //count = result.Count;//Rizwan:24-JUN-2011
            var rowCount = query.SetFirstResult(0).GetExecutableCriteria(this._session).SetProjection(Projections.RowCount()).FutureValue <Int32>();

            count = rowCount.Value;
            return(result);
            //}
        }
Пример #4
0
 private static void SetPagination(DetachedCriteria criteria, int pageSize, int pageNumber)
 {
     if (criteria == null)
     {
         throw new ArgumentNullException("criteria");
     }
     criteria.SetFirstResult(pageSize * (pageNumber < 1 ? 0 : pageNumber - 1)).SetMaxResults(pageSize);
 }
Пример #5
0
        private static void ResetPagination(DetachedCriteria criteria)
        {
            if (criteria == null)
            {
                throw new ArgumentNullException("criteria");
            }

            criteria.SetFirstResult(default(int)).SetMaxResults(RowSelection.NoValue);
        }
Пример #6
0
 protected DetachedCriteria Limit(DetachedCriteria criteria, int start, int max)
 {
     if (start >= 1)
     {
         criteria.SetFirstResult(start);
     }
     if (max >= 0)
     {
         criteria.SetMaxResults(max);
     }
     return(criteria);
 }
Пример #7
0
        /// <summary>
        /// Current Criteria의 Paging 설정을 수행한다.
        /// </summary>
        /// <param name="firstResult">결과 Set의 첫번째 인덱스</param>
        /// <param name="maxResults">결과 Set의 최대 레코드 수 (0 이하이면 설정하지 않는다.)</param>
        /// <returns>Current instance of CriteriaBatch</returns>
        public CriteriaBatch Paging(int firstResult, int maxResults)
        {
            if (firstResult >= 0)
            {
                _currentCriteria.SetFirstResult(firstResult);
            }

            if (maxResults > 0)
            {
                _currentCriteria.SetMaxResults(maxResults);
            }

            return(this);
        }
Пример #8
0
        //public IEnumerable<T> Get(IQuery query, int baseIndex, short pageSize, out int count, string sortFieldName, SortDirection sortDirection)
        //{
        //    //if pageSize>0 then do paging, otherwise no paging and all records will be displayed
        //    if (pageSize > 0)
        //        query.SetFirstResult(baseIndex)
        //            .SetMaxResults(pageSize)//Rizwan:24-Jun-2011  Commented this line ignore as next line contains same thing as well
        //            .SetMaxResults(pageSize);
        //   // query.AddOrder(new Order(sortFieldName, sortDirection == SortDirection.Ascending ? true : false));
        //    IList<T> result = query.List<T>();
        //    //count = result.Count;//Rizwan:24-JUN-2011
        //    var rowCount = query.SetFirstResult(0).List().Count;
        //    count = rowCount;
        //    return result;
        //    //}
        //}
        public IEnumerable <T> Get(DetachedCriteria query, int pageIndex, int pageSize, out int count, string sortFieldName, SortDirection sortDirection)
        {
            /*
             * if ((!string.IsNullOrEmpty(sortFieldName))&& sortFieldName != "LeaveTypeId")
             * {
             *  query.SetFirstResult(pageIndex * pageSize)
             *      .SetMaxResults(pageSize)//Rizwan:24-Jun-2011  Commented this line ignore as next line contains same thing as well
             *      .SetMaxResults(pageSize)
             *      .AddOrder(new Order(sortFieldName, sortDirection == SortDirection.Ascending));
             *
             *  IList<T> result = query.GetExecutableCriteria(this._session).List<T>();
             *  //count = result.Count;//Rizwan:24-JUN-2011
             *  var rowCount = query.SetFirstResult(0).GetExecutableCriteria(this._session).SetProjection(Projections.RowCount()).FutureValue<Int32>();
             *  count = rowCount.Value;
             *   return result;
             *
             * }
             * else
             * {
             */

            //if pageSize>0 then do paging, otherwise no paging and all records will be displayed
            if (pageSize > 0)
            {
                query.SetFirstResult(pageIndex * pageSize)
                .SetMaxResults(pageSize)//Rizwan:24-Jun-2011  Commented this line ignore as next line contains same thing as well
                .SetMaxResults(pageSize);
            }
            //query.AddOrder(new Order(sortFieldName, sortDirection == SortDirection.Ascending ? true : false));
            IList <T> result = query.GetExecutableCriteria(this._session).List <T>();
            //count = result.Count;//Rizwan:24-JUN-2011
            var rowCount = query.SetFirstResult(0).GetExecutableCriteria(this._session).SetProjection(Projections.RowCount()).FutureValue <Int32>();

            count = rowCount.Value;
            return(result);
            //}
        }
 /// <summary>
 /// Adds paging to the DetachedCriteria based on the given parameters.
 /// </summary>
 /// <param name="criteria"></param>
 /// <param name="pageSize"></param>
 /// <param name="pageNumber"></param>
 /// <returns></returns>
 public static DetachedCriteria ApplyPaging(this DetachedCriteria criteria, int?pageSize, int?pageNumber)
 {
     if (pageSize.HasValue)
     {
         criteria.SetMaxResults(pageSize.Value);
     }
     if (pageNumber.HasValue)
     {
         if (!pageSize.HasValue)
         {
             throw new ArgumentException("Unable to determine the object to return for the given page number when the pagesize is unknown.");
         }
         criteria.SetFirstResult(pageSize.Value * (pageNumber.Value - 1));
     }
     return(criteria);
 }
        private IList <RegistrationInformation> AcceptPaginator(DetachedCriteria criteria, ISession session)
        {
            var countSubquery = CriteriaTransformer.TransformToRowCount(criteria);

            _lastRowsCount = countSubquery.GetExecutableCriteria(session).UniqueResult <int>();

            if (CurrentPage > 0)
            {
                criteria.SetFirstResult(CurrentPage * PageSize);
            }

            criteria.SetMaxResults(PageSize);

            ApplySort(criteria);

            return(criteria.GetExecutableCriteria(session).ToList <RegistrationInformation>().ToList());
        }
        private IList <DocumentLog> AcceptPaginator(ISession session, DetachedCriteria criteria, bool forExport = false)
        {
            var countQuery = CriteriaTransformer.TransformToRowCount(criteria);

            if (OnlyNoParsed && !forExport)
            {
                if (CurrentPage > 0)
                {
                    criteria.SetFirstResult(CurrentPage * PageSize);
                }

                criteria.SetMaxResults(PageSize);
            }

            RowsCount = countQuery.GetExecutableCriteria(session).UniqueResult <int>();
            return(criteria.GetExecutableCriteria(session).ToList <DocumentLog>());
        }
Пример #12
0
 /// <summary>
 /// selects a certain amount of entitys
 /// matching a given criteria.
 /// Should be used if a lot of data is expected!!
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="criteria"></param>
 /// <param name="firstResult">the index of the first result</param>
 /// <param name="numberOfResults">how many results do you want to have</param>
 /// <param name="orders">the order in which it should be selected</param>
 /// <returns></returns>
 public IEnumerable <T> SelectCertainNumberWhere <T>(DetachedCriteria criteria, int firstResult, int numberOfResults, params Order[] orders) where T : IEntity
 {
     try
     {
         criteria.SetFirstResult(firstResult).SetMaxResults(numberOfResults);
         return(SelectManyWhere <T>(criteria, orders));
     }
     catch (DatabaseException dex)
     {
         this.setError();
         throw (dex);
     }
     catch (Exception ex)
     {
         this.setError();
         throw (new DatabaseException(ex, "Different Error in selecting"));
     }
 }
Пример #13
0
 /// <summary>
 /// Retunrs the First result matching the given
 /// criteria or a default entity if there is no result
 /// thorws an exception if an error occurs.
 /// Should be used if a lot of data is expected!!
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="criteria"></param>
 /// <returns></returns>
 public T SelectFirstOfMany <T>(DetachedCriteria criteria) where T : IEntity
 {
     try
     {
         var results = criteria.SetFirstResult(0).SetMaxResults(1)
                       .GetExecutableCriteria(session).List <T>();
         return((results.Count > 0) ? results[0] : default(T));
     }
     catch (DatabaseException dex)
     {
         this.setError();
         throw (dex);
     }
     catch (Exception ex)
     {
         this.setError();
         throw (new DatabaseException(ex, "Could not select first entity!"));
     }
 }
Пример #14
0
        /// <summary>
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="type"></param>
        /// <param name="total"></param>
        /// <returns></returns>
        public IList <News> GetNews(int pageIndex, int pageSize, NewsType type, out int total)
        {
            if (pageSize <= 0)
            {
                throw new ArgumentOutOfRangeException("pageSize", Resources.PageSize_should_greater_than_zero);
            }
            if (pageIndex < 0)
            {
                throw new ArgumentOutOfRangeException("pageIndex", Resources.PageIndex_should_greater_than_zero_);
            }


            total = CountMessage(type);

            DetachedCriteria cri = CreateDetachedCriteria()
                                   .Add(Restrictions.Eq(TypeProperty, type))
                                   .AddOrder(Order.Desc(CreateTimeProperty));

            cri.SetFirstResult(pageIndex * pageSize).SetMaxResults(pageSize);
            return(cri.GetExecutableCriteria(CurrentSession).List <News>());
        }
Пример #15
0
        public IList <User> Search(UserSearch userSearch, int pageIndex, int pageSize, out int total,
                                   params SortTarget[] sortTargets)
        {
            DetachedCriteria result = QuickSearch(userSearch);

            total = result
                    .SetProjection(Projections.RowCount())
                    .GetExecutableCriteria(CurrentSession).UniqueResult <int>();
            result = QuickSearch(userSearch);
            if (sortTargets != null && sortTargets.Length != 0)
            {
                foreach (SortTarget a in sortTargets)
                {
                    result.AddOrder(a.Tag == SortTag.Asc
                        ? Order.Asc(Projections.Property(a.Property))
                        : Order.Desc(Projections.Property(a.Property)));
                }
            }
            return
                (result.SetFirstResult(pageIndex * pageSize)
                 .SetMaxResults(pageSize)
                 .GetExecutableCriteria(CurrentSession)
                 .List <User>());
        }
 public NHibernateDynamicQueryGenerator <EntityType> SetFirstResult(int firstResult)
 {
     query.SetFirstResult(firstResult);
     return(this);
 }
 public ICriteria SetFirstResult(int firstResult)
 {
     return(detachedCriteria.SetFirstResult(firstResult).Adapt(session));
 }
Пример #18
0
 public CriteriaBatch Paging(int firstResult, int maxResults)
 {
     currentCriteria.SetFirstResult(firstResult);
     currentCriteria.SetMaxResults(maxResults);
     return(this);
 }
Пример #19
0
        /// <summary>
        ///     Builds a <see cref="DetachedCriteria" /> from the given <see cref="IMorphableFlowQuery" /> query.
        /// </summary>
        /// <param name="query">
        ///     The query from which to build a <see cref="ICriteria" />.
        /// </param>
        /// <typeparam name="TSource">
        ///     The <see cref="System.Type" /> of the underlying entity for the given query.
        /// </typeparam>
        /// <returns>
        ///     The built <see cref="DetachedCriteria" />.
        /// </returns>
        public virtual DetachedCriteria Build <TSource>(IMorphableFlowQuery query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            DetachedCriteria criteria = DetachedCriteria.For <TSource>(query.Alias);

            foreach (Join join in query.Joins)
            {
                criteria.CreateAlias(join.Property, join.Alias, join.JoinType, join.WithClause);
            }

            foreach (ICriterion criterion in query.Criterions)
            {
                criteria.Add(criterion);
            }

            foreach (Lock queryLock in query.Locks)
            {
                if (queryLock.Alias == null)
                {
                    criteria.SetLockMode(queryLock.LockMode);
                }
                else
                {
                    criteria.SetLockMode(queryLock.Alias, queryLock.LockMode);
                }
            }

            bool skips = query.ResultsToSkip.HasValue && query.ResultsToSkip.Value > 0;

            if (skips)
            {
                criteria.SetFirstResult(query.ResultsToSkip.Value);
            }

            bool takes = query.ResultsToTake.HasValue && query.ResultsToTake.Value > 0;

            if (takes)
            {
                criteria.SetMaxResults(query.ResultsToTake.Value);
            }

            if (query.IsCacheable)
            {
                criteria.SetCacheable(true);

                if (query.CacheMode.HasValue)
                {
                    criteria.SetCacheMode(query.CacheMode.Value);
                }

                if (!string.IsNullOrEmpty(query.CacheRegion))
                {
                    criteria.SetCacheRegion(query.CacheRegion);
                }
            }

            criteria
            .SetProjection
            (
                GetProjection(query)
            );

            if (query.ResultTransformer != null)
            {
                criteria.SetResultTransformer(query.ResultTransformer);
            }

            if (query.Orders.Count > 0 && (skips || takes))
            {
                foreach (OrderByStatement statement in query.Orders)
                {
                    if (statement.IsBasedOnSource)
                    {
                        criteria.AddOrder(statement.Order);
                    }
                }
            }

            return(criteria);
        }