feat: create an option to dynamic query method

Signed-off-by: Otavio Santana <otaviopolianasantana@gmail.com>
eclipse · May 19, 2024 · 8dd4ecd · 8dd4ecd
1 parent f4d68d6
commit 8dd4ecd
Show file tree

Hide file tree

Showing 3 changed files with 55 additions and 2 deletions.
diff --git a/...re/src/main/java/org/eclipse/jnosql/mapping/core/repository/DynamicQueryMethodReturn.java b/...re/src/main/java/org/eclipse/jnosql/mapping/core/repository/DynamicQueryMethodReturn.java
@@ -34,14 +34,16 @@ public final class DynamicQueryMethodReturn implements MethodDynamicExecutable {
     private final Class<?> typeClass;
     private final java.util.function.Function<String, Stream<?>> queryConverter;
     private final Function<String, PreparedStatement> prepareConverter;
+    private final boolean count;
 
     private DynamicQueryMethodReturn(Method method, Object[] args, Class<?> typeClass, Function<String, Stream<?>> queryConverter,
-                                     Function<String, PreparedStatement> prepareConverter) {
+                                     Function<String, PreparedStatement> prepareConverter, boolean count) {
         this.method = method;
         this.args = args;
         this.typeClass = typeClass;
         this.queryConverter = queryConverter;
         this.prepareConverter = prepareConverter;
+        this.count = count;
     }
 
     Method method() {
@@ -64,6 +66,10 @@ Function<String, PreparedStatement> prepareConverter() {
         return prepareConverter;
     }
 
+    boolean isCount() {
+        return count;
+    }
+
     public static DynamicQueryMethodReturnBuilder builder() {
         return new DynamicQueryMethodReturnBuilder();
     }
@@ -85,6 +91,8 @@ public static final class DynamicQueryMethodReturnBuilder {
 
         private Function<String, PreparedStatement> prepareConverter;
 
+        private boolean count;
+
         private DynamicQueryMethodReturnBuilder() {
         }
 
@@ -115,13 +123,18 @@ public DynamicQueryMethodReturnBuilder withPrepareConverter(Function<String, Pre
             return this;
         }
 
+        public DynamicQueryMethodReturnBuilder withCount(boolean count) {
+            this.count = count;
+            return this;
+        }
+
         public DynamicQueryMethodReturn build() {
             Objects.requireNonNull(method, "method is required");
             Objects.requireNonNull(typeClass, "typeClass is required");
             Objects.requireNonNull(queryConverter, "queryConverter is required");
             Objects.requireNonNull(prepareConverter, "prepareConverter is required");
 
-            return new DynamicQueryMethodReturn(method, args, typeClass, queryConverter, prepareConverter);
+            return new DynamicQueryMethodReturn(method, args, typeClass, queryConverter, prepareConverter, count);
         }
     }
 

diff --git a/...core/src/main/java/org/eclipse/jnosql/mapping/core/repository/DynamicReturnConverter.java b/...core/src/main/java/org/eclipse/jnosql/mapping/core/repository/DynamicReturnConverter.java
@@ -77,6 +77,16 @@ public Object convert(DynamicQueryMethodReturn dynamicQueryMethod) {
 
         String value = RepositoryReflectionUtils.INSTANCE.getQuery(method);
 
+        if(dynamicQueryMethod.isCount()){
+            Map<String, Object> params = RepositoryReflectionUtils.INSTANCE.getParams(method, args);
+            if (params.isEmpty()) {
+                return queryConverter.apply(value).count();
+            } else {
+                var prepare = prepareConverter.apply(value);
+                params.forEach(prepare::bind);
+                return prepare.count();
+            }
+        }
 
         Map<String, Object> params = RepositoryReflectionUtils.INSTANCE.getParams(method, args);
         Stream<?> entities;

diff --git a/...rc/test/java/org/eclipse/jnosql/mapping/core/repository/DynamicQueryMethodReturnTest.java b/...rc/test/java/org/eclipse/jnosql/mapping/core/repository/DynamicQueryMethodReturnTest.java
@@ -18,6 +18,7 @@
 import jakarta.data.repository.CrudRepository;
 import jakarta.data.repository.Param;
 import jakarta.data.repository.Query;
+import org.assertj.core.api.SoftAssertions;
 import org.eclipse.jnosql.mapping.PreparedStatement;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -247,6 +248,29 @@ void shouldReturnFromPrepareStatement() throws NoSuchMethodException {
         Assertions.assertEquals(new Person("Ada"), persons.iterator().next());
     }
 
+    @Test
+    void shouldReturnLong() throws NoSuchMethodException {
+        var preparedStatement = Mockito.mock(PreparedStatement.class);
+        Mockito.when(preparedStatement.count()).thenReturn(1L);
+        Method method = getMethod(PersonRepository.class, "count");
+
+
+        Function<String, Stream<?>> stream = q -> Stream.of(new Person("Ada"));
+        var dynamicReturn = DynamicQueryMethodReturn.builder()
+                .withTypeClass(Person.class)
+                .withMethod(method)
+                .withQueryConverter(stream)
+                .withCount(true)
+                .withPrepareConverter(s -> preparedStatement)
+                .build();
+
+        Object execute = dynamicReturn.execute();
+        SoftAssertions.assertSoftly(soft -> {
+            soft.assertThat(execute).isInstanceOf(Long.class);
+            soft.assertThat(execute).isEqualTo(1L);
+        });
+    }
+
     private Method getMethod(Class<?> repository, String methodName) throws NoSuchMethodException {
         return Stream.of(repository.getDeclaredMethods())
                 .filter(m -> m.getName().equals(methodName))
@@ -286,6 +310,12 @@ private interface PersonRepository extends CrudRepository<Person, String> {
 
         @Query("query")
         List<Person> query(@Param("name") String name);
+
+        @Query("select count(this) from Person")
+        long count();
+
+        @Query("select count(this) from Person where name = :name")
+        long count(@Param("name") String name);
     }
 
 }