Skip to content

Commit 9f03598

Browse files
mp911demp911de
committed
Polishing.
Add SpecificationFluentQuery to include specification-related overloads. Also, add slice(…) terminal method to obtain a slice only without running a count query. See #3727
1 parent 5315848 commit 9f03598

File tree

5 files changed

+143
-13
lines changed

5 files changed

+143
-13
lines changed

‎.gitignore

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,3 +13,4 @@ package-lock.json
1313
node
1414
build/
1515
.mvn/.develocity
16+
spring-data-jpa/gen

‎spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/JpaSpecificationExecutor.java

Lines changed: 56 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,13 +19,16 @@
1919
import jakarta.persistence.criteria.CriteriaQuery;
2020
import jakarta.persistence.criteria.Root;
2121

22+
import java.util.Arrays;
23+
import java.util.Collection;
2224
import java.util.List;
2325
import java.util.Optional;
2426
import java.util.function.Function;
2527

2628
import org.springframework.dao.InvalidDataAccessApiUsageException;
2729
import org.springframework.data.domain.Page;
2830
import org.springframework.data.domain.Pageable;
31+
import org.springframework.data.domain.Slice;
2932
import org.springframework.data.domain.Sort;
3033
import org.springframework.data.jpa.domain.Specification;
3134
import org.springframework.data.repository.query.FluentQuery;
@@ -84,6 +87,7 @@ public interface JpaSpecificationExecutor<T> {
8487
* be counted.
8588
* @param pageable must not be {@literal null}.
8689
* @return never {@literal null}.
90+
* @since 3.5
8791
*/
8892
Page<T> findAll(@Nullable Specification<T> spec, @Nullable Specification<T> countSpec, Pageable pageable);
8993

@@ -150,6 +154,57 @@ public interface JpaSpecificationExecutor<T> {
150154
* @since 3.0
151155
* @throws InvalidDataAccessApiUsageException if the query function returns the {@link FluentQuery} instance.
152156
*/
153-
<S extends T, R> R findBy(Specification<T> spec, Function<FluentQuery.FetchableFluentQuery<S>, R> queryFunction);
157+
<S extends T, R> R findBy(Specification<T> spec, Function<? super SpecificationFluentQuery<S>, R> queryFunction);
158+
159+
/**
160+
* Extension to {@link FetchableFluentQuery} allowing slice results and pagination with a custom count
161+
* {@link Specification}.
162+
*
163+
* @param <T>
164+
* @since 3.5
165+
*/
166+
interface SpecificationFluentQuery<T> extends FluentQuery.FetchableFluentQuery<T> {
167+
168+
@Override
169+
SpecificationFluentQuery<T> sortBy(Sort sort);
170+
171+
@Override
172+
SpecificationFluentQuery<T> limit(int limit);
173+
174+
@Override
175+
<R> SpecificationFluentQuery<R> as(Class<R> resultType);
176+
177+
@Override
178+
default SpecificationFluentQuery<T> project(String... properties) {
179+
return this.project(Arrays.asList(properties));
180+
}
181+
182+
@Override
183+
SpecificationFluentQuery<T> project(Collection<String> properties);
184+
185+
/**
186+
* Get a slice of matching elements for {@link Pageable} by requesting {@code Pageable#getPageSize() + 1} elements.
187+
*
188+
* @param pageable the pageable to request a paged result, can be {@link Pageable#unpaged()}, must not be
189+
* {@literal null}. The given {@link Pageable} will override any previously specified {@link Sort sort} if
190+
* the {@link Sort} object is not {@link Sort#isUnsorted()}. Any potentially specified {@link #limit(int)}
191+
* will be overridden by {@link Pageable#getPageSize()}.
192+
* @return
193+
*/
194+
Slice<T> slice(Pageable pageable);
195+
196+
/**
197+
* Get a page of matching elements for {@link Pageable} and provide a custom {@link Specification count
198+
* specification}.
199+
*
200+
* @param pageable the pageable to request a paged result, can be {@link Pageable#unpaged()}, must not be
201+
* {@literal null}. The given {@link Pageable} will override any previously specified {@link Sort sort} if
202+
* the {@link Sort} object is not {@link Sort#isUnsorted()}. Any potentially specified {@link #limit(int)}
203+
* will be overridden by {@link Pageable#getPageSize()}.
204+
* @param countSpec specification used to count results.
205+
* @return
206+
*/
207+
Page<T> page(Pageable pageable, Specification<?> countSpec);
208+
}
154209

155210
}

‎spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/support/FetchableFluentQueryBySpecification.java

Lines changed: 43 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -31,14 +31,18 @@
3131
import org.springframework.data.domain.PageImpl;
3232
import org.springframework.data.domain.Pageable;
3333
import org.springframework.data.domain.ScrollPosition;
34+
import org.springframework.data.domain.Slice;
35+
import org.springframework.data.domain.SliceImpl;
3436
import org.springframework.data.domain.Sort;
3537
import org.springframework.data.domain.Window;
3638
import org.springframework.data.jpa.domain.Specification;
39+
import org.springframework.data.jpa.repository.JpaSpecificationExecutor.SpecificationFluentQuery;
3740
import org.springframework.data.jpa.repository.query.ScrollDelegate;
3841
import org.springframework.data.jpa.support.PageableUtils;
3942
import org.springframework.data.projection.ProjectionFactory;
4043
import org.springframework.data.repository.query.FluentQuery;
4144
import org.springframework.data.support.PageableExecutionUtils;
45+
import org.springframework.lang.Nullable;
4246
import org.springframework.util.Assert;
4347

4448
/**
@@ -52,7 +56,7 @@
5256
* @since 3.0
5357
*/
5458
class FetchableFluentQueryBySpecification<S, R> extends FluentQuerySupport<S, R>
55-
implements FluentQuery.FetchableFluentQuery<R> {
59+
implements FluentQuery.FetchableFluentQuery<R>, SpecificationFluentQuery<R> {
5660

5761
private final Specification<S> spec;
5862
private final Function<FluentQuerySupport<?, ?>, TypedQuery<S>> finder;
@@ -85,7 +89,7 @@ private FetchableFluentQueryBySpecification(Specification<S> spec, Class<S> enti
8589
}
8690

8791
@Override
88-
public FetchableFluentQuery<R> sortBy(Sort sort) {
92+
public SpecificationFluentQuery<R> sortBy(Sort sort) {
8993

9094
Assert.notNull(sort, "Sort must not be null");
9195

@@ -94,7 +98,7 @@ public FetchableFluentQuery<R> sortBy(Sort sort) {
9498
}
9599

96100
@Override
97-
public FetchableFluentQuery<R> limit(int limit) {
101+
public SpecificationFluentQuery<R> limit(int limit) {
98102

99103
Assert.isTrue(limit >= 0, "Limit must not be negative");
100104

@@ -103,7 +107,7 @@ public FetchableFluentQuery<R> limit(int limit) {
103107
}
104108

105109
@Override
106-
public <NR> FetchableFluentQuery<NR> as(Class<NR> resultType) {
110+
public <NR> SpecificationFluentQuery<NR> as(Class<NR> resultType) {
107111

108112
Assert.notNull(resultType, "Projection target type must not be null");
109113

@@ -112,7 +116,7 @@ public <NR> FetchableFluentQuery<NR> as(Class<NR> resultType) {
112116
}
113117

114118
@Override
115-
public FetchableFluentQuery<R> project(Collection<String> properties) {
119+
public SpecificationFluentQuery<R> project(Collection<String> properties) {
116120

117121
return new FetchableFluentQueryBySpecification<>(spec, entityType, resultType, sort, limit, properties, finder,
118122
scroll, countOperation, existsOperation, entityManager, projectionFactory);
@@ -155,9 +159,20 @@ public Window<R> scroll(ScrollPosition scrollPosition) {
155159
return scroll.scroll(this, scrollPosition).map(getConversionFunction());
156160
}
157161

162+
@Override
163+
public Slice<R> slice(Pageable pageable) {
164+
return pageable.isUnpaged() ? new PageImpl<>(all()) : readSlice(pageable);
165+
}
166+
158167
@Override
159168
public Page<R> page(Pageable pageable) {
160-
return pageable.isUnpaged() ? new PageImpl<>(all()) : readPage(pageable);
169+
return pageable.isUnpaged() ? new PageImpl<>(all()) : readPage(pageable, spec);
170+
}
171+
172+
@Override
173+
@SuppressWarnings({ "rawtypes", "unchecked" })
174+
public Page<R> page(Pageable pageable, Specification<?> countSpec) {
175+
return pageable.isUnpaged() ? new PageImpl<>(all()) : readPage(pageable, (Specification) countSpec);
161176
}
162177

163178
@Override
@@ -193,7 +208,27 @@ private TypedQuery<S> createSortedAndProjectedQuery() {
193208
return query;
194209
}
195210

196-
private Page<R> readPage(Pageable pageable) {
211+
private Slice<R> readSlice(Pageable pageable) {
212+
213+
TypedQuery<S> pagedQuery = createSortedAndProjectedQuery();
214+
215+
if (pageable.isPaged()) {
216+
pagedQuery.setFirstResult(PageableUtils.getOffsetAsInteger(pageable));
217+
pagedQuery.setMaxResults(pageable.getPageSize() + 1);
218+
}
219+
220+
List<S> resultList = pagedQuery.getResultList();
221+
boolean hasNext = resultList.size() > pageable.getPageSize();
222+
if (hasNext) {
223+
resultList = resultList.subList(0, pageable.getPageSize());
224+
}
225+
226+
List<R> slice = convert(resultList);
227+
228+
return new SliceImpl<>(slice, pageable, hasNext);
229+
}
230+
231+
private Page<R> readPage(Pageable pageable, @Nullable Specification<S> countSpec) {
197232

198233
TypedQuery<S> pagedQuery = createSortedAndProjectedQuery();
199234

@@ -204,7 +239,7 @@ private Page<R> readPage(Pageable pageable) {
204239

205240
List<R> paginatedResults = convert(pagedQuery.getResultList());
206241

207-
return PageableExecutionUtils.getPage(paginatedResults, pageable, () -> countOperation.apply(spec));
242+
return PageableExecutionUtils.getPage(paginatedResults, pageable, () -> countOperation.apply(countSpec));
208243
}
209244

210245
private List<R> convert(List<S> resultList) {

‎spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/support/SimpleJpaRepository.java

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -506,7 +506,8 @@ public long delete(@Nullable Specification<T> spec) {
506506
}
507507

508508
@Override
509-
public <S extends T, R> R findBy(Specification<T> spec, Function<FetchableFluentQuery<S>, R> queryFunction) {
509+
public <S extends T, R> R findBy(Specification<T> spec,
510+
Function<? super SpecificationFluentQuery<S>, R> queryFunction) {
510511

511512
Assert.notNull(spec, SPECIFICATION_MUST_NOT_BE_NULL);
512513
Assert.notNull(queryFunction, QUERY_FUNCTION_MUST_NOT_BE_NULL);
@@ -515,7 +516,7 @@ public <S extends T, R> R findBy(Specification<T> spec, Function<FetchableFluent
515516
}
516517

517518
private <S extends T, R> R doFindBy(Specification<T> spec, Class<T> domainClass,
518-
Function<FetchableFluentQuery<S>, R> queryFunction) {
519+
Function<? super SpecificationFluentQuery<S>, R> queryFunction) {
519520

520521
Assert.notNull(spec, SPECIFICATION_MUST_NOT_BE_NULL);
521522
Assert.notNull(queryFunction, QUERY_FUNCTION_MUST_NOT_BE_NULL);
@@ -550,7 +551,7 @@ private <S extends T, R> R doFindBy(Specification<T> spec, Class<T> domainClass,
550551
FetchableFluentQueryBySpecification<?, T> fluentQuery = new FetchableFluentQueryBySpecification<>(spec, domainClass,
551552
finder, scrollDelegate, this::count, this::exists, this.entityManager, getProjectionFactory());
552553

553-
R result = queryFunction.apply((FetchableFluentQuery<S>) fluentQuery);
554+
R result = queryFunction.apply((SpecificationFluentQuery<S>) fluentQuery);
554555

555556
if (result instanceof FluentQuery<?>) {
556557
throw new InvalidDataAccessApiUsageException(
@@ -718,7 +719,7 @@ protected Page<T> readPage(TypedQuery<T> query, Pageable pageable, @Nullable Spe
718719
* @param spec can be {@literal null}.
719720
* @param pageable can be {@literal null}.
720721
*/
721-
protected <S extends T> Page<S> readPage(TypedQuery<S> query, final Class<S> domainClass, Pageable pageable,
722+
protected <S extends T> Page<S> readPage(TypedQuery<S> query, Class<S> domainClass, Pageable pageable,
722723
@Nullable Specification<S> spec) {
723724

724725
if (pageable.isPaged()) {

‎spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/UserRepositoryTests.java

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2706,6 +2706,44 @@ void findByFluentSpecificationPage() {
27062706
assertThat(page1.getContent()).containsExactly(fourthUser);
27072707
}
27082708

2709+
@Test // GH-2274
2710+
void findByFluentSpecificationSlice() {
2711+
2712+
flushTestUsers();
2713+
2714+
Slice<User> slice = repository.findBy(userHasFirstnameLike("v"),
2715+
q -> q.sortBy(Sort.by("firstname")).slice(PageRequest.of(0, 2)));
2716+
2717+
assertThat(slice).isNotInstanceOf(Page.class);
2718+
assertThat(slice.getContent()).containsExactly(thirdUser, firstUser);
2719+
assertThat(slice.hasNext()).isTrue();
2720+
2721+
slice = repository.findBy(userHasFirstnameLike("v"),
2722+
q -> q.sortBy(Sort.by("firstname")).slice(PageRequest.of(0, 3)));
2723+
2724+
assertThat(slice).isNotInstanceOf(Page.class);
2725+
assertThat(slice).hasSize(3);
2726+
assertThat(slice.hasNext()).isFalse();
2727+
}
2728+
2729+
@Test // GH-3727
2730+
void findByFluentSpecificationPageCustomCountSpec() {
2731+
2732+
flushTestUsers();
2733+
2734+
Page<User> page0 = repository.findBy(userHasFirstnameLike("v"),
2735+
q -> q.sortBy(Sort.by("firstname")).page(PageRequest.of(0, 2), (root, query, criteriaBuilder) -> null));
2736+
2737+
assertThat(page0.getContent()).containsExactly(thirdUser, firstUser);
2738+
assertThat(page0.getTotalElements()).isEqualTo(4L);
2739+
2740+
page0 = repository.findBy(userHasFirstnameLike("v"),
2741+
q -> q.sortBy(Sort.by("firstname")).page(PageRequest.of(0, 2)));
2742+
2743+
assertThat(page0.getContent()).containsExactly(thirdUser, firstUser);
2744+
assertThat(page0.getTotalElements()).isEqualTo(3L);
2745+
}
2746+
27092747
@Test // GH-2274, GH-3716
27102748
void findByFluentSpecificationWithInterfaceBasedProjection() {
27112749

0 commit comments

Comments
 (0)