Example usage for org.springframework.data.domain Pageable getOffset

Introduction

In this page you can find the example usage for org.springframework.data.domain Pageable getOffset.

Prototype

long getOffset();

Source Link

Document

Returns the offset to be taken according to the underlying page and page size.

Usage

From source file:ei.ne.ke.cassandra.cql3.AstyanaxCql3Repository.java

protected Page<T> doFindAll(ID restrict, Pageable pageable) {
    /*//from   ww  w . j a  v a  2s. co m
     * Example #1
     *   pageNumber = 0
     *   pageSize = 25
     *   offset = 0
     *   => start row = 0
     *   => end row = 24 (including)
     *
     * Example #2
     *   pageNumber = 1
     *   pageSize = 25
     *   offset = 0
     *   => start row = 25
     *   => end row = 49 (including)
     *
     * Example #3
     *   pageNumber = 1
     *   pageSize = 25
     *   offset = 10
     *   => start row = 35
     *   => end row = 59 (including)
     */
    try {
        int pageNumber = pageable.getPageNumber();
        int pageSize = pageable.getPageSize();
        int offset = pageable.getOffset();
        int firstRow = pageNumber * pageSize + offset;
        int lastRow = (pageNumber + 1) * pageSize + offset;
        Map<String, ByteBuffer> serializedKeyValues = spec.getSerializedKeyValues(restrict);
        List<String> keysSet = EntitySpecificationUtils.getKeysSet(serializedKeyValues);
        String keysCql = cqlGen.buildLimitedFindAllKeysStatement(keysSet, pageable.getSort(), lastRow);
        PreparedCqlQuery<String, String> preparedStatement = doPreparedCqlRead(keysCql);
        for (String column : keysSet) {
            preparedStatement = preparedStatement.withValue(serializedKeyValues.get(column));
        }
        OperationResult<CqlResult<String, String>> keysResult = preparedStatement.execute();
        LOGGER.debug("attempts: {}, latency: {}ms", keysResult.getAttemptsCount(),
                keysResult.getLatency(TimeUnit.MILLISECONDS));
        CqlResult<String, String> cqlKeysResult = keysResult.getResult();
        Rows<String, String> keysSetRows = cqlKeysResult.getRows();
        List<T> keysAsEnts = Lists.newArrayListWithExpectedSize(lastRow - firstRow + 1);
        for (int i = firstRow; i < keysSetRows.size() && i < lastRow; i++) {
            keysAsEnts.add(spec.map(keysSetRows.getRowByIndex(i).getColumns()));
        }
        List<ID> keys = spec.getKey(keysAsEnts);
        return new PageImpl<T>((List<T>) findAll(keys), pageable, count(restrict));
    } catch (ConnectionException e) {
        throw new DataRetrievalFailureException("Error while executing CQL3 query", e);
    }
}

---

From source file:org.wallride.repository.TagRepositoryImpl.java

@Override
public Page<Tag> search(TagSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Tag.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "name" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;/*from   w ww.ja  v  a  2s .  c o  m*/
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Tag.class);

    Sort sort = new Sort(new SortField("sortName", SortField.Type.STRING));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Tag.class)
            .setCriteriaQuery(criteria).setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Tag> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

---

From source file:org.wallride.repository.CustomFieldRepositoryImpl.java

public FullTextQuery buildFullTextQuery(CustomFieldSearchRequest request, Pageable pageable,
        Criteria criteria) {/*from   ww  w  .  ja  va  2  s . c  o m*/
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(CustomField.class)
            .get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "name", "code", "description" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("idx", SortField.Type.INT));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, CustomField.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

---

From source file:org.wallride.repository.CategoryRepositoryImpl.java

@Override
public Page<Category> search(CategorySearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Category.class)
            .get();//w w  w .  j av a  2  s  .co m

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "name" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Category.class);

    Sort sort = new Sort(new SortField("sortName", SortField.Type.STRING));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Category.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Category> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

---

From source file:com.mobileman.kuravis.core.services.entity.impl.AbstractEntityServiceImpl.java

