diff --git a/src/main/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplate.java b/src/main/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplate.java index 8006dc996..84c81a703 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplate.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplate.java @@ -14,13 +14,12 @@ import org.elasticsearch.action.search.SearchRequest; import org.elasticsearch.action.search.SearchResponse; import org.elasticsearch.common.unit.TimeValue; import org.elasticsearch.index.query.MoreLikeThisQueryBuilder; -import org.elasticsearch.search.SearchHit; import org.elasticsearch.search.suggest.SuggestBuilder; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; -import org.springframework.data.domain.Page; import org.springframework.data.elasticsearch.ElasticsearchException; +import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage; import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter; import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter; import org.springframework.data.elasticsearch.core.document.SearchDocumentResponse; @@ -98,26 +97,29 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper public CloseableIterator stream(Query query, Class clazz, IndexCoordinates index) { long scrollTimeInMillis = TimeValue.timeValueMinutes(1).millis(); return StreamQueries.streamResults(startScroll(scrollTimeInMillis, query, clazz, index), - scrollId -> continueScroll(scrollId, scrollTimeInMillis, clazz), this::clearScroll); + scrollId -> continueScroll(scrollId, scrollTimeInMillis, clazz), this::searchScrollClear); } @Override - public Page moreLikeThis(MoreLikeThisQuery query, Class clazz, IndexCoordinates index) { + public CloseableIterator> searchForStream(Query query, Class clazz, IndexCoordinates index) { + long scrollTimeInMillis = TimeValue.timeValueMinutes(1).millis(); + return StreamQueries.streamResults(searchScrollStart(scrollTimeInMillis, query, clazz, index), + scrollId -> searchScrollContinue(scrollId, scrollTimeInMillis, clazz), this::searchScrollClear); + } + + @Override + public AggregatedPage> search(MoreLikeThisQuery query, Class clazz, IndexCoordinates index) { Assert.notNull(query.getId(), "No document id defined for MoreLikeThisQuery"); MoreLikeThisQueryBuilder moreLikeThisQueryBuilder = requestFactory.moreLikeThisQueryBuilder(query, index); - return queryForPage(new NativeSearchQueryBuilder().withQuery(moreLikeThisQueryBuilder).build(), clazz, index); + return searchForPage(new NativeSearchQueryBuilder().withQuery(moreLikeThisQueryBuilder).build(), clazz, index); } @Override - public List queryForList(Query query, Class clazz, IndexCoordinates index) { - return queryForPage(query, clazz, index).getContent(); - } - - @Override - public List> queryForPage(List queries, Class clazz, IndexCoordinates index) { + public List>> multiSearchForPage(List queries, Class clazz, + IndexCoordinates index) { MultiSearchRequest request = new MultiSearchRequest(); for (Query query : queries) { request.add(requestFactory.searchRequest(query, clazz, index)); @@ -126,7 +128,8 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper } @Override - public List> queryForPage(List queries, List> classes, IndexCoordinates index) { + public List>> multiSearchForPage(List queries, + List> classes, IndexCoordinates index) { MultiSearchRequest request = new MultiSearchRequest(); Iterator> it = classes.iterator(); for (Query query : queries) { @@ -135,9 +138,10 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper return doMultiSearch(queries, classes, request); } - private List> doMultiSearch(List queries, Class clazz, MultiSearchRequest request) { + private List>> doMultiSearch(List queries, Class clazz, + MultiSearchRequest request) { MultiSearchResponse.Item[] items = getMultiSearchResult(request); - List> res = new ArrayList<>(queries.size()); + List>> res = new ArrayList<>(queries.size()); int c = 0; for (Query query : queries) { res.add(elasticsearchConverter.mapResults(SearchDocumentResponse.from(items[c++].getResponse()), clazz, @@ -146,10 +150,10 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper return res; } - private List> doMultiSearch(List queries, List> classes, - MultiSearchRequest request) { + private List>> doMultiSearch(List queries, + List> classes, MultiSearchRequest request) { MultiSearchResponse.Item[] items = getMultiSearchResult(request); - List> res = new ArrayList<>(queries.size()); + List>> res = new ArrayList<>(queries.size()); int c = 0; Iterator> it = classes.iterator(); for (Query query : queries) { @@ -160,17 +164,6 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper } abstract protected MultiSearchResponse.Item[] getMultiSearchResult(MultiSearchRequest request); - - protected List extractIds(SearchResponse response) { - List ids = new ArrayList<>(); - for (SearchHit hit : response.getHits()) { - if (hit != null) { - ids.add(hit.getId()); - } - } - return ids; - } - // endregion // region Helper methods @@ -195,7 +188,7 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper public abstract SearchResponse suggest(SuggestBuilder suggestion, IndexCoordinates index); /** - * @param clazz + * @param clazz the entity class * @return the IndexCoordinates defined on the entity. * @since 4.0 */ diff --git a/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchRestTemplate.java b/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchRestTemplate.java index 275b49492..29c51ba63 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchRestTemplate.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchRestTemplate.java @@ -238,7 +238,7 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate { } @Override - public AggregatedPage queryForPage(Query query, Class clazz, IndexCoordinates index) { + public AggregatedPage> searchForPage(Query query, Class clazz, IndexCoordinates index) { SearchRequest searchRequest = requestFactory.searchRequest(query, clazz, index); SearchResponse response; try { @@ -250,18 +250,8 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate { } @Override - public List queryForIds(Query query, Class clazz, IndexCoordinates index) { - SearchRequest searchRequest = requestFactory.searchRequest(query, clazz, index); - try { - SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT); - return extractIds(response); - } catch (IOException e) { - throw new ElasticsearchException("Error for search request: " + searchRequest.toString(), e); - } - } - - @Override - public ScrolledPage startScroll(long scrollTimeInMillis, Query query, Class clazz, IndexCoordinates index) { + public ScrolledPage> searchScrollStart(long scrollTimeInMillis, Query query, Class clazz, + IndexCoordinates index) { Assert.notNull(query.getPageable(), "Query.pageable is required for scan & scroll"); @@ -276,7 +266,9 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate { } } - public ScrolledPage continueScroll(@Nullable String scrollId, long scrollTimeInMillis, Class clazz) { + @Override + public ScrolledPage> searchScrollContinue(@Nullable String scrollId, long scrollTimeInMillis, + Class clazz) { SearchScrollRequest request = new SearchScrollRequest(scrollId); request.scroll(TimeValue.timeValueMillis(scrollTimeInMillis)); SearchResponse response; @@ -289,7 +281,7 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate { } @Override - public void clearScroll(String scrollId) { + public void searchScrollClear(String scrollId) { ClearScrollRequest request = new ClearScrollRequest(); request.addScrollId(scrollId); try { diff --git a/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplate.java b/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplate.java index 65a384cd8..03499348f 100755 --- a/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplate.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplate.java @@ -203,21 +203,15 @@ public class ElasticsearchTemplate extends AbstractElasticsearchTemplate { } @Override - public AggregatedPage queryForPage(Query query, Class clazz, IndexCoordinates index) { + public AggregatedPage> searchForPage(Query query, Class clazz, IndexCoordinates index) { SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, clazz, index); SearchResponse response = getSearchResponse(searchRequestBuilder); return elasticsearchConverter.mapResults(SearchDocumentResponse.from(response), clazz, query.getPageable()); } @Override - public List queryForIds(Query query, Class clazz, IndexCoordinates index) { - SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, clazz, index); - SearchResponse response = getSearchResponse(searchRequestBuilder); - return extractIds(response); - } - - @Override - public ScrolledPage startScroll(long scrollTimeInMillis, Query query, Class clazz, IndexCoordinates index) { + public ScrolledPage> searchScrollStart(long scrollTimeInMillis, Query query, Class clazz, + IndexCoordinates index) { Assert.notNull(query.getPageable(), "Query.pageable is required for scan & scroll"); SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, clazz, index); @@ -227,14 +221,15 @@ public class ElasticsearchTemplate extends AbstractElasticsearchTemplate { } @Override - public ScrolledPage continueScroll(@Nullable String scrollId, long scrollTimeInMillis, Class clazz) { + public ScrolledPage> searchScrollContinue(@Nullable String scrollId, long scrollTimeInMillis, + Class clazz) { SearchResponse response = getSearchResponseWithTimeout( client.prepareSearchScroll(scrollId).setScroll(TimeValue.timeValueMillis(scrollTimeInMillis)).execute()); return elasticsearchConverter.mapResults(SearchDocumentResponse.from(response), clazz, Pageable.unpaged()); } @Override - public void clearScroll(String scrollId) { + public void searchScrollClear(String scrollId) { client.prepareClearScroll().addScrollId(scrollId).execute().actionGet(); } diff --git a/src/main/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplate.java b/src/main/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplate.java index 8c308d43c..8c234a8ee 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplate.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplate.java @@ -17,7 +17,6 @@ package org.springframework.data.elasticsearch.core; import static org.elasticsearch.index.VersionType.*; -import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @@ -41,7 +40,6 @@ import org.elasticsearch.index.query.QueryBuilders; import org.elasticsearch.index.query.WrapperQueryBuilder; import org.elasticsearch.index.reindex.BulkByScrollResponse; import org.elasticsearch.index.reindex.DeleteByQueryRequest; -import org.elasticsearch.search.SearchHit; import org.elasticsearch.search.builder.SearchSourceBuilder; import org.elasticsearch.search.sort.FieldSortBuilder; import org.elasticsearch.search.sort.SortBuilders; @@ -57,8 +55,10 @@ import org.springframework.data.elasticsearch.core.EntityOperations.Entity; import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter; import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter; import org.springframework.data.elasticsearch.core.document.DocumentAdapters; +import org.springframework.data.elasticsearch.core.document.SearchDocument; import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity; import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty; +import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext; import org.springframework.data.elasticsearch.core.query.CriteriaQuery; import org.springframework.data.elasticsearch.core.query.NativeSearchQuery; @@ -417,22 +417,18 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera // endregion // region SearchOperations - /* - * (non-Javadoc) - * @see org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations#find(Query, Class, Class, IndexCoordinates) - */ @Override - public Flux find(Query query, Class entityType, Class resultType, IndexCoordinates index) { + public Flux> search(Query query, Class entityType, Class resultType, IndexCoordinates index) { - return doFind(query, entityType, index).map(it -> converter.mapDocument(DocumentAdapters.from(it), resultType)); + return doFind(query, entityType, index).map(searchDocument -> converter.read(resultType, searchDocument)); } @Override - public Flux find(Query query, Class entityType, Class returnType) { - return find(query, entityType, returnType, getIndexCoordinatesFor(entityType)); + public Flux> search(Query query, Class entityType, Class returnType) { + return search(query, entityType, returnType, getIndexCoordinatesFor(entityType)); } - private Flux doFind(Query query, Class clazz, IndexCoordinates index) { + private Flux doFind(Query query, Class clazz, IndexCoordinates index) { return Flux.defer(() -> { SearchRequest request = requestFactory.searchRequest(query, clazz, index); @@ -510,15 +506,15 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera * Customization hook on the actual execution result {@link Publisher}.
* * @param request the already prepared {@link SearchRequest} ready to be executed. - * @return a {@link Flux} emitting the result of the operation. + * @return a {@link Flux} emitting the result of the operation converted to {@link SearchDocument}s. */ - protected Flux doFind(SearchRequest request) { + protected Flux doFind(SearchRequest request) { if (QUERY_LOGGER.isDebugEnabled()) { QUERY_LOGGER.debug("Executing doFind: {}", request); } - return Flux.from(execute(client -> client.search(request))) // + return Flux.from(execute(client -> client.search(request))).map(DocumentAdapters::from) // .onErrorResume(NoSuchIndexException.class, it -> Mono.empty()); } @@ -542,16 +538,16 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera * Customization hook on the actual execution result {@link Publisher}.
* * @param request the already prepared {@link SearchRequest} ready to be executed. - * @return a {@link Flux} emitting the result of the operation. + * @return a {@link Flux} emitting the result of the operation converted to {@link SearchDocument}s. */ - protected Flux doScroll(SearchRequest request) { + protected Flux doScroll(SearchRequest request) { if (QUERY_LOGGER.isDebugEnabled()) { QUERY_LOGGER.debug("Executing doScroll: {}", request); } return Flux.from(execute(client -> client.scroll(request))) // - .onErrorResume(NoSuchIndexException.class, it -> Mono.empty()); + .map(DocumentAdapters::from).onErrorResume(NoSuchIndexException.class, it -> Mono.empty()); } @Nullable diff --git a/src/main/java/org/springframework/data/elasticsearch/core/ReactiveSearchOperations.java b/src/main/java/org/springframework/data/elasticsearch/core/ReactiveSearchOperations.java index dabc23097..2177ae8c9 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/ReactiveSearchOperations.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/ReactiveSearchOperations.java @@ -15,12 +15,12 @@ */ package org.springframework.data.elasticsearch.core; -import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import org.elasticsearch.index.query.QueryBuilders; import org.springframework.data.domain.Pageable; +import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.Query; import org.springframework.data.elasticsearch.core.query.StringQuery; @@ -42,8 +42,10 @@ public interface ReactiveSearchOperations { * @param query must not be {@literal null}. * @param entityType must not be {@literal null}. * @param - * @return a {@link Flux} emitting matching entities one by one. + * @return a {@link Flux} emitting matching entities one by one wrapped in a {@link SearchHit}. + * @deprecated since 4.0, use {@link #search(Query, Class)}. */ + @Deprecated default Flux find(Query query, Class entityType) { return find(query, entityType, entityType); } @@ -58,21 +60,12 @@ public interface ReactiveSearchOperations { * @param entityType The entity type for mapping the query. Must not be {@literal null}. * @param returnType The mapping target type. Must not be {@literal null}. Th * @param - * @return a {@link Flux} emitting matching entities one by one. + * @return a {@link Flux} emitting matching entities one by one wrapped in a {@link SearchHit}. + * @deprecated since 4.0, use {@link #search(Query, Class, Class)}. */ - Flux find(Query query, Class entityType, Class returnType); - - /** - * Search the index for entities matching the given {@link Query query}. - * - * @param query must not be {@literal null}. - * @param entityType must not be {@literal null}. - * @param index the target index, must not be {@literal null} - * @param - * @returnm a {@link Flux} emitting matching entities one by one. - */ - default Flux find(Query query, Class entityType, IndexCoordinates index) { - return find(query, entityType, entityType, index); + @Deprecated + default Flux find(Query query, Class entityType, Class returnType) { + return search(query, entityType, returnType).map(SearchHit::getContent); } /** @@ -80,12 +73,32 @@ public interface ReactiveSearchOperations { * * @param query must not be {@literal null}. * @param entityType must not be {@literal null}. + * @param index the target index, must not be {@literal null} + * @param + * @return a {@link Flux} emitting matching entities one by one wrapped in a {@link SearchHit}. + * @deprecated since 4.0, use {@link #search(Query, Class, IndexCoordinates)} + */ + @Deprecated + default Flux find(Query query, Class entityType, IndexCoordinates index) { + return find(query, entityType, entityType, index); + } + + /** + * Search the index for entities matching the given {@link Query query}. + * + * @param + * @param query must not be {@literal null}. + * @param entityType must not be {@literal null}. * @param resultType the projection result type. * @param index the target index, must not be {@literal null} * @param - * @return a {@link Flux} emitting matching entities one by one. + * @return a {@link Flux} emitting matching entities one by one wrapped in a {@link SearchHit}. + * @deprecated since 4.0, use {@link #search(Query, Class, Class, IndexCoordinates)}. */ - Flux find(Query query, Class entityType, Class resultType, IndexCoordinates index); + @Deprecated + default Flux find(Query query, Class entityType, Class resultType, IndexCoordinates index) { + return search(query, entityType, resultType, index).map(SearchHit::getContent); + } /** * Count the number of documents matching the given {@link Query}. @@ -116,4 +129,58 @@ public interface ReactiveSearchOperations { */ Mono count(Query query, Class entityType, IndexCoordinates index); + /** + * Search the index for entities matching the given {@link Query query}.
+ * {@link Pageable#isUnpaged() Unpaged} queries may overrule elasticsearch server defaults for page size by either * + * delegating to the scroll API or using a max {@link org.elasticsearch.search.builder.SearchSourceBuilder#size(int) * + * size}. + * + * @param query must not be {@literal null}. + * @param entityType The entity type for mapping the query. Must not be {@literal null}. + * @param returnType The mapping target type. Must not be {@literal null}. Th + * @param + * @return a {@link Flux} emitting matching entities one by one wrapped in a {@link SearchHit}. + */ + Flux> search(Query query, Class entityType, Class returnType); + + /** + * Search the index for entities matching the given {@link Query query}.
+ * {@link Pageable#isUnpaged() Unpaged} queries may overrule elasticsearch server defaults for page size by either + * delegating to the scroll API or using a max {@link org.elasticsearch.search.builder.SearchSourceBuilder#size(int) + * size}. + * + * @param query must not be {@literal null}. + * @param entityType must not be {@literal null}. + * @param + * @return a {@link Flux} emitting matching entities one by one wrapped in a {@link SearchHit}. + */ + default Flux> search(Query query, Class entityType) { + return search(query, entityType, entityType); + } + + /** + * Search the index for entities matching the given {@link Query query}. + * + * @param + * @param query must not be {@literal null}. + * @param entityType must not be {@literal null}. + * @param resultType the projection result type. + * @param index the target index, must not be {@literal null} + * @param + * @return a {@link Flux} emitting matching entities one by one wrapped in a {@link SearchHit}. + */ + Flux> search(Query query, Class entityType, Class resultType, IndexCoordinates index); + + /** + * Search the index for entities matching the given {@link Query query}. + * + * @param query must not be {@literal null}. + * @param entityType must not be {@literal null}. + * @param index the target index, must not be {@literal null} + * @param + * @return a {@link Flux} emitting matching entities one by one wrapped in a {@link SearchHit}. + */ + default Flux> search(Query query, Class entityType, IndexCoordinates index) { + return search(query, entityType, entityType, index); + } } diff --git a/src/main/java/org/springframework/data/elasticsearch/core/SearchHit.java b/src/main/java/org/springframework/data/elasticsearch/core/SearchHit.java new file mode 100644 index 000000000..b84b5843f --- /dev/null +++ b/src/main/java/org/springframework/data/elasticsearch/core/SearchHit.java @@ -0,0 +1,66 @@ +/* + * Copyright 2019 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.elasticsearch.core; + +import org.springframework.lang.Nullable; + +/** + * Encapsulates the found data with additional information from the search. + * + * @param the result data class. + * @author Peter-Josef Meisch + * @since 4.0 + */ +public class SearchHit { + + private final String id; + private final float score; + private final T content; + + public SearchHit(@Nullable String id, float score, T content) { + this.id = id; + this.score = score; + this.content = content; + } + + @Nullable + public String getId() { + return id; + } + + /** + * @return the score for the hit. + */ + public float getScore() { + return score; + } + + /** + * @return the object data from the search. + */ + public T getContent() { + return content; + } + + @Override + public String toString() { + return "SearchHit{" + + "id='" + id + '\'' + + ", score=" + score + + ", content=" + content + + '}'; + } +} diff --git a/src/main/java/org/springframework/data/elasticsearch/core/SearchHitSupport.java b/src/main/java/org/springframework/data/elasticsearch/core/SearchHitSupport.java new file mode 100644 index 000000000..44854e460 --- /dev/null +++ b/src/main/java/org/springframework/data/elasticsearch/core/SearchHitSupport.java @@ -0,0 +1,84 @@ +/* + * Copyright 2019 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.elasticsearch.core; + +import reactor.core.publisher.Flux; + +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage; +import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl; + +/** + * Utility class with helper methods for working with {@link SearchHit}. + * + * @author Peter-Josef Meisch + * @since 4.0 + */ +public final class SearchHitSupport { + + private SearchHitSupport() {} + + /** + * unwraps the data contained in a SearchHit for different types containing SearchHits if possible + * + * @param result the object, list, page or whatever containing SearchHit objects + * @return a corresponding object where the SearchHits are replaced by their content if possible, otherwise the + * original object + */ + public static Object unwrapSearchHits(Object result) { + + if (result == null) { + return result; + } + + if (result instanceof SearchHit) { + return ((SearchHit) result).getContent(); + } + + if (result instanceof List) { + return ((List) result).stream() // + .map(SearchHitSupport::unwrapSearchHits) // + .collect(Collectors.toList()); + } + + if (result instanceof AggregatedPage) { + AggregatedPage page = (AggregatedPage) result; + List list = page.getContent().stream().map(o -> unwrapSearchHits(o)).collect(Collectors.toList()); + return new AggregatedPageImpl<>(list, null, page.getTotalElements(), page.getAggregations(), page.getScrollId(), + page.getMaxScore()); + + } + + if (result instanceof Stream) { + return ((Stream) result).map(SearchHitSupport::unwrapSearchHits); + } + + if (result instanceof SearchHits) { + SearchHits searchHits = (SearchHits) result; + return unwrapSearchHits(searchHits.getSearchHits()); + } + + if (result instanceof Flux) { + Flux flux = (Flux) result; + return flux.map(SearchHitSupport::unwrapSearchHits); + } + + return result; + } +} diff --git a/src/main/java/org/springframework/data/elasticsearch/core/SearchHits.java b/src/main/java/org/springframework/data/elasticsearch/core/SearchHits.java new file mode 100644 index 000000000..ec36780af --- /dev/null +++ b/src/main/java/org/springframework/data/elasticsearch/core/SearchHits.java @@ -0,0 +1,92 @@ +/* + * Copyright 2019 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.elasticsearch.core; + +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.stream.Stream; + +import org.springframework.data.util.Streamable; +import org.springframework.util.Assert; +import org.springframework.util.StringUtils; + +/** + * Encapsulates a list of {@link SearchHit}s with additional information from the search. + * + * @param the result data class. + * @author Peter-Josef Meisch + * @since 4.0 + */ +public class SearchHits implements Streamable> { + + private final List> searchHits; + private final long totalHits; + private final float maxScore; + + /** + * @param searchHits must not be {@literal null} + * @param totalHits + * @param maxScore + */ + public SearchHits(List> searchHits, long totalHits, float maxScore) { + this.totalHits = totalHits; + this.maxScore = maxScore; + + Assert.notNull(searchHits, "searchHits must not be null"); + + this.searchHits = searchHits; + } + + @Override + public Iterator> iterator() { + return (Iterator>) searchHits.iterator(); + } + + // region getter + /** + * @return the contained {@link SearchHit}s. + */ + public List> getSearchHits() { + return Collections.unmodifiableList(searchHits); + } + + public long getTotalHits() { + return totalHits; + } + + public float getMaxScore() { + return maxScore; + } + // endregion + + // region SearchHit access + /** + * @param index position in List. + * @return the {@link SearchHit} at position {index} + * @throws IndexOutOfBoundsException on invalid index + */ + public SearchHit getSearchHit(int index) { + return searchHits.get(index); + } + // endregion + + @Override + public String toString() { + return "SearchHits{" + "totalHits=" + totalHits + ", maxScore=" + maxScore + ", searchHits=" + + StringUtils.collectionToCommaDelimitedString(searchHits) + '}'; + } +} diff --git a/src/main/java/org/springframework/data/elasticsearch/core/SearchOperations.java b/src/main/java/org/springframework/data/elasticsearch/core/SearchOperations.java index 14a4d18d6..e47981111 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/SearchOperations.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/SearchOperations.java @@ -15,6 +15,7 @@ */ package org.springframework.data.elasticsearch.core; +import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; @@ -67,10 +68,11 @@ public interface SearchOperations { * @param clazz the entity clazz used for property mapping * @param index the index to run the query against * @return the first matching object + * @deprecated since 4.0, use {@link #searchOne(Query, Class, IndexCoordinates)}. */ + @Deprecated default T queryForObject(Query query, Class clazz, IndexCoordinates index) { - List content = queryForPage(query, clazz, index).getContent(); - return content.isEmpty() ? null : content.get(0); + return (T) SearchHitSupport.unwrapSearchHits(searchOne(query, clazz, index)); } /** @@ -80,8 +82,12 @@ public interface SearchOperations { * @param clazz the entity clazz used for property mapping * @param index the index to run the query against * @return a page with aggregations + * @deprecated since 4.0, use {@link #searchForPage(Query, Class, IndexCoordinates)}. */ - AggregatedPage queryForPage(Query query, Class clazz, IndexCoordinates index); + @Deprecated + default AggregatedPage queryForPage(Query query, Class clazz, IndexCoordinates index) { + return (AggregatedPage) SearchHitSupport.unwrapSearchHits(searchForPage(query, clazz, index)); + } /** * Execute the multi-search against elasticsearch and return result as {@link List} of {@link Page} @@ -90,8 +96,14 @@ public interface SearchOperations { * @param clazz the entity clazz used for property mapping * @param index the index to run the query against * @return list of pages with the results + * @deprecated since 4.0, use {@link #multiSearchForPage(List, Class, IndexCoordinates)}. */ - List> queryForPage(List queries, Class clazz, IndexCoordinates index); + @Deprecated + default List> queryForPage(List queries, Class clazz, IndexCoordinates index) { + return multiSearchForPage(queries, clazz, index).stream() // + .map(page -> (Page) SearchHitSupport.unwrapSearchHits(page)) // + .collect(Collectors.toList()); + } /** * Execute the multi-search against elasticsearch and return result as {@link List} of {@link Page} @@ -100,8 +112,279 @@ public interface SearchOperations { * @param classes the entity classes used for the queries * @param index the index to run the query against * @return list of pages with the results + * @deprecated since 4.0, use {@link #multiSearchForPage(List, List, IndexCoordinates)}. */ - List> queryForPage(List queries, List> classes, IndexCoordinates index); + @Deprecated + default List> queryForPage(List queries, List> classes, + IndexCoordinates index) { + return multiSearchForPage(queries, classes, index).stream() // + .map(page -> (AggregatedPage) SearchHitSupport.unwrapSearchHits(page)) // + .collect(Collectors.toList()); + } + + /** + * Executes the given {@link Query} against elasticsearch and return result as {@link CloseableIterator}. + *

+ * + * @param element return type + * @param query the query to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return a {@link CloseableIterator} that wraps an Elasticsearch scroll context that needs to be closed in case of * + * error. + * @deprecated since 4.0, use {@link #searchForStream(Query, Class, IndexCoordinates)}. + */ + @Deprecated + CloseableIterator stream(Query query, Class clazz, IndexCoordinates index); + + /** + * Execute the criteria query against elasticsearch and return result as {@link List} + * + * @param element return type + * @param query the query to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return list of found objects + * @deprecated since 4.0, use {@link #search(Query, Class, IndexCoordinates)}. + */ + @Deprecated + default List queryForList(Query query, Class clazz, IndexCoordinates index) { + return (List) SearchHitSupport.unwrapSearchHits(search(query, clazz, index)); + } + + /** + * Execute the multi search query against elasticsearch and return result as {@link List} + * + * @param queries the queries to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @param element return type + * @return list of found objects + * @deprecated since 4.0, use {@link #multiSearch(List, Class, IndexCoordinates)}. + */ + @Deprecated + default List> queryForList(List queries, Class clazz, IndexCoordinates index) { + return queryForPage(queries, clazz, index).stream().map(Page::getContent).collect(Collectors.toList()); + } + + /** + * Execute the multi search query against elasticsearch and return result as {@link List} + * + * @param queries the queries to execute + * @param classes the entity classes used for property mapping + * @param index the index to run the query against + * @return list of list of found objects + * @deprecated since 4.0, use {@link #multiSearch(List, List, IndexCoordinates)}. + */ + @Deprecated + default List> queryForList(List queries, List> classes, IndexCoordinates index) { + return queryForPage(queries, classes, index).stream().map(Page::getContent).collect(Collectors.toList()); + } + + /** + * Execute the query against elasticsearch and return ids + * + * @param query the query to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return list of found object ids + * @deprecated since 4.0 use {@link #search(Query, Class, IndexCoordinates)} and map the results. + */ + @Deprecated + default List queryForIds(Query query, Class clazz, IndexCoordinates index) { + return search(query, clazz, index).map(SearchHit::getId).toList(); + } + + /** + * Returns scrolled page for given query + * + * @param scrollTimeInMillis duration of the scroll time + * @param query The search query. + * @param clazz The class of entity to retrieve. + * @param index the index to run the query against + * @return scrolled page result + * @deprecated since 4.0, use {@link #searchScrollStart(long, Query, Class, IndexCoordinates)}. + */ + @Deprecated + default ScrolledPage startScroll(long scrollTimeInMillis, Query query, Class clazz, + IndexCoordinates index) { + return (ScrolledPage) SearchHitSupport + .unwrapSearchHits(searchScrollStart(scrollTimeInMillis, query, clazz, index)); + } + + /** + * Returns next scrolled page. + * + * @param scrollId the scroll id + * @param scrollTimeInMillis duration of the scroll time + * @param clazz The class of entity to retrieve. + * @return scrolled page result + * @deprecated since 4.0, use {@link #searchScrollStart(long, Query, Class, IndexCoordinates)}. + */ + @Deprecated + default ScrolledPage continueScroll(@Nullable String scrollId, long scrollTimeInMillis, Class clazz) { + return (ScrolledPage) SearchHitSupport + .unwrapSearchHits(searchScrollContinue(scrollId, scrollTimeInMillis, clazz)); + } + + /** + * Clears the search contexts associated with specified scroll ids. + * + * @param scrollId the scroll id + * @deprecated since 4.0, use {@link #searchScrollClear(String)}. + */ + @Deprecated + default void clearScroll(String scrollId) { + searchScrollClear(scrollId); + } + + /** + * more like this query to search for documents that are "like" a specific document. + * + * @param element return type + * @param query the query to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return page with the results + * @deprecated since 4.0, use {@link #search(MoreLikeThisQuery, Class, IndexCoordinates)}. + */ + @Deprecated + default AggregatedPage moreLikeThis(MoreLikeThisQuery query, Class clazz, IndexCoordinates index) { + return (AggregatedPage) SearchHitSupport.unwrapSearchHits(search(query, clazz, index)); + } + + /** + * Execute the query against elasticsearch and return the first returned object. + * + * @param query the query to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return the first found object + */ + @Nullable + default SearchHit searchOne(Query query, Class clazz, IndexCoordinates index) { + List> content = searchForPage(query, clazz, index).getContent(); + return content.isEmpty() ? null : content.get(0); + } + + /** + * Execute the query against elasticsearch and return result as {@link AggregatedPage}. + * + * @param query the query to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return a page with aggregations + */ + AggregatedPage> searchForPage(Query query, Class clazz, IndexCoordinates index); + + /** + * Execute the multi-search against elasticsearch and return result as {@link List} of {@link AggregatedPage} + * + * @param queries the queries + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return list of pages with the results + */ + List>> multiSearchForPage(List queries, Class clazz, + IndexCoordinates index); + + /** + * Execute the multi-search against elasticsearch and return result as {@link List} of {@link AggregatedPage} + * + * @param queries the queries + * @param classes the entity classes used for the queries + * @param index the index to run the query against + * @return list of pages with the results + */ + List>> multiSearchForPage(List queries, List> classes, + IndexCoordinates index); + + /** + * Execute the criteria query against elasticsearch and return result as {@link SearchHits} + * + * @param element return type + * @param query the query to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return SearchHits containing the list of found objects + */ + default SearchHits search(Query query, Class clazz, IndexCoordinates index) { + AggregatedPage> aggregatedPage = searchForPage(query, clazz, index); + return new SearchHits<>(aggregatedPage.getContent(), aggregatedPage.getTotalElements(), + aggregatedPage.getMaxScore()); + } + + /** + * Execute the multi search query against elasticsearch and return result as {@link List} of {@link SearchHits}. + * + * @param queries the queries to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @param element return type + * @return list of SearchHits + */ + default List> multiSearch(List queries, Class clazz, IndexCoordinates index) { + return multiSearchForPage(queries, clazz, index).stream() + .map(page -> new SearchHits(page.getContent(), page.getTotalElements(), page.getMaxScore())) + .collect(Collectors.toList()); + } + + /** + * Execute the multi search query against elasticsearch and return result as {@link List} of {@link SearchHits}. + * + * @param queries the queries to execute + * @param classes the entity classes used for property mapping + * @param index the index to run the query against + * @return list of SearchHits + */ + default List> multiSearch(List queries, List> classes, IndexCoordinates index) { + List> searchHitsList = new ArrayList<>(); + multiSearchForPage(queries, classes, index).forEach(page -> { + searchHitsList.add(new SearchHits(page.getContent(), page.getTotalElements(), page.getMaxScore())); + }); + return searchHitsList; + } + + /** + * more like this query to search for documents that are "like" a specific document. + * + * @param element return type + * @param query the query to execute + * @param clazz the entity clazz used for property mapping + * @param index the index to run the query against + * @return page with the results + */ + AggregatedPage> search(MoreLikeThisQuery query, Class clazz, IndexCoordinates index); + + /** + * Returns scrolled page for given query + * + * @param scrollTimeInMillis duration of the scroll time + * @param query The search query. + * @param clazz The class of entity to retrieve. + * @param index the index to run the query against + * @return scrolled page result + */ + ScrolledPage> searchScrollStart(long scrollTimeInMillis, Query query, Class clazz, + IndexCoordinates index); + + /** + * Returns next scrolled page + * + * @param scrollId the scroll id + * @param scrollTimeInMillis duration of the scroll time + * @param clazz The class of entity to retrieve. + * @return scrolled page result + */ + ScrolledPage> searchScrollContinue(@Nullable String scrollId, long scrollTimeInMillis, + Class clazz); + + /** + * Clears the search contexts associated with specified scroll ids. + * + * @param scrollId the scroll id + */ + void searchScrollClear(String scrollId); /** * Executes the given {@link Query} against elasticsearch and return result as {@link CloseableIterator}. @@ -114,88 +397,11 @@ public interface SearchOperations { * @return a {@link CloseableIterator} that wraps an Elasticsearch scroll context that needs to be closed in case of * * error. */ - CloseableIterator stream(Query query, Class clazz, IndexCoordinates index); - - /** - * Execute the criteria query against elasticsearch and return result as {@link List} - * - * @param query the query to execute - * @param clazz the entity clazz used for property mapping - * @param index the index to run the query against - * @param element return type - * @return list of found objects - */ - List queryForList(Query query, Class clazz, IndexCoordinates index); - - /** - * Execute the multi search query against elasticsearch and return result as {@link List} - * - * @param queries the queries to execute - * @param clazz the entity clazz used for property mapping - * @param index the index to run the query against - * @param element return type - * @return list of found objects - */ - default List> queryForList(List queries, Class clazz, IndexCoordinates index) { - return queryForPage(queries, clazz, index).stream().map(Page::getContent).collect(Collectors.toList()); - } - - /** - * Execute the multi search query against elasticsearch and return result as {@link List} - * - * @param queries the queries to execute - * @param classes the entity classes used for property mapping - * @param index the index to run the query against - * @return list of list of found objects - */ - default List> queryForList(List queries, List> classes, IndexCoordinates index) { - return queryForPage(queries, classes, index).stream().map(Page::getContent).collect(Collectors.toList()); - } - - /** - * Execute the query against elasticsearch and return ids - * - * @param query the query to execute - * @param clazz the entity clazz used for property mapping - * @param index the index to run the query against - * @return list of found object ids - */ - List queryForIds(Query query, Class clazz, IndexCoordinates index); - - /** - * Returns scrolled page for given query - * - * @param scrollTimeInMillis duration of the scroll time - * @param query The search query. - * @param clazz The class of entity to retrieve. - * @param index the index to run the query against - * @return scrolled page result - */ - ScrolledPage startScroll(long scrollTimeInMillis, Query query, Class clazz, IndexCoordinates index); - - ScrolledPage continueScroll(@Nullable String scrollId, long scrollTimeInMillis, Class clazz); - - /** - * Clears the search contexts associated with specified scroll ids. - * - * @param scrollId the scroll id - */ - void clearScroll(String scrollId); - - /** - * more like this query to search for documents that are "like" a specific document. - * - * @param query the query to execute - * @param clazz the entity clazz used for property mapping - * @param index the index to run the query against - * @param element return type - * @return page with the results - */ - Page moreLikeThis(MoreLikeThisQuery query, Class clazz, IndexCoordinates index); + CloseableIterator> searchForStream(Query query, Class clazz, IndexCoordinates index); /** * Does a suggest query - * + * * @param suggestion the query * @param index the index to run the query against * @return the suggest response diff --git a/src/main/java/org/springframework/data/elasticsearch/core/aggregation/impl/AggregatedPageImpl.java b/src/main/java/org/springframework/data/elasticsearch/core/aggregation/impl/AggregatedPageImpl.java index 5250bdc1d..01da64509 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/aggregation/impl/AggregatedPageImpl.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/aggregation/impl/AggregatedPageImpl.java @@ -87,25 +87,25 @@ public class AggregatedPageImpl extends PageImpl implements AggregatedPage } public AggregatedPageImpl(List content, Pageable pageable, long total, Aggregations aggregations, float maxScore) { - this(content, pageable, total, aggregations); + this(content, pageableOrUnpaged(pageable), total, aggregations); this.maxScore = maxScore; } public AggregatedPageImpl(List content, Pageable pageable, long total, Aggregations aggregations, String scrollId) { - this(content, pageable, total, aggregations); + this(content, pageableOrUnpaged(pageable), total, aggregations); this.scrollId = scrollId; } public AggregatedPageImpl(List content, Pageable pageable, long total, Aggregations aggregations, String scrollId, float maxScore) { - this(content, pageable, total, aggregations, scrollId); + this(content, pageableOrUnpaged(pageable), total, aggregations, scrollId); this.maxScore = maxScore; } public AggregatedPageImpl(List content, Pageable pageable, SearchDocumentResponse response) { - this(content, pageable, response.getTotalHits(), response.getAggregations(), response.getScrollId(), - response.getMaxScore()); + this(content, pageableOrUnpaged(pageable), response.getTotalHits(), response.getAggregations(), + response.getScrollId(), response.getMaxScore()); } @Override diff --git a/src/main/java/org/springframework/data/elasticsearch/core/convert/ElasticsearchConverter.java b/src/main/java/org/springframework/data/elasticsearch/core/convert/ElasticsearchConverter.java index 9d2074e6a..216e376fe 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/convert/ElasticsearchConverter.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/convert/ElasticsearchConverter.java @@ -19,8 +19,10 @@ import java.util.List; import org.springframework.data.convert.EntityConverter; import org.springframework.data.domain.Pageable; +import org.springframework.data.elasticsearch.core.SearchHit; import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage; import org.springframework.data.elasticsearch.core.document.Document; +import org.springframework.data.elasticsearch.core.document.SearchDocument; import org.springframework.data.elasticsearch.core.document.SearchDocumentResponse; import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity; import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty; @@ -57,7 +59,8 @@ public interface ElasticsearchConverter return getConversionService().convert(idValue, String.class); } - AggregatedPage mapResults(SearchDocumentResponse response, Class clazz, Pageable pageable); + AggregatedPage> mapResults(SearchDocumentResponse response, Class clazz, + @Nullable Pageable pageable); /** * Get the configured {@link ProjectionFactory}.
@@ -72,14 +75,25 @@ public interface ElasticsearchConverter /** * Map a single {@link Document} to an instance of the given type. * - * @param document must not be {@literal null}. + * @param document the document to map * @param type must not be {@literal null}. * @param - * @return can be {@literal null} if the {@link Document#isEmpty()} is true. + * @return can be {@literal null} if the document is null or {@link Document#isEmpty()} is true. * @since 4.0 */ @Nullable - T mapDocument(Document document, Class type); + T mapDocument(@Nullable Document document, Class type); + + /** + * builds a {@link SearchHit} from a {@link SearchDocument}. + * + * @param searchDocument must not be {@literal null} + * @param the clazz of the type, must not be {@literal null}. + * @param type the type of the returned data, must not be {@literal null}. + * @return SearchHit with all available information filled in + * @since 4.0 + */ + SearchHit read(Class type, SearchDocument searchDocument); /** * Map a list of {@link Document}s to alist of instance of the given type. diff --git a/src/main/java/org/springframework/data/elasticsearch/core/convert/MappingElasticsearchConverter.java b/src/main/java/org/springframework/data/elasticsearch/core/convert/MappingElasticsearchConverter.java index 715f59d52..180034ba0 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/convert/MappingElasticsearchConverter.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/convert/MappingElasticsearchConverter.java @@ -17,17 +17,8 @@ package org.springframework.data.elasticsearch.core.convert; import lombok.RequiredArgsConstructor; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; +import java.util.*; import java.util.Map.Entry; -import java.util.Optional; -import java.util.Set; import java.util.stream.Collectors; import org.springframework.beans.BeansException; @@ -44,6 +35,7 @@ import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.domain.Pageable; import org.springframework.data.elasticsearch.ElasticsearchException; import org.springframework.data.elasticsearch.annotations.ScriptedField; +import org.springframework.data.elasticsearch.core.SearchHit; import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage; import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl; import org.springframework.data.elasticsearch.core.document.Document; @@ -588,7 +580,11 @@ public class MappingElasticsearchConverter @Override @Nullable - public T mapDocument(Document document, Class type) { + public T mapDocument(@Nullable Document document, Class type) { + + if (document == null) { + return null; + } Object mappedResult = read(type, document); @@ -601,6 +597,15 @@ public class MappingElasticsearchConverter : type.cast(mappedResult); } + @Override + public SearchHit read(Class type, SearchDocument searchDocument) { + String id = searchDocument.hasId() ? searchDocument.getId() : null; + float score = searchDocument.getScore(); + T content = mapDocument(searchDocument, type); + + return new SearchHit(id, score, content); + } + @Override public List mapDocuments(List documents, Class type) { return documents.stream().map(it -> mapDocument(it, type)).collect(Collectors.toList()); @@ -697,12 +702,14 @@ public class MappingElasticsearchConverter } @Override - public AggregatedPage mapResults(SearchDocumentResponse response, Class type, Pageable pageable) { + public AggregatedPage> mapResults(SearchDocumentResponse response, Class type, + Pageable pageable) { - List results = response.getSearchDocuments().stream() // - .map(searchDocument -> mapDocument(searchDocument, type)).collect(Collectors.toList()); + List> results = response.getSearchDocuments().stream() // + .map(searchDocument -> read(type, searchDocument)) // + .collect(Collectors.toList()); - return new AggregatedPageImpl(results, pageable, response); + return new AggregatedPageImpl<>(results, pageable, response); } private void populateScriptFields(T result, SearchDocument searchDocument) { diff --git a/src/main/java/org/springframework/data/elasticsearch/core/convert/package-info.java b/src/main/java/org/springframework/data/elasticsearch/core/convert/package-info.java new file mode 100644 index 000000000..baa01ef51 --- /dev/null +++ b/src/main/java/org/springframework/data/elasticsearch/core/convert/package-info.java @@ -0,0 +1,2 @@ +@org.springframework.lang.NonNullApi +package org.springframework.data.elasticsearch.core.convert; diff --git a/src/main/java/org/springframework/data/elasticsearch/core/document/SearchDocument.java b/src/main/java/org/springframework/data/elasticsearch/core/document/SearchDocument.java index c5fc6928f..8195015af 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/document/SearchDocument.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/document/SearchDocument.java @@ -19,7 +19,7 @@ import java.util.List; import java.util.Map; /** - * Extension to {@link Document} exposing a search {@link #getScore() score}. + * Extension to {@link Document} exposing a search response related data. * * @author Mark Paluch * @author Peter-Josef Meisch diff --git a/src/main/java/org/springframework/data/elasticsearch/repository/query/AbstractReactiveElasticsearchRepositoryQuery.java b/src/main/java/org/springframework/data/elasticsearch/repository/query/AbstractReactiveElasticsearchRepositoryQuery.java index f9303515f..d361d5708 100644 --- a/src/main/java/org/springframework/data/elasticsearch/repository/query/AbstractReactiveElasticsearchRepositoryQuery.java +++ b/src/main/java/org/springframework/data/elasticsearch/repository/query/AbstractReactiveElasticsearchRepositoryQuery.java @@ -20,10 +20,11 @@ import reactor.core.publisher.Mono; import org.reactivestreams.Publisher; import org.springframework.core.convert.converter.Converter; -import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations; +import org.springframework.data.elasticsearch.core.SearchHitSupport; import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity; import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty; +import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.Query; import org.springframework.data.elasticsearch.repository.query.ReactiveElasticsearchQueryExecution.ResultProcessingConverter; import org.springframework.data.elasticsearch.repository.query.ReactiveElasticsearchQueryExecution.ResultProcessingExecution; @@ -56,10 +57,12 @@ abstract class AbstractReactiveElasticsearchRepositoryQuery implements Repositor * (non-Javadoc) * @see org.springframework.data.repository.query.RepositoryQuery#execute(java.lang.Object[]) */ + @Override public Object execute(Object[] parameters) { - return queryMethod.hasReactiveWrapperParameter() ? executeDeferred(parameters) + Object result = queryMethod.hasReactiveWrapperParameter() ? executeDeferred(parameters) : execute(new ReactiveElasticsearchParametersParameterAccessor(queryMethod, parameters)); + return SearchHitSupport.unwrapSearchHits(result); } private Object executeDeferred(Object[] parameters) { @@ -116,10 +119,10 @@ abstract class AbstractReactiveElasticsearchRepositoryQuery implements Repositor return (query, type, targetType, indexCoordinates) -> operations.count(query, type, indexCoordinates) .map(count -> count > 0); } else if (queryMethod.isCollectionQuery()) { - return (query, type, targetType, indexCoordinates) -> operations.find(query.setPageable(accessor.getPageable()), + return (query, type, targetType, indexCoordinates) -> operations.search(query.setPageable(accessor.getPageable()), type, targetType, indexCoordinates); } else { - return (query, type, targetType, indexCoordinates) -> operations.find(query, type, targetType, indexCoordinates); + return (query, type, targetType, indexCoordinates) -> operations.search(query, type, targetType, indexCoordinates); } } diff --git a/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchPartQuery.java b/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchPartQuery.java index b0453adc4..a750e022d 100644 --- a/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchPartQuery.java +++ b/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchPartQuery.java @@ -17,14 +17,14 @@ package org.springframework.data.elasticsearch.repository.query; import org.springframework.data.domain.PageRequest; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; -import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; +import org.springframework.data.elasticsearch.core.SearchHitSupport; import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty; +import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.CriteriaQuery; import org.springframework.data.elasticsearch.repository.query.parser.ElasticsearchQueryCreator; import org.springframework.data.mapping.context.MappingContext; import org.springframework.data.repository.query.ParametersParameterAccessor; import org.springframework.data.repository.query.parser.PartTree; -import org.springframework.data.util.CloseableIterator; import org.springframework.data.util.StreamUtils; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; @@ -54,24 +54,24 @@ public class ElasticsearchPartQuery extends AbstractElasticsearchRepositoryQuery @Override public Object execute(Object[] parameters) { - ParametersParameterAccessor accessor = new ParametersParameterAccessor(queryMethod.getParameters(), parameters); CriteriaQuery query = createQuery(accessor); Assert.notNull(query, "unsupported query"); Class clazz = queryMethod.getEntityInformation().getJavaType(); IndexCoordinates index = elasticsearchOperations.getIndexCoordinatesFor(clazz); + Object result = null; + if (tree.isLimiting()) { query.setMaxResults(tree.getMaxResults()); } if (tree.isDelete()) { - Object result = countOrGetDocumentsForDelete(query, accessor); + result = countOrGetDocumentsForDelete(query, accessor); elasticsearchOperations.delete(query, clazz, index); - return result; } else if (queryMethod.isPageQuery()) { query.setPageable(accessor.getPageable()); - return elasticsearchOperations.queryForPage(query, clazz, index); + result = elasticsearchOperations.searchForPage(query, clazz, index); } else if (queryMethod.isStreamQuery()) { Class entityType = clazz; if (accessor.getPageable().isUnpaged()) { @@ -79,44 +79,41 @@ public class ElasticsearchPartQuery extends AbstractElasticsearchRepositoryQuery } else { query.setPageable(accessor.getPageable()); } - return StreamUtils - .createStreamFromIterator((CloseableIterator) elasticsearchOperations.stream(query, entityType, index)); + result = StreamUtils.createStreamFromIterator(elasticsearchOperations.stream(query, entityType, index)); } else if (queryMethod.isCollectionQuery()) { if (accessor.getPageable().isUnpaged()) { - - int itemCount = (int) elasticsearchOperations.count(query, clazz, - index); + int itemCount = (int) elasticsearchOperations.count(query, clazz, index); query.setPageable(PageRequest.of(0, Math.max(1, itemCount))); } else { query.setPageable(accessor.getPageable()); } - return elasticsearchOperations.queryForList(query, clazz, index); + result = elasticsearchOperations.search(query, clazz, index); } else if (tree.isCountProjection()) { - return elasticsearchOperations.count(query, clazz, index); + result = elasticsearchOperations.count(query, clazz, index); + } else { + result = elasticsearchOperations.searchOne(query, clazz, index); } - return elasticsearchOperations.queryForObject(query, clazz, index); + return SearchHitSupport.unwrapSearchHits(result); } private Object countOrGetDocumentsForDelete(CriteriaQuery query, ParametersParameterAccessor accessor) { Object result = null; Class clazz = queryMethod.getEntityInformation().getJavaType(); - IndexCoordinates index = elasticsearchOperations - .getIndexCoordinatesFor(clazz); + IndexCoordinates index = elasticsearchOperations.getIndexCoordinatesFor(clazz); if (queryMethod.isCollectionQuery()) { if (accessor.getPageable().isUnpaged()) { - int itemCount = (int) elasticsearchOperations.count(query, clazz, - index); + int itemCount = (int) elasticsearchOperations.count(query, clazz, index); query.setPageable(PageRequest.of(0, Math.max(1, itemCount))); } else { query.setPageable(accessor.getPageable()); } - result = elasticsearchOperations.queryForList(query, clazz, index); + result = elasticsearchOperations.search(query, clazz, index); } if (ClassUtils.isAssignable(Number.class, queryMethod.getReturnedObjectType())) { diff --git a/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchStringQuery.java b/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchStringQuery.java index ebbe03010..48a79e93d 100644 --- a/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchStringQuery.java +++ b/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchStringQuery.java @@ -20,8 +20,9 @@ import java.util.regex.Pattern; import org.springframework.core.convert.support.GenericConversionService; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; -import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; +import org.springframework.data.elasticsearch.core.SearchHitSupport; import org.springframework.data.elasticsearch.core.convert.DateTimeConverters; +import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.StringQuery; import org.springframework.data.repository.query.ParametersParameterAccessor; import org.springframework.util.Assert; @@ -71,17 +72,23 @@ public class ElasticsearchStringQuery extends AbstractElasticsearchRepositoryQue StringQuery stringQuery = createQuery(accessor); Class clazz = queryMethod.getEntityInformation().getJavaType(); IndexCoordinates index = elasticsearchOperations.getIndexCoordinatesFor(clazz); + + Object result = null; + if (queryMethod.isPageQuery()) { stringQuery.setPageable(accessor.getPageable()); - return elasticsearchOperations.queryForPage(stringQuery, clazz, index); + result = elasticsearchOperations.searchForPage(stringQuery, clazz, index); } else if (queryMethod.isCollectionQuery()) { if (accessor.getPageable().isPaged()) { stringQuery.setPageable(accessor.getPageable()); } - return elasticsearchOperations.queryForList(stringQuery, clazz, index); + result = elasticsearchOperations.search(stringQuery, clazz, index); + } else { + result = elasticsearchOperations.searchOne(stringQuery, clazz, index); } - return elasticsearchOperations.queryForObject(stringQuery, clazz, index); + return SearchHitSupport.unwrapSearchHits(result); + } protected StringQuery createQuery(ParametersParameterAccessor parameterAccessor) { diff --git a/src/main/java/org/springframework/data/elasticsearch/repository/support/AbstractElasticsearchRepository.java b/src/main/java/org/springframework/data/elasticsearch/repository/support/AbstractElasticsearchRepository.java index b2f3a7184..f4f156cb8 100644 --- a/src/main/java/org/springframework/data/elasticsearch/repository/support/AbstractElasticsearchRepository.java +++ b/src/main/java/org/springframework/data/elasticsearch/repository/support/AbstractElasticsearchRepository.java @@ -35,12 +35,13 @@ import org.springframework.data.domain.PageImpl; import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; -import org.springframework.data.elasticsearch.core.DocumentOperations; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; import org.springframework.data.elasticsearch.core.IndexOperations; -import org.springframework.data.elasticsearch.core.SearchOperations; -import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; +import org.springframework.data.elasticsearch.core.SearchHit; +import org.springframework.data.elasticsearch.core.SearchHitSupport; +import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage; import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity; +import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.DeleteQuery; import org.springframework.data.elasticsearch.core.query.GetQuery; import org.springframework.data.elasticsearch.core.query.IndexQuery; @@ -113,8 +114,8 @@ public abstract class AbstractElasticsearchRepository implements Elastics private boolean createIndexAndMapping() { - final ElasticsearchPersistentEntity entity = operations.getElasticsearchConverter() - .getMappingContext().getRequiredPersistentEntity(getEntityClass()); + final ElasticsearchPersistentEntity entity = operations.getElasticsearchConverter().getMappingContext() + .getRequiredPersistentEntity(getEntityClass()); return entity.isCreateIndexAndMapping(); } @@ -138,7 +139,8 @@ public abstract class AbstractElasticsearchRepository implements Elastics @Override public Page findAll(Pageable pageable) { NativeSearchQuery query = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).withPageable(pageable).build(); - return operations.queryForPage(query, getEntityClass(), getIndexCoordinates()); + AggregatedPage> page = operations.searchForPage(query, getEntityClass(), getIndexCoordinates()); + return unwrapSearchHits(page); } @Override @@ -150,7 +152,12 @@ public abstract class AbstractElasticsearchRepository implements Elastics } NativeSearchQuery query = new NativeSearchQueryBuilder().withQuery(matchAllQuery()) .withPageable(PageRequest.of(0, itemCount, sort)).build(); - return operations.queryForPage(query, getEntityClass(), getIndexCoordinates()); + AggregatedPage> page = operations.searchForPage(query, getEntityClass(), getIndexCoordinates()); + return unwrapSearchHits(page); + } + + private Page unwrapSearchHits(AggregatedPage> page) { + return (Page) SearchHitSupport.unwrapSearchHits(page); } @Override @@ -219,18 +226,21 @@ public abstract class AbstractElasticsearchRepository implements Elastics return new PageImpl<>(Collections. emptyList()); } searchQuery.setPageable(PageRequest.of(0, count)); - return operations.queryForPage(searchQuery, getEntityClass(), getIndexCoordinates()); + AggregatedPage> page = operations.searchForPage(searchQuery, getEntityClass(), getIndexCoordinates()); + return unwrapSearchHits(page); } @Override public Page search(QueryBuilder query, Pageable pageable) { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(query).withPageable(pageable).build(); - return operations.queryForPage(searchQuery, getEntityClass(), getIndexCoordinates()); + AggregatedPage> page = operations.searchForPage(searchQuery, getEntityClass(), getIndexCoordinates()); + return unwrapSearchHits(page); } @Override public Page search(Query query) { - return operations.queryForPage(query, getEntityClass(), getIndexCoordinates()); + AggregatedPage> page = operations.searchForPage(query, getEntityClass(), getIndexCoordinates()); + return unwrapSearchHits(page); } @Override @@ -245,7 +255,8 @@ public abstract class AbstractElasticsearchRepository implements Elastics query.addFields(fields); } - return operations.moreLikeThis(query, getEntityClass(), getIndexCoordinates()); + AggregatedPage> page = operations.search(query, getEntityClass(), getIndexCoordinates()); + return unwrapSearchHits(page); } @Override diff --git a/src/main/java/org/springframework/data/elasticsearch/repository/support/SimpleReactiveElasticsearchRepository.java b/src/main/java/org/springframework/data/elasticsearch/repository/support/SimpleReactiveElasticsearchRepository.java index 3d87f54ce..2d7b1ef11 100644 --- a/src/main/java/org/springframework/data/elasticsearch/repository/support/SimpleReactiveElasticsearchRepository.java +++ b/src/main/java/org/springframework/data/elasticsearch/repository/support/SimpleReactiveElasticsearchRepository.java @@ -21,6 +21,7 @@ import reactor.core.publisher.Mono; import org.reactivestreams.Publisher; import org.springframework.data.domain.Sort; import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations; +import org.springframework.data.elasticsearch.core.SearchHit; import org.springframework.data.elasticsearch.core.query.Query; import org.springframework.data.elasticsearch.repository.ReactiveElasticsearchRepository; import org.springframework.util.Assert; @@ -48,7 +49,9 @@ public class SimpleReactiveElasticsearchRepository implements ReactiveEla @Override public Flux findAll(Sort sort) { - return elasticsearchOperations.find(Query.findAll().addSort(sort), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()); + return elasticsearchOperations + .search(Query.findAll().addSort(sort), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()) + .map(SearchHit::getContent); } @Override @@ -76,7 +79,8 @@ public class SimpleReactiveElasticsearchRepository implements ReactiveEla public Mono findById(ID id) { Assert.notNull(id, "Id must not be null!"); - return elasticsearchOperations.findById(convertId(id), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()); + return elasticsearchOperations.findById(convertId(id), entityInformation.getJavaType(), + entityInformation.getIndexCoordinates()); } @Override @@ -90,7 +94,8 @@ public class SimpleReactiveElasticsearchRepository implements ReactiveEla public Mono existsById(ID id) { Assert.notNull(id, "Id must not be null!"); - return elasticsearchOperations.exists(convertId(id), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()); + return elasticsearchOperations.exists(convertId(id), entityInformation.getJavaType(), + entityInformation.getIndexCoordinates()); } @Override @@ -103,7 +108,9 @@ public class SimpleReactiveElasticsearchRepository implements ReactiveEla @Override public Flux findAll() { - return elasticsearchOperations.find(Query.findAll(), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()); + return elasticsearchOperations + .search(Query.findAll(), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()) + .map(SearchHit::getContent); } @Override @@ -124,14 +131,16 @@ public class SimpleReactiveElasticsearchRepository implements ReactiveEla @Override public Mono count() { - return elasticsearchOperations.count(Query.findAll(), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()); + return elasticsearchOperations.count(Query.findAll(), entityInformation.getJavaType(), + entityInformation.getIndexCoordinates()); } @Override public Mono deleteById(ID id) { Assert.notNull(id, "Id must not be null!"); - return elasticsearchOperations.deleteById(convertId(id), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()) // + return elasticsearchOperations + .deleteById(convertId(id), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()) // .then(); } @@ -167,7 +176,8 @@ public class SimpleReactiveElasticsearchRepository implements ReactiveEla @Override public Mono deleteAll() { - return elasticsearchOperations.deleteBy(Query.findAll(), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()) // + return elasticsearchOperations + .deleteBy(Query.findAll(), entityInformation.getJavaType(), entityInformation.getIndexCoordinates()) // .then(); } diff --git a/src/test/java/org/springframework/data/elasticsearch/NestedObjectTests.java b/src/test/java/org/springframework/data/elasticsearch/NestedObjectTests.java index 07350522c..566ac5055 100644 --- a/src/test/java/org/springframework/data/elasticsearch/NestedObjectTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/NestedObjectTests.java @@ -45,6 +45,9 @@ import org.springframework.data.elasticsearch.annotations.FieldType; import org.springframework.data.elasticsearch.annotations.InnerField; import org.springframework.data.elasticsearch.annotations.MultiField; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; +import org.springframework.data.elasticsearch.core.SearchHit; +import org.springframework.data.elasticsearch.core.SearchHits; +import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage; import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.GetQuery; import org.springframework.data.elasticsearch.core.query.IndexQuery; @@ -131,7 +134,7 @@ public class NestedObjectTests { boolQuery().must(termQuery("car.name", "saturn")).must(termQuery("car.model", "imprezza")), ScoreMode.None); NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(builder).build(); - List persons = elasticsearchTemplate.queryForList(searchQuery, Person.class, index); + SearchHits persons = elasticsearchTemplate.search(searchQuery, Person.class, index); assertThat(persons).hasSize(1); } @@ -193,11 +196,11 @@ public class NestedObjectTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(builder).build(); - Page personIndexed = elasticsearchTemplate.queryForPage(searchQuery, + Page> personIndexed = elasticsearchTemplate.searchForPage(searchQuery, PersonMultipleLevelNested.class, index); assertThat(personIndexed).isNotNull(); assertThat(personIndexed.getTotalElements()).isEqualTo(1); - assertThat(personIndexed.getContent().get(0).getId()).isEqualTo("1"); + assertThat(personIndexed.getContent().get(0).getContent().getId()).isEqualTo("1"); } private List createPerson() { @@ -330,7 +333,7 @@ public class NestedObjectTests { QueryBuilder builder = nestedQuery("books", boolQuery().must(termQuery("books.name", "java")), ScoreMode.None); NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(builder).build(); - List persons = elasticsearchTemplate.queryForList(searchQuery, Person.class, index); + SearchHits persons = elasticsearchTemplate.search(searchQuery, Person.class, index); // then assertThat(persons).hasSize(1); @@ -378,10 +381,10 @@ public class NestedObjectTests { // then NativeSearchQuery searchQuery = new NativeSearchQueryBuilder() .withQuery(nestedQuery("buckets", termQuery("buckets.1", "test3"), ScoreMode.None)).build(); - Page books = elasticsearchTemplate.queryForPage(searchQuery, Book.class, index); + AggregatedPage> books = elasticsearchTemplate.searchForPage(searchQuery, Book.class, index); assertThat(books.getContent()).hasSize(1); - assertThat(books.getContent().get(0).getId()).isEqualTo(book2.getId()); + assertThat(books.getContent().get(0).getContent().getId()).isEqualTo(book2.getId()); } @Setter diff --git a/src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java b/src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java index 4ff17b4c7..437808c91 100755 --- a/src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java @@ -282,7 +282,7 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); // when - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(sampleEntities).isNotNull(); @@ -306,8 +306,8 @@ public abstract class ElasticsearchTemplateTests { .withPreference("_local").build(); // when - Page sampleEntities = operations.queryForPage(searchQueryWithValidPreference, SampleEntity.class, - index); + Page> sampleEntities = operations.searchForPage(searchQueryWithValidPreference, + SampleEntity.class, index); // then assertThat(sampleEntities).isNotNull(); @@ -332,7 +332,7 @@ public abstract class ElasticsearchTemplateTests { // when assertThatThrownBy(() -> { - operations.queryForPage(searchQueryWithInvalidPreference, SampleEntity.class, index); + operations.searchForPage(searchQueryWithInvalidPreference, SampleEntity.class, index); }).isInstanceOf(Exception.class); } @@ -352,7 +352,7 @@ public abstract class ElasticsearchTemplateTests { // when NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()) .withIndicesOptions(IndicesOptions.lenientExpandOpen()).build(); - Page entities = operations.queryForPage(searchQuery, SampleEntity.class, + Page> entities = operations.searchForPage(searchQuery, SampleEntity.class, IndexCoordinates.of(INDEX_1_NAME, INDEX_2_NAME)); // then @@ -384,7 +384,7 @@ public abstract class ElasticsearchTemplateTests { // then NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(2); } @@ -439,7 +439,7 @@ public abstract class ElasticsearchTemplateTests { // then NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("id", documentId)).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(0); } @@ -461,7 +461,7 @@ public abstract class ElasticsearchTemplateTests { // then NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("id", documentId)).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(0); } @@ -486,7 +486,7 @@ public abstract class ElasticsearchTemplateTests { // then NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("id", documentId)).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(0); } @@ -574,7 +574,7 @@ public abstract class ElasticsearchTemplateTests { .withFilter(boolQuery().filter(termQuery("id", documentId))).build(); // when - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isEqualTo(1); @@ -609,11 +609,11 @@ public abstract class ElasticsearchTemplateTests { .withSort(new FieldSortBuilder("rate").order(SortOrder.ASC)).build(); // when - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isEqualTo(3); - assertThat(sampleEntities.getContent().get(0).getRate()).isEqualTo(sampleEntity2.getRate()); + assertThat(sampleEntities.getContent().get(0).getContent().getRate()).isEqualTo(sampleEntity2.getRate()); } @Test @@ -646,12 +646,12 @@ public abstract class ElasticsearchTemplateTests { .withSort(new FieldSortBuilder("message").order(SortOrder.ASC)).build(); // when - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isEqualTo(3); - assertThat(sampleEntities.getContent().get(0).getRate()).isEqualTo(sampleEntity2.getRate()); - assertThat(sampleEntities.getContent().get(1).getMessage()).isEqualTo(sampleEntity1.getMessage()); + assertThat(sampleEntities.getContent().get(0).getContent().getRate()).isEqualTo(sampleEntity2.getRate()); + assertThat(sampleEntities.getContent().get(1).getContent().getMessage()).isEqualTo(sampleEntity1.getMessage()); } @Test // DATAES-312 @@ -684,12 +684,12 @@ public abstract class ElasticsearchTemplateTests { .withPageable(PageRequest.of(0, 10, Sort.by(Sort.Order.asc("message").nullsFirst()))).build(); // when - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isEqualTo(3); - assertThat(sampleEntities.getContent().get(0).getRate()).isEqualTo(sampleEntity3.getRate()); - assertThat(sampleEntities.getContent().get(1).getMessage()).isEqualTo(sampleEntity1.getMessage()); + assertThat(sampleEntities.getContent().get(0).getContent().getRate()).isEqualTo(sampleEntity3.getRate()); + assertThat(sampleEntities.getContent().get(1).getContent().getMessage()).isEqualTo(sampleEntity1.getMessage()); } @Test // DATAES-312 @@ -722,12 +722,12 @@ public abstract class ElasticsearchTemplateTests { .withPageable(PageRequest.of(0, 10, Sort.by(Sort.Order.asc("message").nullsLast()))).build(); // when - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isEqualTo(3); - assertThat(sampleEntities.getContent().get(0).getRate()).isEqualTo(sampleEntity1.getRate()); - assertThat(sampleEntities.getContent().get(1).getMessage()).isEqualTo(sampleEntity2.getMessage()); + assertThat(sampleEntities.getContent().get(0).getContent().getRate()).isEqualTo(sampleEntity1.getRate()); + assertThat(sampleEntities.getContent().get(1).getContent().getMessage()).isEqualTo(sampleEntity2.getMessage()); } @Test // DATAES-467, DATAES-657 @@ -748,12 +748,12 @@ public abstract class ElasticsearchTemplateTests { .build(); // when - Page page = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(page.getTotalElements()).isEqualTo(2); - assertThat(page.getContent().get(0).getId()).isEqualTo("2"); - assertThat(page.getContent().get(1).getId()).isEqualTo("1"); + assertThat(page.getContent().get(0).getContent().getId()).isEqualTo("2"); + assertThat(page.getContent().get(1).getContent().getId()).isEqualTo("1"); } @Test @@ -772,7 +772,7 @@ public abstract class ElasticsearchTemplateTests { StringQuery stringQuery = new StringQuery(matchAllQuery().toString()); // when - Page sampleEntities = operations.queryForPage(stringQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(stringQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isEqualTo(1); @@ -803,11 +803,11 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).withScriptField( new ScriptField("scriptedRate", new Script(ScriptType.INLINE, "expression", "doc['rate'] * factor", params))) .build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isEqualTo(1); - assertThat(sampleEntities.getContent().get(0).getScriptedRate()).isEqualTo(4.0); + assertThat(sampleEntities.getContent().get(0).getContent().getScriptedRate()).isEqualTo(4.0); } @Test @@ -826,7 +826,7 @@ public abstract class ElasticsearchTemplateTests { StringQuery stringQuery = new StringQuery(matchAllQuery().toString(), PageRequest.of(0, 10)); // when - Page sampleEntities = operations.queryForPage(stringQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(stringQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isGreaterThanOrEqualTo(1); @@ -853,7 +853,7 @@ public abstract class ElasticsearchTemplateTests { Sort.by(Order.asc("message"))); // when - Page sampleEntities = operations.queryForPage(stringQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(stringQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isGreaterThanOrEqualTo(1); @@ -875,11 +875,11 @@ public abstract class ElasticsearchTemplateTests { StringQuery stringQuery = new StringQuery(termQuery("id", documentId).toString()); // when - SampleEntity sampleEntity1 = operations.queryForObject(stringQuery, SampleEntity.class, index); + SearchHit sampleEntity1 = operations.searchOne(stringQuery, SampleEntity.class, index); // then assertThat(sampleEntity1).isNotNull(); - assertThat(sampleEntity1.getId()).isEqualTo(documentId); + assertThat(sampleEntity1.getContent().getId()).isEqualTo(documentId); } @Test @@ -909,7 +909,7 @@ public abstract class ElasticsearchTemplateTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("test")); // when - SampleEntity sampleEntity1 = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity1 = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(sampleEntity1).isNotNull(); @@ -935,7 +935,7 @@ public abstract class ElasticsearchTemplateTests { // then StringQuery stringQuery = new StringQuery(matchAllQuery().toString()); - List sampleEntities = operations.queryForList(stringQuery, SampleEntity.class, index); + SearchHits sampleEntities = operations.search(stringQuery, SampleEntity.class, index); assertThat(sampleEntities).isEmpty(); } @@ -958,12 +958,12 @@ public abstract class ElasticsearchTemplateTests { .build(); // when - Page page = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); assertThat(page.getTotalElements()).isEqualTo(1); - final SampleEntity actual = page.getContent().get(0); + final SampleEntity actual = page.getContent().get(0).getContent(); assertThat(actual.message).isEqualTo(message); assertThat(actual.getType()).isNull(); assertThat(actual.getLocation()).isNull(); @@ -990,12 +990,12 @@ public abstract class ElasticsearchTemplateTests { .withSourceFilter(sourceFilter.build()).build(); // when - Page page = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); assertThat(page.getTotalElements()).isEqualTo(1); - assertThat(page.getContent().get(0).getMessage()).isEqualTo(message); + assertThat(page.getContent().get(0).getContent().getMessage()).isEqualTo(message); } @Test @@ -1030,11 +1030,13 @@ public abstract class ElasticsearchTemplateTests { moreLikeThisQuery.setMinDocFreq(1); // when - Page sampleEntities = operations.moreLikeThis(moreLikeThisQuery, SampleEntity.class, index); + Page> sampleEntities = operations.search(moreLikeThisQuery, SampleEntity.class, index); // then assertThat(sampleEntities.getTotalElements()).isEqualTo(1); - assertThat(sampleEntities.getContent()).contains(sampleEntity); + List content = sampleEntities.getContent().stream().map(SearchHit::getContent) + .collect(Collectors.toList()); + assertThat(content).contains(sampleEntity); } @Test // DATAES-167 @@ -1051,13 +1053,14 @@ public abstract class ElasticsearchTemplateTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); criteriaQuery.setPageable(PageRequest.of(0, 10)); - ScrolledPage scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index); - List sampleEntities = new ArrayList<>(); + ScrolledPage> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class, + index); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); - scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class); } - operations.clearScroll(scroll.getScrollId()); + operations.searchScrollClear(scroll.getScrollId()); assertThat(sampleEntities).hasSize(30); } @@ -1076,13 +1079,14 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()) .withPageable(PageRequest.of(0, 10)).build(); - ScrolledPage scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index); - List sampleEntities = new ArrayList<>(); + ScrolledPage> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class, + index); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); - scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class); } - operations.clearScroll(scroll.getScrollId()); + operations.searchScrollClear(scroll.getScrollId()); assertThat(sampleEntities).hasSize(30); } @@ -1101,15 +1105,16 @@ public abstract class ElasticsearchTemplateTests { criteriaQuery.addFields("message"); criteriaQuery.setPageable(PageRequest.of(0, 10)); - ScrolledPage scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index); + ScrolledPage> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class, + index); String scrollId = scroll.getScrollId(); - List sampleEntities = new ArrayList<>(); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); scrollId = scroll.getScrollId(); - scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class); } - operations.clearScroll(scrollId); + operations.searchScrollClear(scrollId); assertThat(sampleEntities).hasSize(30); } @@ -1127,15 +1132,16 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).withFields("message") .withQuery(matchAllQuery()).withPageable(PageRequest.of(0, 10)).build(); - ScrolledPage scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index); + ScrolledPage> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class, + index); String scrollId = scroll.getScrollId(); - List sampleEntities = new ArrayList<>(); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); scrollId = scroll.getScrollId(); - scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class); } - operations.clearScroll(scrollId); + operations.searchScrollClear(scrollId); assertThat(sampleEntities).hasSize(30); } @@ -1153,15 +1159,16 @@ public abstract class ElasticsearchTemplateTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); criteriaQuery.setPageable(PageRequest.of(0, 10)); - ScrolledPage scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index); + ScrolledPage> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class, + index); String scrollId = scroll.getScrollId(); - List sampleEntities = new ArrayList<>(); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); scrollId = scroll.getScrollId(); - scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class); } - operations.clearScroll(scrollId); + operations.searchScrollClear(scrollId); assertThat(sampleEntities).hasSize(30); } @@ -1179,15 +1186,16 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()) .withPageable(PageRequest.of(0, 10)).build(); - ScrolledPage scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index); + ScrolledPage> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class, + index); String scrollId = scroll.getScrollId(); - List sampleEntities = new ArrayList<>(); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); scrollId = scroll.getScrollId(); - scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class); } - operations.clearScroll(scrollId); + operations.searchScrollClear(scrollId); assertThat(sampleEntities).hasSize(30); } @@ -1205,15 +1213,16 @@ public abstract class ElasticsearchTemplateTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); criteriaQuery.setPageable(PageRequest.of(0, 10)); - ScrolledPage scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index); + ScrolledPage> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class, + index); String scrollId = scroll.getScrollId(); - List sampleEntities = new ArrayList<>(); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); scrollId = scroll.getScrollId(); - scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class); } - operations.clearScroll(scrollId); + operations.searchScrollClear(scrollId); assertThat(sampleEntities).hasSize(30); } @@ -1231,15 +1240,16 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()) .withPageable(PageRequest.of(0, 10)).build(); - ScrolledPage scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index); + ScrolledPage> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class, + index); String scrollId = scroll.getScrollId(); - List sampleEntities = new ArrayList<>(); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); scrollId = scroll.getScrollId(); - scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class); } - operations.clearScroll(scrollId); + operations.searchScrollClear(scrollId); assertThat(sampleEntities).hasSize(30); } @@ -1257,8 +1267,9 @@ public abstract class ElasticsearchTemplateTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); criteriaQuery.setPageable(PageRequest.of(0, 10)); - CloseableIterator stream = operations.stream(criteriaQuery, SampleEntity.class, index); - List sampleEntities = new ArrayList<>(); + CloseableIterator> stream = operations.searchForStream(criteriaQuery, SampleEntity.class, + index); + List> sampleEntities = new ArrayList<>(); while (stream.hasNext()) { sampleEntities.add(stream.next()); } @@ -1311,9 +1322,9 @@ public abstract class ElasticsearchTemplateTests { CriteriaQuery singleCriteriaQuery = new CriteriaQuery(new Criteria("message").contains("test")); CriteriaQuery multipleCriteriaQuery = new CriteriaQuery( new Criteria("message").contains("some").and("message").contains("message")); - List sampleEntitiesForSingleCriteria = operations.queryForList(singleCriteriaQuery, + SearchHits sampleEntitiesForSingleCriteria = operations.search(singleCriteriaQuery, SampleEntity.class, index); - List sampleEntitiesForAndCriteria = operations.queryForList(multipleCriteriaQuery, SampleEntity.class, + SearchHits sampleEntitiesForAndCriteria = operations.search(multipleCriteriaQuery, SampleEntity.class, index); // then assertThat(sampleEntitiesForSingleCriteria).hasSize(2); @@ -1346,17 +1357,17 @@ public abstract class ElasticsearchTemplateTests { indexOperations.refresh(SampleEntity.class); StringQuery stringQuery = new StringQuery(matchAllQuery().toString()); - List sampleEntities = operations.queryForList(stringQuery, SampleEntity.class, index); + SearchHits sampleEntities = operations.search(stringQuery, SampleEntity.class, index); // then assertThat(sampleEntities).hasSize(3); } @Test - public void shouldPutMappingForGivenEntity() throws Exception { + public void shouldPutMappingForGivenEntity() { // given - Class entity = SampleMappingEntity.class; + Class entity = SampleEntity.class; indexOperations.deleteIndex(entity); indexOperations.createIndex(entity); @@ -1367,7 +1378,7 @@ public abstract class ElasticsearchTemplateTests { } @Test // DATAES-305 - public void shouldPutMappingWithCustomIndexName() throws Exception { + public void shouldPutMappingWithCustomIndexName() { // given Class entity = SampleEntity.class; @@ -1510,15 +1521,15 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()) .withIndicesOptions(IndicesOptions.lenientExpandOpen()).build(); - List entities = new ArrayList<>(); + List> entities = new ArrayList<>(); - ScrolledPage scroll = operations.startScroll(scrollTimeInMillis, searchQuery, SampleEntity.class, - index); + ScrolledPage> scroll = operations.searchScrollStart(scrollTimeInMillis, searchQuery, + SampleEntity.class, index); entities.addAll(scroll.getContent()); while (scroll.hasContent()) { - scroll = operations.continueScroll(scroll.getScrollId(), scrollTimeInMillis, SampleEntity.class); + scroll = operations.searchScrollContinue(scroll.getScrollId(), scrollTimeInMillis, SampleEntity.class); entities.addAll(scroll.getContent()); } @@ -1549,8 +1560,9 @@ public abstract class ElasticsearchTemplateTests { queries.add(new NativeSearchQueryBuilder().withQuery(termQuery("message", "ac")).build()); // then - List> sampleEntities = operations.queryForPage(queries, SampleEntity.class, index); - for (Page sampleEntity : sampleEntities) { + List>> sampleEntities = operations.multiSearchForPage(queries, + SampleEntity.class, index); + for (Page> sampleEntity : sampleEntities) { assertThat(sampleEntity.getTotalElements()).isEqualTo(1); } } @@ -1577,16 +1589,19 @@ public abstract class ElasticsearchTemplateTests { queries.add(new NativeSearchQueryBuilder().withQuery(termQuery("message", "ab")).build()); queries.add(new NativeSearchQueryBuilder().withQuery(termQuery("description", "bc")).build()); - List> pages = operations.queryForPage(queries, Lists.newArrayList(SampleEntity.class, clazz), + List>> pages = operations.multiSearchForPage(queries, + Lists.newArrayList(SampleEntity.class, clazz), IndexCoordinates.of(index.getIndexName(), bookIndex.getIndexName())); // then Page page0 = pages.get(0); assertThat(page0.getTotalElements()).isEqualTo(1L); - assertThat(page0.getContent().get(0).getClass()).isEqualTo(SampleEntity.class); + SearchHit searchHit0 = (SearchHit) page0.getContent().get(0); + assertThat(searchHit0.getContent().getClass()).isEqualTo(SampleEntity.class); Page page1 = pages.get(1); assertThat(page1.getTotalElements()).isEqualTo(1L); - assertThat(page1.getContent().get(0).getClass()).isEqualTo(clazz); + SearchHit searchHit1 = (SearchHit) page1.getContent().get(0); + assertThat(searchHit1.getContent().getClass()).isEqualTo(clazz); } @Test @@ -1610,7 +1625,7 @@ public abstract class ElasticsearchTemplateTests { // then NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("id", documentId)).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(0); } @@ -1630,10 +1645,10 @@ public abstract class ElasticsearchTemplateTests { .build(); // then - Page page = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(page).isNotNull(); assertThat(page.getContent()).hasSize(1); - assertThat(page.getContent().get(0).getId()).isEqualTo(indexQuery.getId()); + assertThat(page.getContent().get(0).getContent().getId()).isEqualTo(indexQuery.getId()); } @Test @@ -1680,11 +1695,11 @@ public abstract class ElasticsearchTemplateTests { .withQuery(boolQuery().must(wildcardQuery("message", "*a*")).should(wildcardQuery("message", "*b*"))) .withMinScore(2.0F).build(); - Page page = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(page.getTotalElements()).isEqualTo(1); - assertThat(page.getContent().get(0).getMessage()).isEqualTo("ab"); + assertThat(page.getContent().get(0).getContent().getMessage()).isEqualTo("ab"); } @Test // DATAES-462 @@ -1704,7 +1719,7 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("message", "xz")) .withSort(SortBuilders.fieldSort("message")).withTrackScores(true).build(); - Page page = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(page).isInstanceOf(AggregatedPage.class); @@ -1765,12 +1780,12 @@ public abstract class ElasticsearchTemplateTests { // then NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(2); - List content = sampleEntities.getContent(); - assertThat(content.get(0).getId()).isNotNull(); - assertThat(content.get(1).getId()).isNotNull(); + List> content = sampleEntities.getContent(); + assertThat(content.get(0).getContent().getId()).isNotNull(); + assertThat(content.get(1).getContent().getId()).isNotNull(); } @Test @@ -1809,12 +1824,12 @@ public abstract class ElasticsearchTemplateTests { // then NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - Page sampleEntities = operations.queryForPage(searchQuery, Map.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, Map.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(2); - List content = sampleEntities.getContent(); - assertThat(content.get(0).get("userId")).isEqualTo(person1.get("userId")); - assertThat(content.get(1).get("userId")).isEqualTo(person2.get("userId")); + List> content = sampleEntities.getContent(); + assertThat(content.get(0).getContent().get("userId")).isEqualTo(person1.get("userId")); + assertThat(content.get(1).getContent().get("userId")).isEqualTo(person2.get("userId")); } @Test // DATAES-523 @@ -1833,7 +1848,7 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); // when - Page entities = operations.queryForPage(searchQuery, GTEVersionEntity.class, index); + Page> entities = operations.searchForPage(searchQuery, GTEVersionEntity.class, index); // then assertThat(entities).isNotNull(); assertThat(entities.getTotalElements()).isGreaterThanOrEqualTo(1); @@ -1864,7 +1879,7 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); // when - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(sampleEntities).isNotNull(); @@ -2241,7 +2256,7 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); // when - List sampleEntities = operations.queryForList(searchQuery, SampleEntity.class, + SearchHits sampleEntities = operations.search(searchQuery, SampleEntity.class, IndexCoordinates.of(INDEX_1_NAME, INDEX_2_NAME)); // then @@ -2268,7 +2283,7 @@ public abstract class ElasticsearchTemplateTests { // when NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - Page page = operations.queryForPage(searchQuery, ResultAggregator.class, + Page> page = operations.searchForPage(searchQuery, ResultAggregator.class, IndexCoordinates.of(INDEX_1_NAME, INDEX_2_NAME)); assertThat(page.getTotalElements()).isEqualTo(2); @@ -2329,9 +2344,9 @@ public abstract class ElasticsearchTemplateTests { // then // document with id "remainingDocumentId" should still be indexed NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(1); - assertThat(sampleEntities.getContent().get(0).getId()).isEqualTo(remainingDocumentId); + assertThat(sampleEntities.getContent().get(0).getContent().getId()).isEqualTo(remainingDocumentId); } @Test // DATAES-525 @@ -2360,9 +2375,9 @@ public abstract class ElasticsearchTemplateTests { // then // document with id "remainingDocumentId" should still be indexed NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(1); - assertThat(sampleEntities.getContent().get(0).getId()).isEqualTo(remainingDocumentId); + assertThat(sampleEntities.getContent().get(0).getContent().getId()).isEqualTo(remainingDocumentId); } @Test // DATAES-525 @@ -2389,9 +2404,9 @@ public abstract class ElasticsearchTemplateTests { // then // document with id "remainingDocumentId" should still be indexed NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - Page sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index); assertThat(sampleEntities.getTotalElements()).isEqualTo(1L); - assertThat(sampleEntities.getContent().get(0).getId()).isEqualTo(remainingDocumentId); + assertThat(sampleEntities.getContent().get(0).getContent().getId()).isEqualTo(remainingDocumentId); } @Test // DATAES-525 @@ -2415,18 +2430,20 @@ public abstract class ElasticsearchTemplateTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("message")); criteriaQuery.setPageable(PageRequest.of(0, 10)); - ScrolledPage scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index); - List sampleEntities = new ArrayList<>(); + ScrolledPage> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class, + index); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); - scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class); } - operations.clearScroll(scroll.getScrollId()); + operations.searchScrollClear(scroll.getScrollId()); // then assertThat(sampleEntities).hasSize(2); - assertThat(sampleEntities.stream().map(SampleEntity::getMessage).collect(Collectors.toList())) - .doesNotContain(notFindableMessage); + assertThat( + sampleEntities.stream().map(SearchHit::getContent).map(SampleEntity::getMessage).collect(Collectors.toList())) + .doesNotContain(notFindableMessage); } @Test // DATAES-525 @@ -2450,18 +2467,20 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchQuery("message", "message")) .withPageable(PageRequest.of(0, 10)).build(); - ScrolledPage scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index); - List sampleEntities = new ArrayList<>(); + ScrolledPage> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class, + index); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); - scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class); } - operations.clearScroll(scroll.getScrollId()); + operations.searchScrollClear(scroll.getScrollId()); // then assertThat(sampleEntities).hasSize(2); - assertThat(sampleEntities.stream().map(SampleEntity::getMessage).collect(Collectors.toList())) - .doesNotContain(notFindableMessage); + assertThat( + sampleEntities.stream().map(SearchHit::getContent).map(SampleEntity::getMessage).collect(Collectors.toList())) + .doesNotContain(notFindableMessage); } @Test // DATAES-565 @@ -2480,18 +2499,20 @@ public abstract class ElasticsearchTemplateTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()) .withPageable(PageRequest.of(0, 10)).withSourceFilter(sourceFilter).build(); - ScrolledPage scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index); - List sampleEntities = new ArrayList<>(); + ScrolledPage> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class, + index); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); - scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class); } - operations.clearScroll(scroll.getScrollId()); + operations.searchScrollClear(scroll.getScrollId()); assertThat(sampleEntities).hasSize(3); - assertThat(sampleEntities.stream().map(SampleEntity::getId).collect(Collectors.toList())) + assertThat(sampleEntities.stream().map(SearchHit::getContent).map(SampleEntity::getId).collect(Collectors.toList())) .doesNotContain((String) null); - assertThat(sampleEntities.stream().map(SampleEntity::getMessage).collect(Collectors.toList())) - .containsOnly((String) null); + assertThat( + sampleEntities.stream().map(SearchHit::getContent).map(SampleEntity::getMessage).collect(Collectors.toList())) + .containsOnly((String) null); } @Test // DATAES-457 @@ -2524,20 +2545,21 @@ public abstract class ElasticsearchTemplateTests { .withSort(new FieldSortBuilder("message").order(SortOrder.DESC)).withPageable(PageRequest.of(0, 10)).build(); // when - ScrolledPage scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index); - List sampleEntities = new ArrayList<>(); + ScrolledPage> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class, + index); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); - scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class); } // then assertThat(sampleEntities).hasSize(3); - assertThat(sampleEntities.get(0).getRate()).isEqualTo(sampleEntity2.getRate()); - assertThat(sampleEntities.get(1).getRate()).isEqualTo(sampleEntity3.getRate()); - assertThat(sampleEntities.get(1).getMessage()).isEqualTo(sampleEntity3.getMessage()); - assertThat(sampleEntities.get(2).getRate()).isEqualTo(sampleEntity1.getRate()); - assertThat(sampleEntities.get(2).getMessage()).isEqualTo(sampleEntity1.getMessage()); + assertThat(sampleEntities.get(0).getContent().getRate()).isEqualTo(sampleEntity2.getRate()); + assertThat(sampleEntities.get(1).getContent().getRate()).isEqualTo(sampleEntity3.getRate()); + assertThat(sampleEntities.get(1).getContent().getMessage()).isEqualTo(sampleEntity3.getMessage()); + assertThat(sampleEntities.get(2).getContent().getRate()).isEqualTo(sampleEntity1.getRate()); + assertThat(sampleEntities.get(2).getContent().getMessage()).isEqualTo(sampleEntity1.getMessage()); } @Test // DATAES-457 @@ -2571,20 +2593,21 @@ public abstract class ElasticsearchTemplateTests { .build(); // when - ScrolledPage scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index); - List sampleEntities = new ArrayList<>(); + ScrolledPage> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class, + index); + List> sampleEntities = new ArrayList<>(); while (scroll.hasContent()) { sampleEntities.addAll(scroll.getContent()); - scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class); + scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class); } // then assertThat(sampleEntities).hasSize(3); - assertThat(sampleEntities.get(0).getRate()).isEqualTo(sampleEntity2.getRate()); - assertThat(sampleEntities.get(1).getRate()).isEqualTo(sampleEntity3.getRate()); - assertThat(sampleEntities.get(1).getMessage()).isEqualTo(sampleEntity3.getMessage()); - assertThat(sampleEntities.get(2).getRate()).isEqualTo(sampleEntity1.getRate()); - assertThat(sampleEntities.get(2).getMessage()).isEqualTo(sampleEntity1.getMessage()); + assertThat(sampleEntities.get(0).getContent().getRate()).isEqualTo(sampleEntity2.getRate()); + assertThat(sampleEntities.get(1).getContent().getRate()).isEqualTo(sampleEntity3.getRate()); + assertThat(sampleEntities.get(1).getContent().getMessage()).isEqualTo(sampleEntity3.getMessage()); + assertThat(sampleEntities.get(2).getContent().getRate()).isEqualTo(sampleEntity1.getRate()); + assertThat(sampleEntities.get(2).getContent().getMessage()).isEqualTo(sampleEntity1.getMessage()); } @Test // DATAES-593 @@ -2607,14 +2630,14 @@ public abstract class ElasticsearchTemplateTests { .build(); // when - Page page = operations.queryForPage(searchQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(searchQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); assertThat(page.getTotalElements()).isEqualTo(3); assertThat(page.getContent()).hasSize(2); - assertThat(page.getContent().get(0).getMessage()).isEqualTo("message 1"); - assertThat(page.getContent().get(1).getMessage()).isEqualTo("message 2"); + assertThat(page.getContent().get(0).getContent().getMessage()).isEqualTo("message 1"); + assertThat(page.getContent().get(1).getContent().getMessage()).isEqualTo("message 2"); } private IndexQuery getIndexQuery(SampleEntity sampleEntity) { diff --git a/src/test/java/org/springframework/data/elasticsearch/core/LogEntityTests.java b/src/test/java/org/springframework/data/elasticsearch/core/LogEntityTests.java index f3369d4a2..633a497c4 100644 --- a/src/test/java/org/springframework/data/elasticsearch/core/LogEntityTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/LogEntityTests.java @@ -25,7 +25,6 @@ import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; -import java.util.List; import org.elasticsearch.ElasticsearchException; import org.junit.jupiter.api.BeforeEach; @@ -90,7 +89,7 @@ public class LogEntityTests { // when NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("ip", "10.10.10.1")).build(); - List entities = operations.queryForList(searchQuery, LogEntity.class, index); + SearchHits entities = operations.search(searchQuery, LogEntity.class, index); // then assertThat(entities).isNotNull().hasSize(1); @@ -103,7 +102,7 @@ public class LogEntityTests { NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("ip", "10.10.10")).build(); assertThatThrownBy(() -> { - List entities = operations.queryForList(searchQuery, LogEntity.class, index); + SearchHits entities = operations.search(searchQuery, LogEntity.class, index); }).isInstanceOf(ElasticsearchException.class); } @@ -113,7 +112,7 @@ public class LogEntityTests { // when NativeSearchQuery searchQuery = new NativeSearchQueryBuilder() .withQuery(rangeQuery("ip").from("10.10.10.1").to("10.10.10.3")).build(); - List entities = operations.queryForList(searchQuery, LogEntity.class, index); + SearchHits entities = operations.search(searchQuery, LogEntity.class, index); // then assertThat(entities).isNotNull().hasSize(3); diff --git a/src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateTests.java b/src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateTests.java index 8abfa0d60..41c04d0d3 100644 --- a/src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateTests.java @@ -24,7 +24,6 @@ import lombok.Builder; import lombok.Data; import lombok.EqualsAndHashCode; import lombok.NoArgsConstructor; -import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import reactor.core.publisher.Mono; import reactor.test.StepVerifier; @@ -54,6 +53,7 @@ import org.springframework.data.elasticsearch.TestUtils; import org.springframework.data.elasticsearch.annotations.Document; import org.springframework.data.elasticsearch.annotations.Field; import org.springframework.data.elasticsearch.annotations.Score; +import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.Criteria; import org.springframework.data.elasticsearch.core.query.CriteriaQuery; import org.springframework.data.elasticsearch.core.query.IndexQuery; @@ -137,7 +137,7 @@ public class ReactiveElasticsearchTemplateTests { restTemplate.refresh(SampleEntity.class); - List result = restTemplate.queryForList( + SearchHits result = restTemplate.search( new CriteriaQuery(Criteria.where("message").is(sampleEntity.getMessage())), SampleEntity.class, IndexCoordinates.of(DEFAULT_INDEX)); assertThat(result).hasSize(1); @@ -311,38 +311,39 @@ public class ReactiveElasticsearchTemplateTests { } @Test // DATAES-519 - public void findShouldCompleteWhenIndexDoesNotExist() { + public void searchShouldCompleteWhenIndexDoesNotExist() { template - .find(new CriteriaQuery(Criteria.where("message").is("some message")), SampleEntity.class, + .search(new CriteriaQuery(Criteria.where("message").is("some message")), SampleEntity.class, IndexCoordinates.of("no-such-index")) // .as(StepVerifier::create) // .verifyComplete(); } @Test // DATAES-504 - public void findShouldApplyCriteria() { + public void searchShouldApplyCriteria() { SampleEntity sampleEntity = randomEntity("some message"); index(sampleEntity); CriteriaQuery criteriaQuery = new CriteriaQuery(Criteria.where("message").is("some message")); - template.find(criteriaQuery, SampleEntity.class) // + template.search(criteriaQuery, SampleEntity.class) // + .map(SearchHit::getContent) // .as(StepVerifier::create) // .expectNext(sampleEntity) // .verifyComplete(); } @Test // DATAES-504 - public void findShouldReturnEmptyFluxIfNothingFound() { + public void searchShouldReturnEmptyFluxIfNothingFound() { SampleEntity sampleEntity = randomEntity("some message"); index(sampleEntity); CriteriaQuery criteriaQuery = new CriteriaQuery(Criteria.where("message").is("foo")); - template.find(criteriaQuery, SampleEntity.class) // + template.search(criteriaQuery, SampleEntity.class) // .as(StepVerifier::create) // .verifyComplete(); } @@ -352,7 +353,7 @@ public class ReactiveElasticsearchTemplateTests { index(randomEntity("test message"), randomEntity("test test"), randomEntity("some message")); - template.find(new StringQuery(matchAllQuery().toString()), SampleEntity.class) // + template.search(new StringQuery(matchAllQuery().toString()), SampleEntity.class) // .as(StepVerifier::create) // .expectNextCount(3) // .verifyComplete(); @@ -367,7 +368,8 @@ public class ReactiveElasticsearchTemplateTests { CriteriaQuery query = new CriteriaQuery(new Criteria("message").contains("test")); - template.find(query, SampleEntity.class) // + template.search(query, SampleEntity.class) // + .map(SearchHit::getContent) // .as(StepVerifier::create) // .expectNext(shouldMatch) // .verifyComplete(); @@ -385,7 +387,8 @@ public class ReactiveElasticsearchTemplateTests { CriteriaQuery query = new CriteriaQuery( new Criteria("message").contains("some").and("message").contains("message")); - template.find(query, SampleEntity.class) // + template.search(query, SampleEntity.class) // + .map(SearchHit::getContent) // .as(StepVerifier::create) // .expectNext(sampleEntity3) // .verifyComplete(); @@ -404,7 +407,8 @@ public class ReactiveElasticsearchTemplateTests { new Criteria("message").contains("some").and("message").contains("message")); queryWithValidPreference.setPreference("_local"); - template.find(queryWithValidPreference, SampleEntity.class) // + template.search(queryWithValidPreference, SampleEntity.class) // + .map(SearchHit::getContent) // .as(StepVerifier::create) // .expectNext(sampleEntity3) // .verifyComplete(); @@ -423,7 +427,7 @@ public class ReactiveElasticsearchTemplateTests { new Criteria("message").contains("some").and("message").contains("message")); queryWithInvalidPreference.setPreference("_only_nodes:oops"); - template.find(queryWithInvalidPreference, SampleEntity.class) // + template.search(queryWithInvalidPreference, SampleEntity.class) // .as(StepVerifier::create) // .expectError(ElasticsearchStatusException.class).verify(); } @@ -440,14 +444,15 @@ public class ReactiveElasticsearchTemplateTests { CriteriaQuery query = new CriteriaQuery( new Criteria("message").contains("some").and("message").contains("message")); - template.find(query, SampleEntity.class, Message.class) // + template.search(query, SampleEntity.class, Message.class) // + .map(SearchHit::getContent) // .as(StepVerifier::create) // .expectNext(new Message(sampleEntity3.getMessage())) // .verifyComplete(); } @Test // DATAES-518 - public void findShouldApplyPagingCorrectly() { + public void searchShouldApplyPagingCorrectly() { List source = IntStream.range(0, 100).mapToObj(it -> randomEntity("entity - " + it)) .collect(Collectors.toList()); @@ -458,7 +463,7 @@ public class ReactiveElasticsearchTemplateTests { .addSort(Sort.by("message"))// .setPageable(PageRequest.of(0, 20)); - template.find(query, SampleEntity.class).as(StepVerifier::create) // + template.search(query, SampleEntity.class).as(StepVerifier::create) // .expectNextCount(20) // .verifyComplete(); } @@ -475,7 +480,7 @@ public class ReactiveElasticsearchTemplateTests { .addSort(Sort.by("message"))// .setPageable(Pageable.unpaged()); - template.find(query, SampleEntity.class).as(StepVerifier::create) // + template.search(query, SampleEntity.class).as(StepVerifier::create) // .expectNextCount(100) // .verifyComplete(); } @@ -682,7 +687,7 @@ public class ReactiveElasticsearchTemplateTests { .withPageable(PageRequest.of(0, 25)) // .build(); - template.find(query, SampleEntity.class, IndexCoordinates.of(DEFAULT_INDEX)) // + template.search(query, SampleEntity.class, IndexCoordinates.of(DEFAULT_INDEX)) // .as(StepVerifier::create) // .expectNextCount(2) // .verifyComplete(); diff --git a/src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateUnitTests.java b/src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateUnitTests.java index 5bd97580b..ce95568c9 100644 --- a/src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateUnitTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateUnitTests.java @@ -108,12 +108,12 @@ public class ReactiveElasticsearchTemplateUnitTests { } @Test // DATAES-504, DATAES-518 - public void findShouldFallBackToDefaultIndexOptionsIfNotSet() { + public void searchShouldFallBackToDefaultIndexOptionsIfNotSet() { ArgumentCaptor captor = ArgumentCaptor.forClass(SearchRequest.class); when(client.search(captor.capture())).thenReturn(Flux.empty()); - template.find(new CriteriaQuery(new Criteria("*")).setPageable(PageRequest.of(0, 10)), SampleEntity.class) // + template.search(new CriteriaQuery(new Criteria("*")).setPageable(PageRequest.of(0, 10)), SampleEntity.class) // .as(StepVerifier::create) // .verifyComplete(); @@ -121,7 +121,7 @@ public class ReactiveElasticsearchTemplateUnitTests { } @Test // DATAES-504, DATAES-518 - public void findShouldApplyIndexOptionsIfSet() { + public void searchShouldApplyIndexOptionsIfSet() { ArgumentCaptor captor = ArgumentCaptor.forClass(SearchRequest.class); when(client.search(captor.capture())).thenReturn(Flux.empty()); @@ -129,7 +129,7 @@ public class ReactiveElasticsearchTemplateUnitTests { template.setIndicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN); Query query = new CriteriaQuery(new Criteria("*")).setPageable(PageRequest.of(0, 10)); - template.find(query, SampleEntity.class, index) // + template.search(query, SampleEntity.class, index) // .as(StepVerifier::create) // .verifyComplete(); @@ -137,13 +137,13 @@ public class ReactiveElasticsearchTemplateUnitTests { } @Test // DATAES-504 - public void findShouldApplyPaginationIfSet() { + public void searchShouldApplyPaginationIfSet() { ArgumentCaptor captor = ArgumentCaptor.forClass(SearchRequest.class); when(client.search(captor.capture())).thenReturn(Flux.empty()); Query query = new CriteriaQuery(new Criteria("*")).setPageable(PageRequest.of(2, 50)); - template.find(query, SampleEntity.class, index) // + template.search(query, SampleEntity.class, index) // .as(StepVerifier::create) // .verifyComplete(); @@ -152,12 +152,12 @@ public class ReactiveElasticsearchTemplateUnitTests { } @Test // DATAES-504, DATAES-518 - public void findShouldUseScrollIfPaginationNotSet() { + public void searchShouldUseScrollIfPaginationNotSet() { ArgumentCaptor captor = ArgumentCaptor.forClass(SearchRequest.class); when(client.scroll(captor.capture())).thenReturn(Flux.empty()); - template.find(new CriteriaQuery(new Criteria("*")).setPageable(Pageable.unpaged()), SampleEntity.class) // + template.search(new CriteriaQuery(new Criteria("*")).setPageable(Pageable.unpaged()), SampleEntity.class) // .as(StepVerifier::create) // .verifyComplete(); diff --git a/src/test/java/org/springframework/data/elasticsearch/core/geo/ElasticsearchTemplateGeoTests.java b/src/test/java/org/springframework/data/elasticsearch/core/geo/ElasticsearchTemplateGeoTests.java index dab4f30cb..3469d2d14 100644 --- a/src/test/java/org/springframework/data/elasticsearch/core/geo/ElasticsearchTemplateGeoTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/geo/ElasticsearchTemplateGeoTests.java @@ -39,6 +39,8 @@ import org.springframework.data.elasticsearch.annotations.Document; import org.springframework.data.elasticsearch.annotations.GeoPointField; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; import org.springframework.data.elasticsearch.core.IndexOperations; +import org.springframework.data.elasticsearch.core.SearchHit; +import org.springframework.data.elasticsearch.core.SearchHits; import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.Criteria; import org.springframework.data.elasticsearch.core.query.CriteriaQuery; @@ -139,12 +141,12 @@ public class ElasticsearchTemplateGeoTests { new Criteria("location").within(new GeoPoint(45.7806d, 3.0875d), "20km")); // when - List geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery, + SearchHits geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery, AuthorMarkerEntity.class, authorMarkerIndex); // then assertThat(geoAuthorsForGeoCriteria).hasSize(1); - assertThat(geoAuthorsForGeoCriteria.get(0).getName()).isEqualTo("Franck Marchand"); + assertThat(geoAuthorsForGeoCriteria.getSearchHit(0).getContent().getName()).isEqualTo("Franck Marchand"); } @Test @@ -156,12 +158,12 @@ public class ElasticsearchTemplateGeoTests { new Criteria("name").is("Mohsin Husen").and("location").within(new GeoPoint(51.5171d, 0.1062d), "20km")); // when - List geoAuthorsForGeoCriteria2 = operations.queryForList(geoLocationCriteriaQuery2, + SearchHits geoAuthorsForGeoCriteria2 = operations.search(geoLocationCriteriaQuery2, AuthorMarkerEntity.class, authorMarkerIndex); // then assertThat(geoAuthorsForGeoCriteria2).hasSize(1); - assertThat(geoAuthorsForGeoCriteria2.get(0).getName()).isEqualTo("Mohsin Husen"); + assertThat(geoAuthorsForGeoCriteria2.getSearchHit(0).getContent().getName()).isEqualTo("Mohsin Husen"); } @Test @@ -172,7 +174,7 @@ public class ElasticsearchTemplateGeoTests { CriteriaQuery geoLocationCriteriaQuery = new CriteriaQuery( new Criteria("locationAsString").within(new GeoPoint(51.000000, 0.100000), "1km")); // when - List geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery, + SearchHits geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery, LocationMarkerEntity.class, locationMarkerIndex); // then @@ -188,7 +190,7 @@ public class ElasticsearchTemplateGeoTests { new Criteria("locationAsArray").within(new GeoPoint(51.001000, 0.10100), "1km")); // when - List geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery, + SearchHits geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery, LocationMarkerEntity.class, locationMarkerIndex); // then @@ -203,7 +205,7 @@ public class ElasticsearchTemplateGeoTests { CriteriaQuery geoLocationCriteriaQuery = new CriteriaQuery( new Criteria("locationAsArray").within("51.001000, 0.10100", "1km")); // when - List geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery, + SearchHits geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery, LocationMarkerEntity.class, locationMarkerIndex); // then @@ -218,7 +220,7 @@ public class ElasticsearchTemplateGeoTests { CriteriaQuery geoLocationCriteriaQuery = new CriteriaQuery(new Criteria("locationAsArray").within("u1044", "3km")); // when - List geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery, + SearchHits geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery, LocationMarkerEntity.class, locationMarkerIndex); // then @@ -234,7 +236,7 @@ public class ElasticsearchTemplateGeoTests { .withFilter(QueryBuilders.geoBoundingBoxQuery("locationAsArray").setCorners(52, -1, 50, 1)); // when - List geoAuthorsForGeoCriteria = operations.queryForList(queryBuilder.build(), + SearchHits geoAuthorsForGeoCriteria = operations.search(queryBuilder.build(), LocationMarkerEntity.class, locationMarkerIndex); // then @@ -250,12 +252,12 @@ public class ElasticsearchTemplateGeoTests { new Criteria("location").boundedBy(new GeoBox(new GeoPoint(53.5171d, 0), new GeoPoint(49.5171d, 0.2062d)))); // when - List geoAuthorsForGeoCriteria3 = operations.queryForList(geoLocationCriteriaQuery3, + SearchHits geoAuthorsForGeoCriteria3 = operations.search(geoLocationCriteriaQuery3, AuthorMarkerEntity.class, authorMarkerIndex); // then assertThat(geoAuthorsForGeoCriteria3).hasSize(2); - assertThat(geoAuthorsForGeoCriteria3.stream().map(AuthorMarkerEntity::getName)) + assertThat(geoAuthorsForGeoCriteria3.stream().map(SearchHit::getContent).map(AuthorMarkerEntity::getName)) .containsExactlyInAnyOrder("Mohsin Husen", "Rizwan Idrees"); } @@ -268,12 +270,12 @@ public class ElasticsearchTemplateGeoTests { new Criteria("location").boundedBy(Geohash.stringEncode(0, 53.5171d), Geohash.stringEncode(0.2062d, 49.5171d))); // when - List geoAuthorsForGeoCriteria3 = operations.queryForList(geoLocationCriteriaQuery3, + SearchHits geoAuthorsForGeoCriteria3 = operations.search(geoLocationCriteriaQuery3, AuthorMarkerEntity.class, authorMarkerIndex); // then assertThat(geoAuthorsForGeoCriteria3).hasSize(2); - assertThat(geoAuthorsForGeoCriteria3.stream().map(AuthorMarkerEntity::getName)) + assertThat(geoAuthorsForGeoCriteria3.stream().map(SearchHit::getContent).map(AuthorMarkerEntity::getName)) .containsExactlyInAnyOrder("Mohsin Husen", "Rizwan Idrees"); } @@ -286,12 +288,12 @@ public class ElasticsearchTemplateGeoTests { new Criteria("location").boundedBy(new GeoPoint(53.5171d, 0), new GeoPoint(49.5171d, 0.2062d))); // when - List geoAuthorsForGeoCriteria3 = operations.queryForList(geoLocationCriteriaQuery3, + SearchHits geoAuthorsForGeoCriteria3 = operations.search(geoLocationCriteriaQuery3, AuthorMarkerEntity.class, authorMarkerIndex); // then assertThat(geoAuthorsForGeoCriteria3).hasSize(2); - assertThat(geoAuthorsForGeoCriteria3.stream().map(AuthorMarkerEntity::getName)) + assertThat(geoAuthorsForGeoCriteria3.stream().map(SearchHit::getContent).map(AuthorMarkerEntity::getName)) .containsExactlyInAnyOrder("Mohsin Husen", "Rizwan Idrees"); } @@ -304,12 +306,12 @@ public class ElasticsearchTemplateGeoTests { new Criteria("location").boundedBy(new Point(53.5171d, 0), new Point(49.5171d, 0.2062d))); // when - List geoAuthorsForGeoCriteria3 = operations.queryForList(geoLocationCriteriaQuery3, + SearchHits geoAuthorsForGeoCriteria3 = operations.search(geoLocationCriteriaQuery3, AuthorMarkerEntity.class, authorMarkerIndex); // then assertThat(geoAuthorsForGeoCriteria3).hasSize(2); - assertThat(geoAuthorsForGeoCriteria3.stream().map(AuthorMarkerEntity::getName)) + assertThat(geoAuthorsForGeoCriteria3.stream().map(SearchHit::getContent).map(AuthorMarkerEntity::getName)) .containsExactlyInAnyOrder("Mohsin Husen", "Rizwan Idrees"); } @@ -332,17 +334,17 @@ public class ElasticsearchTemplateGeoTests { .withFilter(QueryBuilders.geoBoundingBoxQuery("locationAsGeoHash").setCorners("u10j46mkfek")); // when - List result1 = operations.queryForList(location1.build(), LocationMarkerEntity.class, + SearchHits result1 = operations.search(location1.build(), LocationMarkerEntity.class, locationMarkerIndex); - List result2 = operations.queryForList(location2.build(), LocationMarkerEntity.class, + SearchHits result2 = operations.search(location2.build(), LocationMarkerEntity.class, locationMarkerIndex); - List result3 = operations.queryForList(location3.build(), LocationMarkerEntity.class, + SearchHits result3 = operations.search(location3.build(), LocationMarkerEntity.class, locationMarkerIndex); - List result4 = operations.queryForList(location4.build(), LocationMarkerEntity.class, + SearchHits result4 = operations.search(location4.build(), LocationMarkerEntity.class, locationMarkerIndex); - List result5 = operations.queryForList(location5.build(), LocationMarkerEntity.class, + SearchHits result5 = operations.search(location5.build(), LocationMarkerEntity.class, locationMarkerIndex); - List result11 = operations.queryForList(location11.build(), LocationMarkerEntity.class, + SearchHits result11 = operations.search(location11.build(), LocationMarkerEntity.class, locationMarkerIndex); // then diff --git a/src/test/java/org/springframework/data/elasticsearch/core/index/MappingBuilderTests.java b/src/test/java/org/springframework/data/elasticsearch/core/index/MappingBuilderTests.java index 33de2b84f..6cc8d75d1 100644 --- a/src/test/java/org/springframework/data/elasticsearch/core/index/MappingBuilderTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/index/MappingBuilderTests.java @@ -51,9 +51,11 @@ import org.springframework.data.annotation.Id; import org.springframework.data.annotation.Transient; import org.springframework.data.elasticsearch.annotations.*; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; -import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; +import org.springframework.data.elasticsearch.core.IndexOperations; +import org.springframework.data.elasticsearch.core.SearchHits; import org.springframework.data.elasticsearch.core.completion.Completion; import org.springframework.data.elasticsearch.core.geo.GeoPoint; +import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.IndexQuery; import org.springframework.data.elasticsearch.core.query.NativeSearchQuery; import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder; @@ -80,28 +82,31 @@ import org.springframework.test.context.ContextConfiguration; @ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class }) public class MappingBuilderTests extends MappingContextBaseTests { - @Autowired private ElasticsearchOperations elasticsearchTemplate; + @Autowired private ElasticsearchOperations operations; + private IndexOperations indexOperations; @BeforeEach public void before() { - elasticsearchTemplate.deleteIndex(StockPrice.class); - elasticsearchTemplate.deleteIndex(SimpleRecursiveEntity.class); - elasticsearchTemplate.deleteIndex(StockPrice.class); - elasticsearchTemplate.deleteIndex(SampleInheritedEntity.class); - elasticsearchTemplate.deleteIndex(User.class); - elasticsearchTemplate.deleteIndex(Group.class); - elasticsearchTemplate.deleteIndex(Book.class); - elasticsearchTemplate.deleteIndex(NormalizerEntity.class); - elasticsearchTemplate.deleteIndex(CopyToEntity.class); + indexOperations = operations.getIndexOperations(); + + indexOperations.deleteIndex(StockPrice.class); + indexOperations.deleteIndex(SimpleRecursiveEntity.class); + indexOperations.deleteIndex(StockPrice.class); + indexOperations.deleteIndex(SampleInheritedEntity.class); + indexOperations.deleteIndex(User.class); + indexOperations.deleteIndex(Group.class); + indexOperations.deleteIndex(Book.class); + indexOperations.deleteIndex(NormalizerEntity.class); + indexOperations.deleteIndex(CopyToEntity.class); } @Test public void shouldNotFailOnCircularReference() { - elasticsearchTemplate.createIndex(SimpleRecursiveEntity.class); - elasticsearchTemplate.putMapping(SimpleRecursiveEntity.class); - elasticsearchTemplate.refresh(SimpleRecursiveEntity.class); + indexOperations.createIndex(SimpleRecursiveEntity.class); + indexOperations.putMapping(SimpleRecursiveEntity.class); + indexOperations.refresh(SimpleRecursiveEntity.class); } @Test // DATAES-568 @@ -134,26 +139,26 @@ public class MappingBuilderTests extends MappingContextBaseTests { // Given // When - elasticsearchTemplate.createIndex(StockPrice.class); - elasticsearchTemplate.putMapping(StockPrice.class); + indexOperations.createIndex(StockPrice.class); + indexOperations.putMapping(StockPrice.class); String symbol = "AU"; double price = 2.34; String id = "abc"; - IndexCoordinates index = IndexCoordinates.of("test-index-stock-mapping-builder").withTypes( "price"); - elasticsearchTemplate.index(buildIndex(StockPrice.builder() // + IndexCoordinates index = IndexCoordinates.of("test-index-stock-mapping-builder").withTypes("price"); + operations.index(buildIndex(StockPrice.builder() // .id(id) // .symbol(symbol) // .price(BigDecimal.valueOf(price)) // .build()), index); - elasticsearchTemplate.refresh(StockPrice.class); + indexOperations.refresh(StockPrice.class); NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - List result = elasticsearchTemplate.queryForList(searchQuery, StockPrice.class, index); + SearchHits result = operations.search(searchQuery, StockPrice.class, index); // Then assertThat(result).hasSize(1); - StockPrice entry = result.get(0); + StockPrice entry = result.getSearchHit(0).getContent(); assertThat(entry.getSymbol()).isEqualTo(symbol); assertThat(entry.getPrice()).isCloseTo(BigDecimal.valueOf(price), Percentage.withPercentage(0.01)); } @@ -186,24 +191,23 @@ public class MappingBuilderTests extends MappingContextBaseTests { // given // when - elasticsearchTemplate.createIndex(SampleInheritedEntity.class); - elasticsearchTemplate.putMapping(SampleInheritedEntity.class); + indexOperations.createIndex(SampleInheritedEntity.class); + indexOperations.putMapping(SampleInheritedEntity.class); Date createdDate = new Date(); String message = "msg"; String id = "abc"; - IndexCoordinates index = IndexCoordinates.of("test-index-sample-inherited-mapping-builder").withTypes( "mapping"); - elasticsearchTemplate.index( - new SampleInheritedEntityBuilder(id).createdDate(createdDate).message(message).buildIndex(), + IndexCoordinates index = IndexCoordinates.of("test-index-sample-inherited-mapping-builder").withTypes("mapping"); + operations.index(new SampleInheritedEntityBuilder(id).createdDate(createdDate).message(message).buildIndex(), index); - elasticsearchTemplate.refresh(SampleInheritedEntity.class); + operations.refresh(SampleInheritedEntity.class); NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build(); - List result = elasticsearchTemplate.queryForList(searchQuery, SampleInheritedEntity.class, index); + SearchHits result = operations.search(searchQuery, SampleInheritedEntity.class, index); // then assertThat(result).hasSize(1); - SampleInheritedEntity entry = result.get(0); + SampleInheritedEntity entry = result.getSearchHit(0).getContent(); assertThat(entry.getCreatedDate()).isEqualTo(createdDate); assertThat(entry.getMessage()).isEqualTo(message); } @@ -228,10 +232,10 @@ public class MappingBuilderTests extends MappingContextBaseTests { public void shouldHandleReverseRelationship() { // given - elasticsearchTemplate.createIndex(User.class); - elasticsearchTemplate.putMapping(User.class); - elasticsearchTemplate.createIndex(Group.class); - elasticsearchTemplate.putMapping(Group.class); + indexOperations.createIndex(User.class); + indexOperations.putMapping(User.class); + indexOperations.createIndex(Group.class); + indexOperations.putMapping(Group.class); // when @@ -242,8 +246,8 @@ public class MappingBuilderTests extends MappingContextBaseTests { public void shouldMapBooks() { // given - elasticsearchTemplate.createIndex(Book.class); - elasticsearchTemplate.putMapping(Book.class); + indexOperations.createIndex(Book.class); + indexOperations.putMapping(Book.class); // when @@ -254,11 +258,11 @@ public class MappingBuilderTests extends MappingContextBaseTests { public void shouldUseBothAnalyzer() { // given - elasticsearchTemplate.createIndex(Book.class); - elasticsearchTemplate.putMapping(Book.class); + indexOperations.createIndex(Book.class); + indexOperations.putMapping(Book.class); // when - Map mapping = elasticsearchTemplate.getMapping(Book.class); + Map mapping = operations.getMapping(Book.class); Map descriptionMapping = (Map) ((Map) mapping.get("properties")).get("description"); Map prefixDescription = (Map) ((Map) descriptionMapping.get("fields")).get("prefix"); @@ -275,11 +279,11 @@ public class MappingBuilderTests extends MappingContextBaseTests { public void shouldUseKeywordNormalizer() { // given - elasticsearchTemplate.createIndex(NormalizerEntity.class); - elasticsearchTemplate.putMapping(NormalizerEntity.class); + operations.createIndex(NormalizerEntity.class); + operations.putMapping(NormalizerEntity.class); // when - Map mapping = elasticsearchTemplate.getMapping(NormalizerEntity.class); + Map mapping = operations.getMapping(NormalizerEntity.class); Map properties = (Map) mapping.get("properties"); Map fieldName = (Map) properties.get("name"); Map fieldDescriptionLowerCase = (Map) ((Map) ((Map) properties.get("description")).get("fields")).get("lower_case"); @@ -295,11 +299,11 @@ public class MappingBuilderTests extends MappingContextBaseTests { public void shouldUseCopyTo() { // given - elasticsearchTemplate.createIndex(CopyToEntity.class); - elasticsearchTemplate.putMapping(CopyToEntity.class); + operations.createIndex(CopyToEntity.class); + operations.putMapping(CopyToEntity.class); // when - Map mapping = elasticsearchTemplate.getMapping(CopyToEntity.class); + Map mapping = operations.getMapping(CopyToEntity.class); Map properties = (Map) mapping.get("properties"); Map fieldFirstName = (Map) properties.get("firstName"); Map fieldLastName = (Map) properties.get("lastName"); diff --git a/src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryTests.java b/src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryTests.java index 83643152b..ade03dcb9 100644 --- a/src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryTests.java @@ -42,6 +42,7 @@ import org.springframework.data.elasticsearch.annotations.Document; import org.springframework.data.elasticsearch.annotations.Field; import org.springframework.data.elasticsearch.annotations.Score; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; +import org.springframework.data.elasticsearch.core.SearchHit; import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration; import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest; @@ -93,7 +94,7 @@ public class CriteriaQueryTests { new Criteria("message").contains("test").and("message").contains("some")); // when - SampleEntity sampleEntity1 = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity1 = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(sampleEntity1).isNotNull(); @@ -136,7 +137,7 @@ public class CriteriaQueryTests { new Criteria("message").contains("some").or("message").contains("test")); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); @@ -167,7 +168,7 @@ public class CriteriaQueryTests { // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); @@ -198,7 +199,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria().or(new Criteria("message").contains("some"))); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); @@ -227,7 +228,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("some message")); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message"); @@ -269,7 +270,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("some message")); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message"); @@ -312,7 +313,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(criteria); // when - SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message"); @@ -354,7 +355,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(criteria); // when - SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message"); @@ -395,7 +396,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("contains")); // when - SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message"); @@ -436,7 +437,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").expression("+elasticsearch || test")); // when - SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message"); @@ -478,7 +479,7 @@ public class CriteriaQueryTests { new Criteria("message").startsWith("some").endsWith("search").contains("message").is("some message search")); // when - SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message"); @@ -519,12 +520,12 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("foo").not()); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(criteriaQuery.getCriteria().isNegating()).isTrue(); assertThat(page).isNotNull(); - assertThat(page.iterator().next().getMessage()).doesNotContain("foo"); + assertThat(page.iterator().next().getContent().getMessage()).doesNotContain("foo"); } @Test @@ -563,7 +564,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(100, 150)); // when - SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(sampleEntity).isNotNull(); @@ -605,7 +606,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(350, null)); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); @@ -648,7 +649,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(null, 550)); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); @@ -691,7 +692,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").lessThanEqual(750)); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); @@ -734,7 +735,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").greaterThanEqual(950)); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page).isNotNull(); @@ -777,7 +778,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("foo").boost(1)); // when - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page.getTotalElements()).isGreaterThanOrEqualTo(1); @@ -800,11 +801,11 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery( new Criteria("message").contains("a").or(new Criteria("message").contains("b"))); criteriaQuery.setMinScore(2.0F); - Page page = operations.queryForPage(criteriaQuery, SampleEntity.class, index); + Page> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index); // then assertThat(page.getTotalElements()).isEqualTo(1); - assertThat(page.getContent().get(0).getMessage()).isEqualTo("ab"); + assertThat(page.getContent().get(0).getContent().getMessage()).isEqualTo("ab"); } @Test // DATAES-213 @@ -826,7 +827,7 @@ public class CriteriaQueryTests { CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("Hello World!")); // when - SampleEntity sampleEntity1 = operations.queryForObject(criteriaQuery, SampleEntity.class, index); + SearchHit sampleEntity1 = operations.searchOne(criteriaQuery, SampleEntity.class, index); // then assertThat(sampleEntity1).isNotNull(); diff --git a/src/test/java/org/springframework/data/elasticsearch/repositories/custommethod/CustomMethodRepositoryBaseTests.java b/src/test/java/org/springframework/data/elasticsearch/repositories/custommethod/CustomMethodRepositoryBaseTests.java index 7374bfcf2..da38a6e57 100644 --- a/src/test/java/org/springframework/data/elasticsearch/repositories/custommethod/CustomMethodRepositoryBaseTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/repositories/custommethod/CustomMethodRepositoryBaseTests.java @@ -1333,6 +1333,20 @@ public abstract class CustomMethodRepositoryBaseTests { assertThat(stream.count()).isEqualTo(10L); } + @Test // DATAES-672 + void streamMethodShouldNotReturnSearchHits() { + // given + List entities = createSampleEntities("abc", 2); + repository.saveAll(entities); + + // when + Stream stream = streamingRepository.findByType("abc"); + + // then + assertThat(stream).isNotNull(); + stream.forEach(o -> assertThat(o).isInstanceOf(SampleEntity.class)); + } + private List createSampleEntities(String type, int numberOfEntities) { List entities = new ArrayList<>(); diff --git a/src/test/java/org/springframework/data/elasticsearch/repositories/setting/dynamic/DynamicSettingAndMappingEntityRepositoryTests.java b/src/test/java/org/springframework/data/elasticsearch/repositories/setting/dynamic/DynamicSettingAndMappingEntityRepositoryTests.java index 5bb26bd00..1b9d9e26b 100644 --- a/src/test/java/org/springframework/data/elasticsearch/repositories/setting/dynamic/DynamicSettingAndMappingEntityRepositoryTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/repositories/setting/dynamic/DynamicSettingAndMappingEntityRepositoryTests.java @@ -17,7 +17,6 @@ package org.springframework.data.elasticsearch.repositories.setting.dynamic; import static org.assertj.core.api.Assertions.*; -import java.util.List; import java.util.Map; import org.apache.commons.lang.RandomStringUtils; @@ -32,6 +31,7 @@ import org.springframework.data.elasticsearch.annotations.Document; import org.springframework.data.elasticsearch.annotations.Mapping; import org.springframework.data.elasticsearch.annotations.Setting; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; +import org.springframework.data.elasticsearch.core.SearchHits; import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.NativeSearchQuery; import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder; @@ -109,13 +109,14 @@ public class DynamicSettingAndMappingEntityRepositoryTests { IndexCoordinates index = IndexCoordinates.of("test-index-dynamic-setting-and-mapping") .withTypes("test-setting-type"); long count = operations.count(searchQuery, DynamicSettingAndMappingEntity.class, index); - List entityList = operations.queryForList(searchQuery, + SearchHits entityList = operations.search(searchQuery, DynamicSettingAndMappingEntity.class, index); // then assertThat(count).isEqualTo(1L); assertThat(entityList).isNotNull().hasSize(1); - assertThat(entityList.get(0).getEmail()).isEqualTo(dynamicSettingAndMappingEntity1.getEmail()); + assertThat(entityList.getSearchHit(0).getContent().getEmail()) + .isEqualTo(dynamicSettingAndMappingEntity1.getEmail()); } @Test diff --git a/src/test/java/org/springframework/data/elasticsearch/repositories/synonym/SynonymRepositoryTests.java b/src/test/java/org/springframework/data/elasticsearch/repositories/synonym/SynonymRepositoryTests.java index 469341a8b..54a2db4bf 100644 --- a/src/test/java/org/springframework/data/elasticsearch/repositories/synonym/SynonymRepositoryTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/repositories/synonym/SynonymRepositoryTests.java @@ -19,8 +19,6 @@ import static org.assertj.core.api.Assertions.*; import lombok.Data; -import java.util.List; - import org.elasticsearch.index.query.QueryBuilders; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -32,6 +30,7 @@ import org.springframework.data.elasticsearch.annotations.Document; import org.springframework.data.elasticsearch.annotations.Mapping; import org.springframework.data.elasticsearch.annotations.Setting; import org.springframework.data.elasticsearch.core.ElasticsearchOperations; +import org.springframework.data.elasticsearch.core.SearchHits; import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder; import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration; @@ -77,12 +76,11 @@ public class SynonymRepositoryTests { repository.save(entry1); repository.save(entry2); - // when - + // whe // then assertThat(repository.count()).isEqualTo(2L); - List synonymEntities = operations.queryForList( + SearchHits synonymEntities = operations.search( new NativeSearchQueryBuilder().withQuery(QueryBuilders.termQuery("text", "british")).build(), SynonymEntity.class, IndexCoordinates.of("test-index-synonym").withTypes("synonym-type")); assertThat(synonymEntities).hasSize(1);