Merge pull request #156 from eclipse/sort_es

Enable Sort of Elastic Search

Author: otaviojava

elasticsearch-driver/src/main/java/org/eclipse/jnosql/diana/elasticsearch/document/DefaultElasticsearchDocumentCollectionManager.java

@@ -110,7 +110,6 @@ public Iterable<DocumentEntity> update(Iterable<DocumentEntity> entities) {
     public void delete(DocumentDeleteQuery query) throws NullPointerException {
         requireNonNull(query, "query is required");
 
-        query.getCondition().orElseThrow(() -> new IllegalArgumentException("condition is required"));
         DocumentQuery select = new ElasticsearchDocumentQuery(query);
 
         List<DocumentEntity> entities = select(select).collect(Collectors.toList());

elasticsearch-driver/src/main/java/org/eclipse/jnosql/diana/elasticsearch/document/EntityConverter.java

@@ -27,6 +27,7 @@
 import org.elasticsearch.client.RequestOptions;
 import org.elasticsearch.client.RestHighLevelClient;
 import org.elasticsearch.search.builder.SearchSourceBuilder;
+import org.elasticsearch.search.sort.SortOrder;
 
 import java.io.IOException;
 import java.util.HashMap;
@@ -35,6 +36,7 @@
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
+import static jakarta.nosql.SortType.ASC;
 import static java.util.Collections.singletonMap;
 import static java.util.stream.Collectors.toList;
 
@@ -79,10 +81,8 @@ static Stream<DocumentEntity> query(DocumentQuery query, RestHighLevelClient cli
     private static Stream<DocumentEntity> executeStatement(DocumentQuery query, RestHighLevelClient client, String index,
                                                            QueryConverterResult select) throws IOException {
         SearchRequest searchRequest = new SearchRequest(index);
-        if (select.hasQuery()) {
-            setQueryBuilder(query, select, searchRequest);
-        }
 
+        setQueryBuilder(query, select, searchRequest);
         SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
         return Stream.of(response.getHits())
                 .flatMap(h -> Stream.of(h.getHits()))
@@ -172,15 +172,31 @@ private static Stream<DocumentEntity> executeId(RestHighLevelClient client, Stri
 
     private static void setQueryBuilder(DocumentQuery query, QueryConverterResult select, SearchRequest searchRequest) {
         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
-        searchSourceBuilder.query(select.getStatement());
+
+        if (select.hasQuery()) {
+            searchSourceBuilder.query(select.getStatement());
+        }
+        feedBuilder(query, searchSourceBuilder);
+
         searchRequest.source(searchSourceBuilder);
+    }
+
+    private static void feedBuilder(DocumentQuery query, SearchSourceBuilder searchSource) {
+        query.getSorts().forEach(d -> {
+            if (ASC.equals(d.getType())) {
+                searchSource.sort(d.getName(), SortOrder.ASC);
+            } else {
+                searchSource.sort(d.getName(), SortOrder.DESC);
+            }
+        });
+
         int from = (int) query.getSkip();
         int size = (int) query.getLimit();
         if (from > 0) {
-            searchSourceBuilder.from(from);
+            searchSource.from(from);
         }
         if (size > 0) {
-            searchSourceBuilder.size(size);
+            searchSource.size(size);
         }
     }
 

elasticsearch-driver/src/test/java/org/eclipse/jnosql/diana/elasticsearch/document/ElasticsearchDocumentCollectionManagerTest.java

@@ -21,13 +21,17 @@
 import jakarta.nosql.document.DocumentQuery;
 import org.eclipse.jnosql.diana.document.Documents;
 import org.elasticsearch.index.query.TermQueryBuilder;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.testcontainers.shaded.org.apache.commons.lang.text.StrBuilder;
 
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
 import static jakarta.nosql.document.DocumentDeleteQuery.delete;
@@ -38,6 +42,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -54,6 +59,10 @@ public void setUp() {
         ElasticsearchDocumentCollectionManagerFactory managerFactory = ElasticsearchDocumentCollectionManagerFactorySupplier.INSTANCE.get();
         entityManager = managerFactory.get(DocumentEntityGerator.INDEX);
 
+        DocumentDeleteQuery deleteQuery = DocumentDeleteQuery.delete().from("person").build();
+
+        entityManager.delete(deleteQuery);
+
     }
 
     @Test
@@ -76,10 +85,11 @@ public void shouldInsertTTL() {
     }
 
     @Test
-    public void shouldReturnAll() {
+    public void shouldReturnAll() throws InterruptedException {
         DocumentEntity entity = DocumentEntityGerator.getEntity();
         entityManager.insert(entity);
         DocumentQuery query = select().from(DocumentEntityGerator.COLLECTION_NAME).build();
+        SECONDS.sleep(1L);
         List<DocumentEntity> result = entityManager.select(query).collect(Collectors.toList());
         assertFalse(result.isEmpty());
     }
@@ -161,6 +171,45 @@ public void shouldFindDocumentById() {
         assertThat(entities, contains(entity));
     }
 
+    @Test
+    public void shouldFindOrderByName() throws InterruptedException {
+        final DocumentEntity poliana = DocumentEntityGerator.getEntity();
+        final DocumentEntity otavio = DocumentEntityGerator.getEntity();
+        poliana.add("name", "poliana");
+        otavio.add("name", "otavio");
+        otavio.add("_id", "id2");
+        entityManager.insert(Arrays.asList(poliana, otavio));
+        SECONDS.sleep(1L);
+        DocumentQuery query = DocumentQuery.select().from("person").orderBy("name").asc().build();
+        String[] names = entityManager.select(query).map(d -> d.find("name"))
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .map(d -> d.get(String.class))
+                .toArray(String[]::new);
+
+        assertArrayEquals(names, new String[]{"otavio", "poliana"});
+    }
+
+    @Test
+    public void shouldFindOrderByNameDesc() throws InterruptedException {
+        final DocumentEntity poliana = DocumentEntityGerator.getEntity();
+        final DocumentEntity otavio = DocumentEntityGerator.getEntity();
+        poliana.add("name", "poliana");
+        otavio.add("name", "otavio");
+        otavio.add("_id", "id2");
+        entityManager.insert(Arrays.asList(poliana, otavio));
+        SECONDS.sleep(1L);
+        DocumentQuery query = DocumentQuery.select().from("person").orderBy("name").desc().build();
+        String[] names = entityManager.select(query).map(d -> d.find("name"))
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .map(d -> d.get(String.class))
+                .toArray(String[]::new);
+
+        assertArrayEquals(names, new String[]{"poliana", "otavio"});
+    }
+
+
     @Test
     public void shouldFindAll() throws InterruptedException {
         entityManager.insert(DocumentEntityGerator.getEntity());