Update elasticsearch driver version

CHANGELOG.adoc

@@ -8,6 +8,10 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version
 
 == [Unreleased]
 
+=== Changed
+
+- Update Elasticsearch driver to 8.17.4
+
 === Fixed
 
 -  Fixes delete all at CouchDB

jnosql-elasticsearch/pom.xml

@@ -28,8 +28,7 @@
     <description>The Eclipse JNoSQL layer to Elasticsearch</description>
 
     <properties>
-        <elasticsearch-java.version>8.14.3</elasticsearch-java.version>
-
+        <elasticsearch-java.version>8.17.4</elasticsearch-java.version>
     </properties>
     <dependencies>
         <dependency>

jnosql-elasticsearch/src/main/java/org/eclipse/jnosql/databases/elasticsearch/communication/QueryConverter.java

@@ -114,60 +114,65 @@ private static IndexMappingRecord getIndexMappingRecord(ElasticsearchClient clie
 
     private static Query.Builder getCondition(IndexMappingRecord indexMappingRecord, CriteriaCondition condition) {
         Element document = condition.element();
-
+        String fieldName = document.name();
+        JsonData value = JsonData.of(document.value().get());
         switch (condition.condition()) {
             case EQUALS:
-                if (supportTermQuery(indexMappingRecord, document.name())) {
+                if (supportTermQuery(indexMappingRecord, fieldName)) {
                     return (Query.Builder) new Query.Builder()
                             .term(TermQuery.of(tq -> tq
-                                    .field(document.name())
+                                    .field(fieldName)
                                     .value(v -> v
-                                            .anyValue(JsonData.of(document.value().get())))));
+                                            .anyValue(value))));
                 }
                 return (Query.Builder) new Query.Builder()
                         .match(MatchQuery.of(tq -> tq
-                                .field(document.name())
+                                .field(fieldName)
                                 .query(v -> v
-                                        .anyValue(JsonData.of(document.value().get())))));
+                                        .anyValue(value))));
             case LESSER_THAN:
                 return (Query.Builder) new Query.Builder()
                         .range(RangeQuery.of(rq -> rq
-                                .field(document.name())
-                                .lt(JsonData.of(document.value().get()))));
+                                .untyped(u -> u
+                                        .field(fieldName)
+                                        .lt(value))));
             case LESSER_EQUALS_THAN:
                 return (Query.Builder) new Query.Builder()
                         .range(RangeQuery.of(rq -> rq
-                                .field(document.name())
-                                .lte(JsonData.of(document.value().get()))));
+                                .untyped(u -> u
+                                        .field(fieldName)
+                                        .lte(value))));
             case GREATER_THAN:
                 return (Query.Builder) new Query.Builder()
                         .range(RangeQuery.of(rq -> rq
-                                .field(document.name())
-                                .gt(JsonData.of(document.value().get()))));
+                                .untyped(u -> u
+                                        .field(fieldName)
+                                        .gt(value))));
             case GREATER_EQUALS_THAN:
                 return (Query.Builder) new Query.Builder()
                         .range(RangeQuery.of(rq -> rq
-                                .field(document.name())
-                                .gte(JsonData.of(document.value().get()))));
+                                .untyped(u -> u
+                                        .field(fieldName)
+                                        .gte(value))));
             case LIKE:
                 return (Query.Builder) new Query.Builder()
                         .queryString(QueryStringQuery.of(rq -> rq
                                 .query(document.value().get(String.class))
                                 .allowLeadingWildcard(true)
-                                .fields(document.name())));
+                                .fields(fieldName)));
             case IN:
                 return (Query.Builder) ValueUtil.convertToList(document.value())
                         .stream()
                         .map(val -> {
-                            if (supportTermQuery(indexMappingRecord, document.name())) {
+                            if (supportTermQuery(indexMappingRecord, fieldName)) {
                                 return new Query.Builder()
                                         .term(TermQuery.of(tq -> tq
-                                                .field(document.name())
+                                                .field(fieldName)
                                                 .value(v -> v.anyValue(JsonData.of(val)))));
                             }
                             return new Query.Builder()
                                     .match(MatchQuery.of(tq -> tq
-                                            .field(document.name())
+                                            .field(fieldName)
                                             .query(v -> v.anyValue(JsonData.of(val)))));
                         })
                         .reduce((d1, d2) -> new Query.Builder()

jnosql-elasticsearch/src/test/java/org/eclipse/jnosql/databases/elasticsearch/communication/DocumentDatabase.java

@@ -43,7 +43,7 @@ public enum DocumentDatabase implements Supplier<ElasticsearchDocumentManagerFac
     INSTANCE;
 
     private final GenericContainer es =
-            new GenericContainer("docker.elastic.co/elasticsearch/elasticsearch:8.5.0")
+            new GenericContainer("docker.io/elastic/elasticsearch:8.15.0")
                     .withReuse(true)
                     .withExposedPorts(9200, 9300)
                     .withEnv("discovery.type", "single-node")

jnosql-elasticsearch/src/test/java/org/eclipse/jnosql/databases/elasticsearch/integration/Library.java

@@ -26,9 +26,10 @@
 @Repository
 public interface Library extends CrudRepository<Magazine, String> {
 
-    @Query("select * from Book where author.name = @name")
+    @Query("where author.name = :name")
     Stream<Magazine> findByAuthorName(@Param("name") String name);
 
     Stream<Magazine> findByTitleLike(String title);
 
+    Stream<Magazine> findByEditionGreaterThanEqual(int edition);
 }

jnosql-elasticsearch/src/test/java/org/eclipse/jnosql/databases/elasticsearch/integration/RepositoryIntegrationTest.java

@@ -214,5 +214,39 @@ public void shouldFindByTitleLike() {
                 .containsAll(allMagazines));
     }
 
+    @Test
+    public void shouldFindByEditionBetween() {
+        Author joshuaBloch = new Author("Joshua Bloch");
+        var magazine1 = new Magazine(randomUUID().toString(), "Effective Java", 1, joshuaBloch);
+        var magazine2 = magazine1.newEdition();
+        var magazine3 = magazine2.newEdition();
+        var magazine4 = magazine3.newEdition();
+        var magazine5 = magazine4.newEdition();
+        var magazine6 = magazine5.newEdition();
+        var magazine7 = magazine6.newEdition();
+
+        List<Magazine> allMagazines = List.of(
+                magazine1,
+                magazine2,
+                magazine3,
+                magazine4,
+                magazine5,
+                magazine6,
+                magazine7);
+
+        library.saveAll(allMagazines);
+
+        List<Magazine> magazinesGreaterThanEquals = allMagazines
+                .stream()
+                .dropWhile(m -> magazine3.edition() > m.edition())
+                .toList();
+
+        await().until(() ->
+                !library.findByEditionGreaterThanEqual(magazine3.edition()).toList().isEmpty());
+
+        var magazines = library.findByEditionGreaterThanEqual(magazine3.edition()).toList();
+        assertThat(magazines)
+                .containsAll(magazinesGreaterThanEquals);
+    }
 
 }