From 1ea9920a0d0661174d405b2a78d5fadfd73ce173 Mon Sep 17 00:00:00 2001 From: Kevin Leturc Date: Tue, 26 Aug 2014 16:44:21 +0200 Subject: [PATCH] DATAES-106 - Add support for countBy projection --- .../core/ElasticsearchOperations.java | 18 + .../core/ElasticsearchTemplate.java | 71 ++- .../query/ElasticsearchPartQuery.java | 3 + .../query/ElasticsearchQueryMethod.java | 8 +- .../ElasticsearchRepositoryFactory.java | 2 +- .../core/ElasticsearchTemplateTests.java | 157 ++++- .../CustomMethodRepositoryTests.java | 536 ++++++++++++++++++ .../custom/SampleCustomMethodRepository.java | 44 +- 8 files changed, 818 insertions(+), 21 deletions(-) diff --git a/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchOperations.java b/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchOperations.java index a1b6e2fe7..9ec2067e0 100755 --- a/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchOperations.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchOperations.java @@ -30,6 +30,7 @@ import org.springframework.data.elasticsearch.core.query.*; * * @author Rizwan Idrees * @author Mohsin Husen + * @author Kevin Leturc */ public interface ElasticsearchOperations { @@ -246,6 +247,23 @@ public interface ElasticsearchOperations { */ List queryForIds(SearchQuery query); + /** + * return number of elements found by given query + * + * @param query + * @param clazz + * @return + */ + long count(CriteriaQuery query, Class clazz); + + /** + * return number of elements found by given query + * + * @param query + * @return + */ + long count(CriteriaQuery query); + /** * return number of elements found by given query * 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 749bcdc88..0d6d91810 100755 --- a/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplate.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplate.java @@ -50,6 +50,7 @@ import org.elasticsearch.action.index.IndexRequestBuilder; import org.elasticsearch.action.mlt.MoreLikeThisRequestBuilder; import org.elasticsearch.action.search.SearchRequestBuilder; import org.elasticsearch.action.search.SearchResponse; +import org.elasticsearch.action.search.SearchType; import org.elasticsearch.action.update.UpdateRequestBuilder; import org.elasticsearch.action.update.UpdateResponse; import org.elasticsearch.client.Client; @@ -96,6 +97,7 @@ import org.springframework.util.Assert; * @author Rizwan Idrees * @author Mohsin Husen * @author Artur Konczak + * @author Kevin Leturc */ public class ElasticsearchTemplate implements ElasticsearchOperations, ApplicationContextAware { @@ -317,10 +319,65 @@ public class ElasticsearchTemplate implements ElasticsearchOperations, Applicati return mapper.mapResults(response, clazz, query.getPageable()); } + @Override + public long count(CriteriaQuery criteriaQuery, Class clazz) { + QueryBuilder elasticsearchQuery = new CriteriaQueryProcessor().createQueryFromCriteria(criteriaQuery.getCriteria()); + FilterBuilder elasticsearchFilter = new CriteriaFilterProcessor().createFilterFromCriteria(criteriaQuery.getCriteria()); + + if (elasticsearchFilter == null) { + return doCount(prepareCount(criteriaQuery, clazz), elasticsearchQuery); + } else { + // filter could not be set into CountRequestBuilder, convert request into search request + return doCount(prepareSearch(criteriaQuery, clazz), elasticsearchQuery, elasticsearchFilter); + } + } + @Override public long count(SearchQuery searchQuery, Class clazz) { - String indexName[] = isNotEmpty(searchQuery.getIndices()) ? searchQuery.getIndices().toArray(new String[searchQuery.getIndices().size()]) : retrieveIndexNameFromPersistentEntity(clazz); - String types[] = isNotEmpty(searchQuery.getTypes()) ? searchQuery.getTypes().toArray(new String[searchQuery.getTypes().size()]) : retrieveTypeFromPersistentEntity(clazz); + QueryBuilder elasticsearchQuery = searchQuery.getQuery(); + FilterBuilder elasticsearchFilter = searchQuery.getFilter(); + + if (elasticsearchFilter == null) { + return doCount(prepareCount(searchQuery, clazz), elasticsearchQuery); + } else { + // filter could not be set into CountRequestBuilder, convert request into search request + return doCount(prepareSearch(searchQuery, clazz), elasticsearchQuery, elasticsearchFilter); + } + } + + @Override + public long count(CriteriaQuery query) { + return count(query, null); + } + + @Override + public long count(SearchQuery query) { + return count(query, null); + } + + private long doCount(CountRequestBuilder countRequestBuilder, QueryBuilder elasticsearchQuery) { + if (elasticsearchQuery != null) { + countRequestBuilder.setQuery(elasticsearchQuery); + } + return countRequestBuilder.execute().actionGet().getCount(); + } + + private long doCount(SearchRequestBuilder searchRequestBuilder, QueryBuilder elasticsearchQuery, FilterBuilder elasticsearchFilter) { + if (elasticsearchQuery != null) { + searchRequestBuilder.setQuery(elasticsearchQuery); + } else { + searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery()); + } + if (elasticsearchFilter != null) { + searchRequestBuilder.setPostFilter(elasticsearchFilter); + } + searchRequestBuilder.setSearchType(SearchType.COUNT); + return searchRequestBuilder.execute().actionGet().getHits().getTotalHits(); + } + + private CountRequestBuilder prepareCount(Query query, Class clazz) { + String indexName[] = isNotEmpty(query.getIndices()) ? query.getIndices().toArray(new String[query.getIndices().size()]) : retrieveIndexNameFromPersistentEntity(clazz); + String types[] = isNotEmpty(query.getTypes()) ? query.getTypes().toArray(new String[query.getTypes().size()]) : retrieveTypeFromPersistentEntity(clazz); Assert.notNull(indexName, "No index defined for Query"); @@ -329,15 +386,7 @@ public class ElasticsearchTemplate implements ElasticsearchOperations, Applicati if (types != null) { countRequestBuilder.setTypes(types); } - if (searchQuery.getQuery() != null) { - countRequestBuilder.setQuery(searchQuery.getQuery()); - } - return countRequestBuilder.execute().actionGet().getCount(); - } - - @Override - public long count(SearchQuery query) { - return count(query, null); + return countRequestBuilder; } @Override 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 9888e6991..61d89a043 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 @@ -28,6 +28,7 @@ import org.springframework.data.repository.query.parser.PartTree; * * @author Rizwan Idrees * @author Mohsin Husen + * @author Kevin Leturc */ public class ElasticsearchPartQuery extends AbstractElasticsearchRepositoryQuery { @@ -52,6 +53,8 @@ public class ElasticsearchPartQuery extends AbstractElasticsearchRepositoryQuery query.setPageable(accessor.getPageable()); } return elasticsearchOperations.queryForList(query, queryMethod.getEntityInformation().getJavaType()); + } else if (tree.isCountProjection()) { + return elasticsearchOperations.count(query, queryMethod.getEntityInformation().getJavaType()); } return elasticsearchOperations.queryForObject(query, queryMethod.getEntityInformation().getJavaType()); } diff --git a/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchQueryMethod.java b/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchQueryMethod.java index 3d29735cd..aa731d579 100644 --- a/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchQueryMethod.java +++ b/src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchQueryMethod.java @@ -19,8 +19,6 @@ import java.lang.reflect.Method; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.data.elasticsearch.annotations.Query; -import org.springframework.data.elasticsearch.repository.support.ElasticsearchEntityInformation; -import org.springframework.data.elasticsearch.repository.support.ElasticsearchEntityInformationCreator; import org.springframework.data.repository.core.RepositoryMetadata; import org.springframework.data.repository.query.QueryMethod; import org.springframework.util.StringUtils; @@ -33,14 +31,10 @@ import org.springframework.util.StringUtils; */ public class ElasticsearchQueryMethod extends QueryMethod { - private final ElasticsearchEntityInformation entityInformation; private Method method; - public ElasticsearchQueryMethod(Method method, RepositoryMetadata metadata, - ElasticsearchEntityInformationCreator elasticsearchEntityInformationCreator) { + public ElasticsearchQueryMethod(Method method, RepositoryMetadata metadata) { super(method, metadata); - this.entityInformation = elasticsearchEntityInformationCreator.getEntityInformation(metadata - .getReturnedDomainClass(method)); this.method = method; } diff --git a/src/main/java/org/springframework/data/elasticsearch/repository/support/ElasticsearchRepositoryFactory.java b/src/main/java/org/springframework/data/elasticsearch/repository/support/ElasticsearchRepositoryFactory.java index a874856c3..b881a5d8e 100644 --- a/src/main/java/org/springframework/data/elasticsearch/repository/support/ElasticsearchRepositoryFactory.java +++ b/src/main/java/org/springframework/data/elasticsearch/repository/support/ElasticsearchRepositoryFactory.java @@ -105,7 +105,7 @@ public class ElasticsearchRepositoryFactory extends RepositoryFactorySupport { @Override public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, NamedQueries namedQueries) { - ElasticsearchQueryMethod queryMethod = new ElasticsearchQueryMethod(method, metadata, entityInformationCreator); + ElasticsearchQueryMethod queryMethod = new ElasticsearchQueryMethod(method, metadata); String namedQueryName = queryMethod.getNamedQueryName(); if (namedQueries.hasQuery(namedQueryName)) { 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 c5b3bc637..f214c0eff 100755 --- a/src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java @@ -58,6 +58,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; * @author Mohsin Husen * @author Franck Marchand * @author Abdul Mohammed + * @author Kevin Leturc */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:elasticsearch-template-test.xml") @@ -80,6 +81,26 @@ public class ElasticsearchTemplateTests { elasticsearchTemplate.refresh(SampleEntity.class, true); } + /* + DATAES-106 + */ + @Test + public void shouldReturnCountForGivenCriteriaQuery() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message") + .version(System.currentTimeMillis()).build(); + + IndexQuery indexQuery = getIndexQuery(sampleEntity); + elasticsearchTemplate.index(indexQuery); + elasticsearchTemplate.refresh(SampleEntity.class, true); + CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); + // when + long count = elasticsearchTemplate.count(criteriaQuery, SampleEntity.class); + // then + assertThat(count, is(equalTo(1L))); + } + @Test public void shouldReturnCountForGivenSearchQuery() { // given @@ -1187,6 +1208,27 @@ public class ElasticsearchTemplateTests { assertThat(sampleEntities.getTotalElements(), greaterThanOrEqualTo(1L)); } + /* + DATAES-106 + */ + @Test + public void shouldReturnCountForGivenCriteriaQueryWithGivenIndexUsingCriteriaQuery() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message") + .version(System.currentTimeMillis()).build(); + + IndexQuery indexQuery = getIndexQuery(sampleEntity); + elasticsearchTemplate.index(indexQuery); + elasticsearchTemplate.refresh(SampleEntity.class, true); + CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); + criteriaQuery.addIndices("test-index"); + // when + long count = elasticsearchTemplate.count(criteriaQuery); + // then + assertThat(count, is(equalTo(1L))); + } + /* DATAES-67 */ @@ -1210,6 +1252,28 @@ public class ElasticsearchTemplateTests { assertThat(count, is(equalTo(1L))); } + /* + DATAES-106 + */ + @Test + public void shouldReturnCountForGivenCriteriaQueryWithGivenIndexAndTypeUsingCriteriaQuery() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message") + .version(System.currentTimeMillis()).build(); + + IndexQuery indexQuery = getIndexQuery(sampleEntity); + elasticsearchTemplate.index(indexQuery); + elasticsearchTemplate.refresh(SampleEntity.class, true); + CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); + criteriaQuery.addIndices("test-index"); + criteriaQuery.addTypes("test-type"); + // when + long count = elasticsearchTemplate.count(criteriaQuery); + // then + assertThat(count, is(equalTo(1L))); + } + /* DATAES-67 */ @@ -1234,6 +1298,43 @@ public class ElasticsearchTemplateTests { assertThat(count, is(equalTo(1L))); } + /* + DATAES-106 + */ + @Test + public void shouldReturnCountForGivenCriteriaQueryWithGivenMultiIndices() { + // given + cleanUpIndices(); + String documentId1 = randomNumeric(5); + SampleEntity sampleEntity1 = new SampleEntityBuilder(documentId1).message("some message") + .version(System.currentTimeMillis()).build(); + + IndexQuery indexQuery1 = new IndexQueryBuilder().withId(sampleEntity1.getId()) + .withIndexName("test-index-1") + .withObject(sampleEntity1) + .build(); + + String documentId2 = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntityBuilder(documentId2).message("some test message") + .version(System.currentTimeMillis()).build(); + + IndexQuery indexQuery2 = new IndexQueryBuilder().withId(sampleEntity2.getId()) + .withIndexName("test-index-2") + .withObject(sampleEntity2) + .build(); + + elasticsearchTemplate.bulkIndex(Arrays.asList(indexQuery1, indexQuery2)); + elasticsearchTemplate.refresh("test-index-1", true); + elasticsearchTemplate.refresh("test-index-2", true); + + CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); + criteriaQuery.addIndices("test-index-1", "test-index-2"); + // when + long count = elasticsearchTemplate.count(criteriaQuery); + // then + assertThat(count, is(equalTo(2L))); + } + /* DATAES-67 */ @@ -1310,6 +1411,43 @@ public class ElasticsearchTemplateTests { assertThat(elasticsearchTemplate.indexExists("test-index"), is(false)); } + /* + DATAES-106 + */ + @Test + public void shouldReturnCountForGivenCriteriaQueryWithGivenIndexNameForSpecificIndex() { + // given + cleanUpIndices(); + String documentId1 = randomNumeric(5); + SampleEntity sampleEntity1 = new SampleEntityBuilder(documentId1).message("some message") + .version(System.currentTimeMillis()).build(); + + IndexQuery indexQuery1 = new IndexQueryBuilder().withId(sampleEntity1.getId()) + .withIndexName("test-index-1") + .withObject(sampleEntity1) + .build(); + + String documentId2 = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntityBuilder(documentId2).message("some test message") + .version(System.currentTimeMillis()).build(); + + IndexQuery indexQuery2 = new IndexQueryBuilder().withId(sampleEntity2.getId()) + .withIndexName("test-index-2") + .withObject(sampleEntity2) + .build(); + + elasticsearchTemplate.bulkIndex(Arrays.asList(indexQuery1, indexQuery2)); + elasticsearchTemplate.refresh("test-index-1", true); + elasticsearchTemplate.refresh("test-index-2", true); + + CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); + criteriaQuery.addIndices("test-index-1"); + // when + long count = elasticsearchTemplate.count(criteriaQuery); + // then + assertThat(count, is(equalTo(1L))); + } + /* DATAES-67 */ @@ -1349,11 +1487,28 @@ public class ElasticsearchTemplateTests { assertThat(count, is(equalTo(1L))); } + @Test(expected = IllegalArgumentException.class) + public void shouldThrowAnExceptionForGivenCriteriaQueryWhenNoIndexSpecifiedForCountQuery() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message") + .version(System.currentTimeMillis()).build(); + + IndexQuery indexQuery = getIndexQuery(sampleEntity); + elasticsearchTemplate.index(indexQuery); + elasticsearchTemplate.refresh(SampleEntity.class, true); + CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria()); + // when + long count = elasticsearchTemplate.count(criteriaQuery); + // then + assertThat(count, is(equalTo(1L))); + } + /* DATAES-67 */ @Test(expected = IllegalArgumentException.class) - public void shouldThrowAnExceptionWhenNoIndexSpecifiedForCountQuery() { + public void shouldThrowAnExceptionForGivenSearchQueryWhenNoIndexSpecifiedForCountQuery() { // given String documentId = randomNumeric(5); SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message") diff --git a/src/test/java/org/springframework/data/elasticsearch/repositories/CustomMethodRepositoryTests.java b/src/test/java/org/springframework/data/elasticsearch/repositories/CustomMethodRepositoryTests.java index 90861b637..590d60953 100644 --- a/src/test/java/org/springframework/data/elasticsearch/repositories/CustomMethodRepositoryTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/repositories/CustomMethodRepositoryTests.java @@ -44,6 +44,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; * @author Rizwan Idrees * @author Mohsin Husen * @author Franck Marchand + * @author Kevin Leturc */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:custom-method-repository-test.xml") @@ -589,5 +590,540 @@ public class CustomMethodRepositoryTests { assertThat(page, is(notNullValue())); assertThat(page.getTotalElements(), is(equalTo(1L))); } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethod() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setMessage("some message"); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test2"); + sampleEntity2.setMessage("some message"); + + repository.save(sampleEntity2); + + // when + long count = repository.countByType("test"); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodForNot() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("some"); + sampleEntity.setMessage("some message"); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setMessage("some message"); + + repository.save(sampleEntity2); + + // when + long count = repository.countByTypeNot("test"); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithBooleanParameter() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setMessage("foo"); + sampleEntity.setAvailable(true); + repository.save(sampleEntity); + + // given + String documentId2 = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId2); + sampleEntity2.setType("test"); + sampleEntity2.setMessage("bar"); + sampleEntity2.setAvailable(false); + repository.save(sampleEntity2); + // when + long count = repository.countByAvailable(false); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithLessThan() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("some message"); + repository.save(sampleEntity); + + String documentId2 = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId2); + sampleEntity2.setType("test"); + sampleEntity2.setRate(20); + sampleEntity2.setMessage("some message"); + repository.save(sampleEntity2); + + // when + long count = repository.countByRateLessThan(10); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithBefore() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("some message"); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(20); + sampleEntity2.setMessage("some message"); + + repository.save(sampleEntity2); + + // when + long count = repository.countByRateBefore(10); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithAfter() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("some message"); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(0); + sampleEntity2.setMessage("some message"); + + repository.save(sampleEntity2); + + // when + long count = repository.countByRateAfter(10); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithLike() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("foo"); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(10); + sampleEntity2.setMessage("some message"); + + repository.save(sampleEntity2); + + // when + long count = repository.countByMessageLike("fo"); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodForStartingWith() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("foo"); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(10); + sampleEntity2.setMessage("some message"); + + repository.save(sampleEntity2); + + // when + long count = repository.countByMessageStartingWith("fo"); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodForEndingWith() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("foo"); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(10); + sampleEntity2.setMessage("some message"); + + repository.save(sampleEntity2); + + // when + long count = repository.countByMessageEndingWith("o"); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodForContains() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("foo"); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(10); + sampleEntity2.setMessage("some message"); + + repository.save(sampleEntity2); + + // when + long count = repository.countByMessageContaining("fo"); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodForIn() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setMessage("foo"); + repository.save(sampleEntity); + + // given + String documentId2 = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId2); + sampleEntity2.setType("test"); + sampleEntity2.setMessage("bar"); + repository.save(sampleEntity2); + + List ids = Arrays.asList(documentId, documentId2); + + // when + long count = repository.countByIdIn(ids); + // then + assertThat(count, is(equalTo(2L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodForNotIn() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setMessage("foo"); + repository.save(sampleEntity); + + // given + String documentId2 = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId2); + sampleEntity2.setType("test"); + sampleEntity2.setMessage("bar"); + repository.save(sampleEntity2); + + List ids = Arrays.asList(documentId); + + // when + long count = repository.countByIdNotIn(ids); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodForTrue() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setMessage("foo"); + sampleEntity.setAvailable(true); + repository.save(sampleEntity); + + // given + String documentId2 = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId2); + sampleEntity2.setType("test"); + sampleEntity2.setMessage("bar"); + sampleEntity2.setAvailable(false); + repository.save(sampleEntity2); + // when + long count = repository.countByAvailableTrue(); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodForFalse() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setMessage("foo"); + sampleEntity.setAvailable(true); + repository.save(sampleEntity); + + // given + String documentId2 = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId2); + sampleEntity2.setType("test"); + sampleEntity2.setMessage("bar"); + sampleEntity2.setAvailable(false); + repository.save(sampleEntity2); + // when + long count = repository.countByAvailableFalse(); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithWithinGeoPoint() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("foo"); + sampleEntity.setLocation(new GeoPoint(45.7806d, 3.0875d)); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(10); + sampleEntity2.setMessage("foo"); + sampleEntity2.setLocation(new GeoPoint(30.7806d, 0.0875d)); + + repository.save(sampleEntity2); + + // when + long count = repository.countByLocationWithin(new GeoPoint(45.7806d, 3.0875d), "2km"); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithWithinPoint() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("foo"); + sampleEntity.setLocation(new GeoPoint(45.7806d, 3.0875d)); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(10); + sampleEntity2.setMessage("foo"); + sampleEntity2.setLocation(new GeoPoint(30.7806d, 0.0875d)); + + repository.save(sampleEntity2); + + // when + long count = repository.countByLocationWithin(new Point(3.0875d, 45.7806d), new Distance(2, Metrics.KILOMETERS)); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithNearBox() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("foo"); + sampleEntity.setLocation(new GeoPoint(45.7806d, 3.0875d)); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test2"); + sampleEntity2.setRate(10); + sampleEntity2.setMessage("foo"); + sampleEntity2.setLocation(new GeoPoint(30.7806d, 0.0875d)); + + repository.save(sampleEntity2); + + // when + long count = repository.countByLocationNear(new Box(new Point(3d, 46d), new Point(4d, 45d))); + // then + assertThat(count, is(equalTo(1L))); + } + + /* + DATAES-106 + */ + @Test + public void shouldCountCustomMethodWithNearPointAndDistance() { + // given + String documentId = randomNumeric(5); + SampleEntity sampleEntity = new SampleEntity(); + sampleEntity.setId(documentId); + sampleEntity.setType("test"); + sampleEntity.setRate(10); + sampleEntity.setMessage("foo"); + sampleEntity.setLocation(new GeoPoint(45.7806d, 3.0875d)); + + repository.save(sampleEntity); + + documentId = randomNumeric(5); + SampleEntity sampleEntity2 = new SampleEntity(); + sampleEntity2.setId(documentId); + sampleEntity2.setType("test"); + sampleEntity2.setRate(10); + sampleEntity2.setMessage("foo"); + sampleEntity2.setLocation(new GeoPoint(30.7806d, 0.0875d)); + + repository.save(sampleEntity2); + + // when + long count = repository.countByLocationNear(new Point(3.0875d, 45.7806d), new Distance(2, Metrics.KILOMETERS)); + // then + assertThat(count, is(equalTo(1L))); + } + } diff --git a/src/test/java/org/springframework/data/elasticsearch/repositories/custom/SampleCustomMethodRepository.java b/src/test/java/org/springframework/data/elasticsearch/repositories/custom/SampleCustomMethodRepository.java index 7cf997e48..78ea15e4f 100644 --- a/src/test/java/org/springframework/data/elasticsearch/repositories/custom/SampleCustomMethodRepository.java +++ b/src/test/java/org/springframework/data/elasticsearch/repositories/custom/SampleCustomMethodRepository.java @@ -31,6 +31,7 @@ import org.springframework.data.geo.Point; /** * @author Rizwan Idrees * @author Mohsin Husen + * @author Kevin Leturc */ public interface SampleCustomMethodRepository extends ElasticsearchRepository { @@ -62,7 +63,7 @@ public interface SampleCustomMethodRepository extends ElasticsearchRepository findByIdIn(List ids, Pageable pageable); - Page findByIdNotIn(List messages, Pageable pageable); + Page findByIdNotIn(List ids, Pageable pageable); Page findByAvailableTrue(Pageable pageable); @@ -81,4 +82,45 @@ public interface SampleCustomMethodRepository extends ElasticsearchRepository findByLocationNear(Point point, Distance distance, Pageable pageable); Page findByLocationNear(GeoPoint point, String distance, Pageable pageable); + + long countByType(String type); + + long countByTypeNot(String type); + + long countByAvailable(boolean available); + + long countByRateLessThan(int rate); + + long countByRateBefore(int rate); + + long countByRateAfter(int rate); + + long countByMessageLike(String message); + + long countByMessageStartingWith(String message); + + long countByMessageEndingWith(String message); + + long countByMessageContaining(String message); + + long countByIdIn(List ids); + + long countByIdNotIn(List ids); + + long countByAvailableTrue(); + + long countByAvailableFalse(); + + long countByLocationWithin(GeoPoint point, String distance); + + long countByLocationWithin(Point point, Distance distance); + + long countByLocationNear(GeoBox box); + + long countByLocationNear(Box box); + + long countByLocationNear(Point point, Distance distance); + + long countByLocationNear(GeoPoint point, String distance); + }