@Override
public List<DBObject> findAll(String entityName, String projection, Pageable page) {
    if (page == null) {
        page = new PageRequest(0, Integer.MAX_VALUE);
    }/* w  ww  . ja  va2s.co  m*/

    DBCursor cursor = null;
    if (StringUtils.isEmpty(projection)) {
        cursor = getCollection(entityName).find(new BasicDBObject());
    } else {
        String[] properties = projection.split(",");
        BasicDBObjectBuilder projectionBuilder = BasicDBObjectBuilder.start();
        boolean idWanted = false;
        for (String property : properties) {
            property = property.trim();
            if (!StringUtils.isEmpty(property)) {
                if (property.equals(EntityUtils.ID)) {
                    idWanted = true;
                }

                projectionBuilder.add(property.trim(), true);
            }
        }

        if (idWanted == false) {
            projectionBuilder.append("_id", false);
        }

        cursor = getCollection(entityName).find(new BasicDBObject(), projectionBuilder.get())
                .sort(new BasicDBObject(projection, 1));
    }

    if (page.getSort() != null) {
        cursor = cursor.sort(createSort(page));
    } else if (projection != null) {
        cursor = cursor.sort(new BasicDBObject(projection, 1));
    }

    cursor = cursor.skip(page.getOffset()).limit(page.getPageSize());

    List<DBObject> result = cursor.toArray();
    return result;
}

---

From source file:org.wallride.repository.UserRepositoryImpl.java

private FullTextQuery buildFullTextQuery(UserSearchRequest request, Pageable pageable, Criteria criteria) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(User.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "loginId", "name.firstName", "name.lastName", };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;//from ww  w .  j a  va  2  s.c  o  m
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (!CollectionUtils.isEmpty(request.getRoles())) {
        for (User.Role role : request.getRoles()) {
            junction.must(qb.keyword().onField("roles").matching(role).createQuery());
        }
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("sortId", SortField.Type.LONG, false));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, User.class)
            .setCriteriaQuery(criteria)
            //            .setProjection("id")
            .setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

---

From source file:com.netflix.genie.core.jpa.services.JpaJobSearchServiceImpl.java

/**
 * {@inheritDoc}/*from   w  w  w  .  j  a v a  2 s. c o m*/
 */
@Override
public Page<JobSearchResult> findJobs(final String id, final String jobName, final String user,
        final Set<JobStatus> statuses, final Set<String> tags, final String clusterName, final String clusterId,
        final String commandName, final String commandId, final Date minStarted, final Date maxStarted,
        final Date minFinished, final Date maxFinished, @NotNull final Pageable page) {
    log.debug("called");

    final CriteriaBuilder cb = this.entityManager.getCriteriaBuilder();
    final CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
    final Root<JobEntity> root = countQuery.from(JobEntity.class);

    final Predicate whereClause = JpaJobSpecs.getFindPredicate(root, cb, id, jobName, user, statuses, tags,
            clusterName, clusterId == null ? null : this.clusterRepository.findOne(clusterId), commandName,
            commandId == null ? null : this.commandRepository.findOne(commandId), minStarted, maxStarted,
            minFinished, maxFinished);

    countQuery.select(cb.count(root)).where(whereClause);

    final Long count = this.entityManager.createQuery(countQuery).getSingleResult();

    // Use the count to make sure we even need to make this query
    if (count > 0) {
        final CriteriaQuery<JobSearchResult> contentQuery = cb.createQuery(JobSearchResult.class);
        contentQuery.from(JobEntity.class);

        contentQuery.multiselect(root.get(JobEntity_.id), root.get(JobEntity_.name), root.get(JobEntity_.user),
                root.get(JobEntity_.status), root.get(JobEntity_.started), root.get(JobEntity_.finished),
                root.get(JobEntity_.clusterName), root.get(JobEntity_.commandName));

        contentQuery.where(whereClause);

        final Sort sort = page.getSort();
        final List<Order> orders = new ArrayList<>();
        sort.iterator().forEachRemaining(order -> {
            if (order.isAscending()) {
                orders.add(cb.asc(root.get(order.getProperty())));
            } else {
                orders.add(cb.desc(root.get(order.getProperty())));
            }
        });

        contentQuery.orderBy(orders);

        final List<JobSearchResult> results = this.entityManager.createQuery(contentQuery)
                .setFirstResult(page.getOffset()).setMaxResults(page.getPageSize()).getResultList();

        return new PageImpl<>(results, page, count);
    } else {
        return new PageImpl<>(Lists.newArrayList(), page, count);
    }
}

---

From source file:com.ethlo.geodata.GeodataServiceImpl.java

