@Override protected Query complete(Criteria criteria, Sort sort) { Query query = (criteria == null ? new Query() : new Query(criteria)).with(sort); if (LOG.isDebugEnabled()) { LOG.debug("Created query " + query); } return query; }
@Override public Flux<T> findAll(Sort sort) { Assert.notNull(sort, "Sort must not be null!"); return findAll(new Query().with(sort)); }
@Override public List<T> findAll(Sort sort) { Assert.notNull(sort, "Sort must not be null!"); return findAll(new Query().with(sort)); }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public Object execute(Query query) { int pageSize = pageable.getPageSize(); // Apply Pageable but tweak limit to peek into next page Query modifiedQuery = query.with(pageable).limit(pageSize + 1); List result = find.matching(modifiedQuery).all(); boolean hasNext = result.size() > pageSize; return new SliceImpl<Object>(hasNext ? result.subList(0, pageSize) : result, pageable, hasNext); } }
@Override public Page<T> findAll(Pageable pageable) { Assert.notNull(pageable, "Pageable must not be null!"); Long count = count(); List<T> list = findAll(new Query().with(pageable)); return new PageImpl<T>(list, pageable, count); }
@Override public <S extends T> List<S> findAll(Example<S> example, Sort sort) { Assert.notNull(example, "Sample must not be null!"); Assert.notNull(sort, "Sort must not be null!"); Query q = new Query(new Criteria().alike(example)).with(sort); return mongoOperations.find(q, example.getProbeType(), entityInformation.getCollectionName()); }
@Override public <S extends T> Flux<S> findAll(Example<S> example, Sort sort) { Assert.notNull(example, "Sample must not be null!"); Assert.notNull(sort, "Sort must not be null!"); Query query = new Query(new Criteria().alike(example)).with(sort); return mongoOperations.find(query, example.getProbeType(), entityInformation.getCollectionName()); }
/** * Sets the given pagination information on the {@link Query} instance. Will transparently set {@code skip} and * {@code limit} as well as applying the {@link Sort} instance defined with the {@link Pageable}. * * @param pageable * @return */ public Query with(Pageable pageable) { if (pageable.isUnpaged()) { return this; } this.limit = pageable.getPageSize(); this.skip = pageable.getOffset(); return with(pageable.getSort()); }
@Override public <S extends T> Page<S> findAll(final Example<S> example, Pageable pageable) { Assert.notNull(example, "Sample must not be null!"); Assert.notNull(pageable, "Pageable must not be null!"); Query q = new Query(new Criteria().alike(example)).with(pageable); List<S> list = mongoOperations.find(q, example.getProbeType(), entityInformation.getCollectionName()); return PageableExecutionUtils.getPage(list, pageable, () -> mongoOperations.count(q, example.getProbeType(), entityInformation.getCollectionName())); }
@Override public Object execute(Query query) { int overallLimit = query.getLimit(); TerminatingFind<?> matching = operation.matching(query); // Apply raw pagination query.with(pageable); // Adjust limit if page would exceed the overall limit if (overallLimit != 0 && pageable.getOffset() + pageable.getPageSize() > overallLimit) { query.limit((int) (overallLimit - pageable.getOffset())); } return PageableExecutionUtils.getPage(matching.all(), pageable, () -> { long count = matching.count(); return overallLimit != 0 ? Math.min(count, overallLimit) : count; }); } }
@Test public void testQueryObjectWithIgnoredPageSize() throws Exception { reader = new MongoItemReader<>(); reader.setTemplate(template); Query query = new Query() .with(Sort.by(new Order(Sort.Direction.ASC, "_id"))) .with(PageRequest.of(0, 50)); reader.setQuery(query); reader.setTargetType(String.class); reader.afterPropertiesSet(); ArgumentCaptor<Query> queryContainer = ArgumentCaptor.forClass(Query.class); when(template.find(queryContainer.capture(), eq(String.class))).thenReturn(new ArrayList<>()); assertFalse(reader.doPageRead().hasNext()); Query actualQuery = queryContainer.getValue(); assertFalse(reader.doPageRead().hasNext()); assertEquals(10, actualQuery.getLimit()); assertEquals(0, actualQuery.getSkip()); }
@Test public void testQueryObjectWithPageSize() throws Exception { reader = new MongoItemReader<>(); reader.setTemplate(template); Query query = new Query() .with(Sort.by(new Order(Sort.Direction.ASC, "_id"))) .with(PageRequest.of(30, 50)); reader.setQuery(query); reader.setTargetType(String.class); reader.setPageSize(100); reader.afterPropertiesSet(); ArgumentCaptor<Query> queryContainer = ArgumentCaptor.forClass(Query.class); when(template.find(queryContainer.capture(), eq(String.class))).thenReturn(new ArrayList<>()); assertFalse(reader.doPageRead().hasNext()); Query actualQuery = queryContainer.getValue(); assertFalse(reader.doPageRead().hasNext()); assertEquals(100, actualQuery.getLimit()); assertEquals(0, actualQuery.getSkip()); }
@Test public void testQueryObject() throws Exception { reader = new MongoItemReader<>(); reader.setTemplate(template); Query query = new Query() .with(Sort.by(new Order(Sort.Direction.ASC, "_id"))); reader.setQuery(query); reader.setTargetType(String.class); reader.afterPropertiesSet(); ArgumentCaptor<Query> queryContainer = ArgumentCaptor.forClass(Query.class); when(template.find(queryContainer.capture(), eq(String.class))).thenReturn(new ArrayList<>()); assertFalse(reader.doPageRead().hasNext()); Query actualQuery = queryContainer.getValue(); assertFalse(reader.doPageRead().hasNext()); assertEquals(10, actualQuery.getLimit()); assertEquals(0, actualQuery.getSkip()); }
@Test public void testQueryObjectWithCollection() throws Exception { reader = new MongoItemReader<>(); reader.setTemplate(template); Query query = new Query() .with(Sort.by(new Order(Sort.Direction.ASC, "_id"))); reader.setQuery(query); reader.setTargetType(String.class); reader.setCollection("collection"); reader.afterPropertiesSet(); ArgumentCaptor<Query> queryContainer = ArgumentCaptor.forClass(Query.class); ArgumentCaptor<String> stringContainer = ArgumentCaptor.forClass(String.class); when(template.find(queryContainer.capture(), eq(String.class), stringContainer.capture())).thenReturn(new ArrayList<>()); assertFalse(reader.doPageRead().hasNext()); Query actualQuery = queryContainer.getValue(); assertFalse(reader.doPageRead().hasNext()); assertEquals(10, actualQuery.getLimit()); assertEquals(0, actualQuery.getSkip()); assertEquals("collection", stringContainer.getValue()); } }
private ReactiveMongoQueryExecution getExecutionToWrap(MongoParameterAccessor accessor, FindWithQuery<?> operation) { if (isDeleteQuery()) { return new DeleteExecution(operations, method); } else if (method.isGeoNearQuery()) { return new GeoNearExecution(operations, accessor, method.getReturnType()); } else if (isTailable(method)) { return (q, t, c) -> operation.matching(q.with(accessor.getPageable())).tail(); } else if (method.isCollectionQuery()) { return (q, t, c) -> operation.matching(q.with(accessor.getPageable())).all(); } else if (isCountQuery()) { return (q, t, c) -> operation.matching(q).count(); } else if (isExistsQuery()) { return (q, t, c) -> operation.matching(q).exists(); } else { return (q, t, c) -> { TerminatingFind<?> find = operation.matching(q); if (isCountQuery()) { return find.count(); } return isLimiting() ? find.first() : find.one(); }; } }
@Test public void testAfterPropertiesSetForQueryObject() throws Exception{ reader = new MongoItemReader<>(); reader.setTemplate(template); reader.setTargetType(String.class); Query query1 = new Query().with(Sort.by(new Order(Sort.Direction.ASC, "_id"))); reader.setQuery(query1); reader.afterPropertiesSet(); }
private MongoQueryExecution getExecution(ConvertingParameterAccessor accessor, FindWithQuery<?> operation) { if (isDeleteQuery()) { return new DeleteExecution(operations, method); } else if (method.isGeoNearQuery() && method.isPageQuery()) { return new PagingGeoNearExecution(operation, method, accessor, this); } else if (method.isGeoNearQuery()) { return new GeoNearExecution(operation, method, accessor); } else if (method.isSliceQuery()) { return new SlicedExecution(operation, accessor.getPageable()); } else if (method.isStreamQuery()) { return q -> operation.matching(q).stream(); } else if (method.isCollectionQuery()) { return q -> operation.matching(q.with(accessor.getPageable()).with(accessor.getSort())).all(); } else if (method.isPageQuery()) { return new PagedExecution(operation, accessor.getPageable()); } else if (isCountQuery()) { return q -> operation.matching(q).count(); } else if (isExistsQuery()) { return q -> operation.matching(q).exists(); } else { return q -> { TerminatingFind<?> find = operation.matching(q); return isLimiting() ? find.firstValue() : find.oneValue(); }; } }
private static Query groupOrderQuery(Object groupId) { Sort sort = Sort.by(Sort.Direction.DESC, MessageDocumentFields.LAST_MODIFIED_TIME, MessageDocumentFields.SEQUENCE); return groupIdQuery(groupId).with(sort); }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public Object execute(Query query) { int pageSize = pageable.getPageSize(); // Apply Pageable but tweak limit to peek into next page Query modifiedQuery = query.with(pageable).limit(pageSize + 1); List result = find.matching(modifiedQuery).all(); boolean hasNext = result.size() > pageSize; return new SliceImpl<Object>(hasNext ? result.subList(0, pageSize) : result, pageable, hasNext); } }