/// <summary> /// Use this API it you did an aliastobean transform to type TTransform /// </summary> /// <typeparam name="TTransform"></typeparam> /// <param name="queryable"></param> /// <param name="startIndex"></param> /// <param name="maxRows">A value of Zero means we're not paging</param> /// <param name="totalCount"></param> /// <returns></returns> public RetrievedData <TTransform> RetrieveUsingPaging <TTransform>(IQueryOver <T, T> queryable, int startIndex, int maxRows, bool hasOrderBy = false) where TTransform : class //, IEntity<idT> { IEnumerable <TTransform> result; int totalCount = 0; IFutureValue <int> futureCount = null; if (maxRows > 0) { futureCount = queryable.Clone().Select(Projections.RowCount()).FutureValue <int>(); result = queryable.Skip(startIndex * maxRows).Take(maxRows).Future <TTransform>(); } else //get all { result = queryable.Future <TTransform>(); } var toReturn = result.ToList(); if (futureCount != null) { totalCount = futureCount.Value; } else { totalCount = toReturn.Count; } result = null; futureCount = null; return(new RetrievedData <TTransform> { DataBatch = toReturn, TotalCount = totalCount }); }
public static IQueryOver <T> Paginado <T>( this IQueryOver <T, T> query, int page, int itemsPerPage) { return(query .Skip(page.PaginateSkip(itemsPerPage)) .Take(itemsPerPage)); }
public static IList <T> GetQueryOver <T>(IQueryOver <T, T> query, List <SortOrder <T> > expressionOrder, Pagination pagination) { if (expressionOrder != null) { for (int i = 0; i < expressionOrder.Count; i++) { var model = expressionOrder[i]; IQueryOverOrderBuilder <T, T> sort; if (i > 0) { sort = query.ThenBy(model.value); } else { sort = query.OrderBy(model.value); } if (model.searchType == EnumBase.OrderType.Asc) { query = sort.Asc; } else { query = sort.Desc; } } } if (pagination != null) { query.Skip((pagination.pageIndex - 1) * pagination.pageSize); query.Take(pagination.pageSize); } var list = query.List <T>(); return(list); }
/// <summary> /// Versuch über ein Detached Criteria die Where-Klauseln zu verarbeiten, damit es mit dem Order nicht zu /// komplikationen kommt. /// </summary> protected virtual IPage <T> Find(IPageable pageable, Action <IQueryOver <T, T> > criteriaBuilder, Action <IQueryOver <T, T> > ordersBuilder = null) { Require.NotNull(pageable, "pageable"); Require.NotNull(criteriaBuilder, "criteriaBuilder"); HibernateDelegate <IPage <T> > finder = delegate(ISession session) { IQueryOver <T, T> query = session.QueryOver <T>(); criteriaBuilder(query); if (ordersBuilder != null) { ordersBuilder(query); } IQueryOver <T, T> countQuery = session.QueryOver <T>(); criteriaBuilder(countQuery); query.Skip(pageable.FirstItem); query.Take(pageable.PageSize); long futureTotalCount = countQuery.RowCountInt64(); IEnumerable <T> futureElements = query.Future <T>(); Page <T> page = new Page <T>(futureElements.ToList(), pageable, futureTotalCount); return(page); }; return(HibernateTemplate.Execute(finder)); }
public static PagedResultSet <T> ToPagedSet <T>(this IQueryOver <T, T> query, ListOptions listOptions) { var count = query.ToRowCountQuery().FutureValue <int>(); var results = query.Skip(listOptions.PageSize * listOptions.Page).Take(listOptions.PageSize).Future(); return(new PagedResultSet <T>(results, count.Value)); }
public override Response Handle(PagedSearchRequest <TDto> request) { var response = CreateTypedResponse(); var keyword = request.Keyword + "%"; IQueryOver <TEntity> query = null; var entityQuery = Session.QueryOver <TEntity>() .Where(WhereExpress(keyword)); var organizationExpression = GetOrganization(); if (organizationExpression != null) { query = entityQuery.JoinQueryOver(organizationExpression) .Where(o => o.Key == UserContext.OrganizationKey); } else { query = entityQuery; } query = query.Skip(request.Page * request.PageSize) .Take(request.PageSize); var result = query.Future <TEntity>() ?? Enumerable.Empty <TEntity> (); response.TotalCount = query.ToRowCountQuery().FutureValue <int>().Value; response.Results = Mapper.Map <IEnumerable <TEntity>, IEnumerable <TDto> > (result.ToList()); return(response); }
private static bool ApplySkipOrTakeInDbIfPossible(QueryDescription query, ref IQueryOver <AggregateNodeStatus, AggregateNodeStatus> filteredAggQuery) { bool modified = false; if (CanApplySortOrderInDb(query) != ApplySortOrderInDb.CannotApplyAll) { foreach (var filter in query.ResultFilters) { switch (filter.ResultFilterType) { case ResultFilterType.Skip: filteredAggQuery = (IQueryOver <AggregateNodeStatus, AggregateNodeStatus>) filteredAggQuery.Skip(filter.SkipCount).Take(9999); modified = true; break; case ResultFilterType.Take: filteredAggQuery = (IQueryOver <AggregateNodeStatus, AggregateNodeStatus>) filteredAggQuery.Take(filter.TakeCount); modified = true; break; } } } return(modified); }
public IList <Enrollee> GetallenrolleeRange(out int totalRecord, int start, int lenght) { IQueryOver <Enrollee, Enrollee> query = _session.QueryOver <Enrollee>().Where(x => x.IsDeleted == false && x.Isexpundged == false); totalRecord = query.RowCount(); return(query.Skip(start).Take(lenght).List()); }
public static IList <T> GetPagedResult <T>(this IQueryOver <T> query, PagedRequestDescription description) { query.Sort(description.JtSortingColumn, description.JtAscending); var entities = query.Skip(description.JtStartIndex).Take(description.JtPageSize).List <T>(); return(entities); }
/// <summary> /// /// </summary> /// <param name="theQueryOver"></param> /// <param name="startIndex"></param> /// <param name="maxRows">A value of Zero means we're not paging</param> /// <param name="hasOrderBy"></param> /// <returns></returns> public RetrievedData <T> RetrieveUsingPaging(IQueryOver <T, T> theQueryOver, int startIndex, int maxRows, bool hasOrderBy = false) { IEnumerable <T> result; int totalCount = 0; IFutureValue <int> futureCount = null; if (maxRows > 0) { futureCount = theQueryOver.Clone().Select(Projections.RowCount()).FutureValue <int>(); result = theQueryOver.Skip(startIndex * maxRows).Take(maxRows).Future <T>(); } else //get all { result = theQueryOver.Future <T>(); } var toReturn = result.ToList(); if (futureCount != null) { totalCount = futureCount.Value; } else { totalCount = toReturn.Count; } result = null; futureCount = null; return(new RetrievedData <T> { DataBatch = toReturn, TotalCount = totalCount }); }
/// <summary> /// Esegue la paginazione dei dati. /// </summary> /// <param name="queryOver"></param> /// <returns></returns> protected virtual IQueryOver <T, T> ExecutePaging(IQueryOver <T, T> queryOver) { if (EnablePaging) { queryOver.Skip(PageIndex); queryOver.Take(PageSize); } return(queryOver); }
public PagedObject <T> Paginate(IQueryOver <T> query, int pageSize, int pageNumber) { this.rowCount = query.RowCount(); this.pageCount = Math.Ceiling(this.rowCount / pageSize); this.pageSize = pageSize; this.ResultQuery = query.Skip((pageNumber - 1) * pageSize).Take(pageSize); return(this); }
public static IQueryOver <TRoot> AddSkip <TRoot>(this IQueryOver <TRoot> queryOver, int?skip) { if (skip.HasValue && skip.Value > 0) { return(queryOver.Skip(skip.Value)); } return(queryOver); }
/// <summary> /// Paging extensions of <see cref="IQueryOver{TRoot}"/> /// </summary> /// <typeparam name="T">{T}</typeparam> /// <param name="queryOver"><see cref="IQueryOver{TRoot}"/></param> /// <param name="currentPage">Current page</param> /// <param name="pageSize">Page size</param> /// <param name="records">Records</param> /// <returns><see cref="IPaging{T}"/></returns> public static IPaging <T> Paging <T>(this IQueryOver <T> queryOver, int currentPage, int pageSize, long?records) { queryOver.Skip(currentPage * pageSize); queryOver.Take(pageSize); return(records.HasValue ? queryOver.List <T>().Paging(currentPage, pageSize, records.Value) : queryOver.List <T>().Paging(currentPage, pageSize)); }
private static IFutureValue <long> MontarQueryPaginado <T>(IQueryOver <T, T> query, int pagina, int tamanhoPagina) where T : class { IFutureValue <long> count = query.ToRowCountInt64Query().FutureValue <long>(); if (pagina > 0 && tamanhoPagina > 0) { query.Skip((pagina - 1) * tamanhoPagina).Take(tamanhoPagina); } return(count); }
public static IPagedList <TResult> Paged <TResult>(this IQueryOver <TResult, TResult> queryBase, int pageNumber, int?pageSize = null) where TResult : SystemEntity { int size = pageSize ?? MrCMSApplication.Get <SiteSettings>().DefaultPageSize; IEnumerable <TResult> results = queryBase.Skip((pageNumber - 1) * size).Take(size).Cacheable().List(); int rowCount = queryBase.Cacheable().RowCount(); return(new StaticPagedList <TResult>(results, pageNumber, size, rowCount)); }
public static PagedList <T> PagedList <T>(this IQueryOver <T> query, int itemsperpage, int?page) { var howManyPages = (int)Math.Ceiling((decimal)query.Clone().ClearOrders().RowCount() / (decimal)itemsperpage); var items = query .Skip(((page ?? 1) - 1) * itemsperpage) .Take(itemsperpage) .List(); return(new PagedList <T>(page ?? 1, itemsperpage, howManyPages, items)); }
public IList <Supervise> QuerySupervise(Paging info, out int total) { using ISession session = DbFactory.OpenSession(); IQueryOver <Supervise> queries = session.QueryOver <Supervise>(); SetQueryArg(queries.RootCriteria, info.Get()); total = queries.RowCount(); return(queries .Skip((info.Page - 1) * info.Limit) .Take(info.Limit) .List()); }
public IList <WorkflowStructure> Query(int pageIndex, int pageSize, out int total, Dictionary <string, string> queryArg) { using ISession session = DbFactory.OpenSession(); IQueryOver <WorkflowStructure> queries = session.QueryOver <WorkflowStructure>(); SetQueryArg(queries.RootCriteria, queryArg); total = queries.RowCount(); return(queries .Skip((pageIndex - 1) * pageSize) .Take(pageSize) .List()); }
public static IPagedList <TResult> Paged <TQuery, TResult>(this IQueryOver <TQuery, TQuery> queryBase, IProjection countQuery, int pageNumber, int?pageSize = null, bool enableCache = true) where TQuery : SystemEntity { var size = pageSize ?? MrCMSApplication.Get <SiteSettings>().DefaultPageSize; var rowCountQuery = queryBase.Clone(); IEnumerable <TResult> results = queryBase.Skip((pageNumber - 1) * size).Take(size).MakeCacheable(enableCache).Future <TResult>(); int rowCount = rowCountQuery.Select(countQuery).ClearOrders().MakeCacheable(enableCache).FutureValue <int>().Value; return(new StaticPagedList <TResult>(results, pageNumber, size, rowCount)); }
public static IQueryOver <TPersistenceModel> ApplyPaging <TPersistenceModel>( this IQueryOver <TPersistenceModel> queryOver, int currentPageNumber, int pageSize) { if (currentPageNumber < 1) { throw new ArgumentOutOfRangeException("currentPageNumber", "Page number can't be less than 1"); } var query = queryOver.Skip((currentPageNumber - 1) * pageSize) .Take(pageSize); return(query); }
public IPage <TResult> FindPage <TResult>(IQueryOver <TResult, TResult> queryOver, IPageable pageRequest) { IQueryOver <TResult, TResult> countQuery = queryOver.Clone().ClearOrders().ToRowCountInt64Query(); countQuery.Skip(0).Take(int.MaxValue); IFutureValue <long> rowCount = countQuery.Select(Projections.RowCountInt64()).FutureValue <long>(); queryOver.Skip(pageRequest.FirstItem); queryOver.Take(pageRequest.PageSize); IEnumerable <TResult> enumerable = queryOver.Future <TResult>(); return(new Page <TResult>(enumerable.ToList(), pageRequest, rowCount.Value)); }
public static IQueryOver <T> Paged <T>(this IQueryOver <T, T> query, int first, int length) { if (first > 0) { query.Skip(first); } if (length > 0) { query.Take(length); } return(query); }
public IList <ServiceTariff> QueryAllServiceTariff(out int totalRecord, out int totalcountinresult, string search, int start, int lenght, string sortColumn, int groupid, string sortOrder, string scrProvider, string scrUsers, int otherFilters) { IQueryOver <ServiceTariff, ServiceTariff> query = _session.QueryOver <ServiceTariff>().Where(x => x.IsDeleted == false && x.GroupId == groupid); if (!string.IsNullOrEmpty(search)) { search = "%" + search + "%"; query.Where(Restrictions.On <ServiceTariff>(x => x.Name).IsInsensitiveLike(search)); } //return normal list. totalRecord = query.RowCount(); totalcountinresult = totalRecord; return(query.Skip(start).Take(lenght).List()); }
public static IQueryOver <TEntity, TEntity> SkipTake <TEntity>( this IQueryOver <TEntity, TEntity> query, int skip, int take) { if (skip > 0) { query.Skip(skip); } if (skip > 0) { query.Take(take); } return(query); }
public static IQueryOver <People, People> Pagination(this IQueryOver <People, People> model, string skip, string top) { var skipAsInteger = string.IsNullOrEmpty(skip) ? 0 : int.Parse(skip); var topAsInteger = string.IsNullOrEmpty(top) ? 0 : int.Parse(top); if (skipAsInteger > 0) { model.Skip(skipAsInteger); } if (topAsInteger > 0) { model.Take(topAsInteger); } return(model); }
/// <summary> /// 按Query条件查询并返回支持分页的对象列表 /// </summary> /// <param name="query">查询条件</param> /// <param name="pagingInfo">分页信息</param> /// <param name="orderBy">排序字段信息</param> /// <returns>支持翻页的对象列表</returns> public virtual IPagedList <T> GetObjectPagedList(IQueryOver <T, T> query, IPagingInfo pagingInfo, OrderField orderBy) { bool needPaging = pagingInfo != null && pagingInfo.IsLegal; if (needPaging) { if (pagingInfo.DoCount) { pagingInfo.RecordCount = query.RowCountInt64(); } query.Skip((pagingInfo.CurrentPage - 1) * pagingInfo.PageSize).Take(pagingInfo.PageSize); } query.RootCriteria.AddOrder(new Order(orderBy.PropertyName, orderBy.Ascending)); IList <T> list = query.List <T>(); return(needPaging ? list.ToPagedList(pagingInfo.CurrentPage, pagingInfo.PageSize, (int)pagingInfo.RecordCount) : list.ToPagedList(1, list.Count)); }
/// <summary> /// NHibernate query state /// </summary> /// <param name="queryOver"></param> /// <param name="skip"></param> /// <param name="pageSize"></param> public NhCoreQueryState(IQueryOver <T> queryOver, int skip, int pageSize) { if (queryOver == null) { throw new ArgumentNullException(nameof(queryOver)); } if (skip < 0) { throw new ArgumentOutOfRangeException(nameof(skip), $"{nameof(skip)} can not be less than zero"); } if (pageSize < 0) { throw new ArgumentOutOfRangeException(nameof(pageSize), $"{nameof(pageSize)} can not be less than zero"); } _mLazyChloeQueryMembers = new Lazy <IFutureEnumerable <T> >(() => queryOver.Skip(skip).Take(pageSize).Future()); }
public Page <TResult> Page(short pNumber, short pSize, SortType pSort, params Expression <Func <TResult, object> >[] pOrderBy) { var _count = ((IQueryOver <TResult, TResult>)_query.Clone()).Select(Projections.RowCount()).FutureValue <Int32>(); for (short f = 0; f < pOrderBy.GetLength(0); f++) { if (pSort == SortType.Ascending) { _query = _query.OrderBy(pOrderBy[f]).Asc(); } else { _query = _query.OrderBy(pOrderBy[f]).Desc(); } } IEnumerable <TResult> _result = _query.Skip(pSize * (pNumber - 1)).Take(pSize).List <TResult>(); return(new Page <TResult>(pNumber, pSize, _count.Value, _result)); }
public Stream writeEntitiesBatched <T>(IQueryOver <T> query, Func <IList <T>, IList <Feature> > action, string fileName, DbaseFileHeader header = null) { int i = 0; query.CacheMode(CacheMode.Ignore); IEnumerable <Feature> features = new List <Feature>(); IList <T> batch; do { batch = query.Skip(this.batchSize * i).Take(batchSize).List(); //batch = query.List(); features = features.Concat(action.Invoke(batch)); i++; } while (batch.Any()); if (header != null) { header.NumRecords = features.Count(); } return(shpShxSerializeService.WriteShape(features.ToList(), fileName, header)); }