@Override
public Page<GeoLocation> filter(LocationFilter filter, Pageable pageable) {
    final Collection<Query<GeoLocation>> queries = new LinkedList<>();

    if (filter.getName() != null) {
        if (filter.getName().endsWith("*")) {
            queries.add(QueryFactory.startsWith(CqGeonamesRepository.ATTRIBUTE_LC_NAME,
                    StringUtils.strip(filter.getName(), "*")));
        } else {//from  w ww.j a v  a  2 s  . c om
            queries.add(QueryFactory.equal(CqGeonamesRepository.ATTRIBUTE_LC_NAME, filter.getName()));
        }
    }

    if (!filter.getFeatureClasses().isEmpty()) {
        queries.add(QueryFactory.in(CqGeonamesRepository.ATTRIBUTE_FEATURE_CLASS, filter.getFeatureClasses()));
    }

    if (!filter.getFeatureCodes().isEmpty()) {
        queries.add(QueryFactory.in(CqGeonamesRepository.ATTRIBUTE_FEATURE_CODE, filter.getFeatureCodes()));
    }

    if (!filter.getCountryCodes().isEmpty()) {
        queries.add(QueryFactory.in(CqGeonamesRepository.ATTRIBUTE_COUNTRY_CODE, filter.getCountryCodes()));
    }

    Query<GeoLocation> query;

    if (queries.isEmpty()) {
        query = QueryFactory.none(GeoLocation.class);
    } else if (queries.size() == 1) {
        query = queries.iterator().next();
    } else {
        query = new And<>(queries);
    }

    final ResultSet<GeoLocation> result = geoNamesRepository.retrieve(query,
            QueryFactory.queryOptions(QueryFactory.orderBy(QueryFactory
                    .descending(QueryFactory.missingLast(CqGeonamesRepository.ATTRIBUTE_POPULATION)))));
    int index = 0;
    final List<GeoLocation> content = new LinkedList<>();
    for (GeoLocation l : result) {
        if (index >= pageable.getOffset() && content.size() < pageable.getPageSize()) {
            content.add(l);
        }
        index++;
    }

    return new PageImpl<>(content, pageable, index);
}

---

From source file:org.wallride.repository.CommentRepositoryImpl.java

@Override
public Page<Comment> search(CommentSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Comment.class)
            .get();//from w  w  w .  j  a  v a2s .c  om

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "authorName", "content" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("post.language").matching(request.getLanguage()).createQuery());
    }

    if (request.getPostId() != null) {
        junction.must(qb.keyword().onField("post.id").matching(request.getPostId()).createQuery());
    }

    if (request.getApproved() != null) {
        junction.must(qb.keyword().onField("approved").matching(request.getApproved()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Comment.class).setFetchMode("post", FetchMode.JOIN)
            .setFetchMode("author", FetchMode.JOIN);

    Sort sort = null;
    if (pageable.getSort() != null) {
        if (pageable.getSort().getOrderFor("date") != null) {
            Order order = pageable.getSort().getOrderFor("date");
            sort = new Sort(
                    new SortField("sortDate", SortField.Type.STRING,
                            order.getDirection().equals(Direction.DESC)),
                    new SortField("sortId", SortField.Type.LONG, order.getDirection().equals(Direction.DESC)));
        }
    }

    if (sort == null) {
        sort = new Sort(new SortField("sortDate", SortField.Type.STRING),
                new SortField("sortId", SortField.Type.LONG));
    }

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Comment.class)
            .setCriteriaQuery(criteria).setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Comment> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

---

From source file:org.wallride.repository.PostRepositoryImpl.java

@Override
public Page<Post> search(PostSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Post.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    junction.must(qb.keyword().onField("drafted").ignoreAnalyzer().matching("_null_").createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "title", "body", "tags.name", };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;/*from   w  ww  . j av a 2  s .  co  m*/
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }
    if (request.getStatus() != null) {
        junction.must(qb.keyword().onField("status").matching(request.getStatus()).createQuery());
    }
    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    if (request.getDateFrom() != null) {
        junction.must(qb.range().onField("date").above(request.getDateFrom()).createQuery());
    }
    if (request.getDateTo() != null) {
        junction.must(qb.range().onField("date").below(request.getDateTo()).createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getTagNames())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String tagName : request.getTagNames()) {
            subJunction.should(qb.phrase().onField("tags.name").sentence(tagName).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getPostIds())) {
        BooleanJunction<BooleanJunction> bool = qb.bool();
        for (long postId : request.getPostIds()) {
            bool.should(qb.keyword().onField("id").matching(postId).createQuery());
        }
        junction.must(bool.createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Post.class).setFetchMode("cover", FetchMode.JOIN)
            .setFetchMode("tags", FetchMode.JOIN).setFetchMode("categories", FetchMode.JOIN)
            .setFetchMode("customFieldValues", FetchMode.JOIN)
            .setFetchMode("customFieldValues.customField", FetchMode.JOIN)
            .setFetchMode("author", FetchMode.JOIN);

    Sort sort = new Sort(new SortField("sortDate", SortField.Type.STRING, true),
            new SortField("sortId", SortField.Type.LONG, true));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Post.class)
            .setCriteriaQuery(criteria).setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Post> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• »