Merge pull request #349 from eclipse-jnosql/backport-optimized-count-queries

dearrudam · web-flow · commit 64a504994415 · 2025-12-21T01:42:05.000-03:00
[Backport] Add optimized count query methods to database managers (1.1.x)
diff --git a/jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/DefaultArangoDBDocumentManager.java b/jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/DefaultArangoDBDocumentManager.java
@@ -154,6 +154,14 @@ public long count(String documentCollection) {
                 .map(Number::longValue).orElse(0L);
     }
 
+    @Override
+    public long count(SelectQuery query) {
+        requireNonNull(query, "query is required");
+        checkCollection(query.name());
+        AQLQueryResult aqlQuery = QueryAQLConverter.count(query);
+        LOGGER.finest("Executing AQL: " + aqlQuery.query());
+        return aql(aqlQuery.query(), aqlQuery.values(), Long.class).findFirst().orElse(0L);
+    }
 
     @Override
     public Stream<CommunicationEntity> aql(String query, Map<String, Object> params) throws NullPointerException {
diff --git a/jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/QueryAQLConverter.java b/jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/QueryAQLConverter.java
@@ -77,6 +77,23 @@ public static AQLQueryResult select(SelectQuery query) throws NullPointerExcepti
 
     }
 
+    public static AQLQueryResult count(SelectQuery query) throws NullPointerException {
+
+        AQLQueryResult q = convert(query.name(),
+                query.condition().orElse(null),
+                Collections.emptyList(),
+                0L,
+                0L,
+                RETURN, false);
+
+        StringBuilder aql = new StringBuilder();
+
+        aql.append("RETURN LENGTH(")
+                .append(q.query())
+                .append(")");
+        return new AQLQueryResult(aql.toString(), q.values());
+    }
+
 
     private static AQLQueryResult convert(String documentCollection,
                                           CriteriaCondition documentCondition,
diff --git a/jnosql-arangodb/src/test/java/org/eclipse/jnosql/databases/arangodb/communication/ArangoDBDocumentManagerTest.java b/jnosql-arangodb/src/test/java/org/eclipse/jnosql/databases/arangodb/communication/ArangoDBDocumentManagerTest.java
@@ -44,6 +44,7 @@
 import static java.util.Arrays.asList;
 import static java.util.Collections.singletonMap;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.SoftAssertions.assertSoftly;
 import static org.eclipse.jnosql.communication.driver.IntegrationTest.MATCHES;
 import static org.eclipse.jnosql.communication.driver.IntegrationTest.NAMED;
 import static org.eclipse.jnosql.communication.semistructured.DeleteQuery.delete;
@@ -223,6 +224,22 @@ void shouldCount() {
         assertTrue(entityManager.count(COLLECTION_NAME) > 0);
     }
 
+    @Test
+    void shouldCountWithSelectQuery() {
+        CommunicationEntity entity = entityManager.insert(createDocumentListNotHavingId());
+        Element key = entity.find(KEY_NAME).get();
+        SelectQuery query = select().from("AppointmentBook").where(key.name()).eq(key.get()).build();
+
+        assertSoftly(softly -> {
+            softly.assertThat(entityManager.count(query))
+                    .as("should count documents matching the query")
+                    .isEqualTo(1L);
+            softly.assertThatThrownBy(() -> entityManager.count((SelectQuery) null))
+                    .as("must not accept null query")
+                    .isInstanceOf(NullPointerException.class);
+        });
+    }
+
     @Test
     void shouldReadFromDifferentBaseDocumentUsingInstance() {
         entityManager.insert(getEntity());
@@ -271,7 +288,7 @@ void shouldInsertNull() {
         entity.add(Element.of("name", null));
         CommunicationEntity documentEntity = entityManager.insert(entity);
         Optional<Element> name = documentEntity.find("name");
-        SoftAssertions.assertSoftly(soft -> {
+        assertSoftly(soft -> {
             soft.assertThat(name).isPresent();
             soft.assertThat(name).get().extracting(Element::name).isEqualTo("name");
             soft.assertThat(name).get().extracting(Element::get).isNull();
@@ -284,7 +301,7 @@ void shouldUpdateNull(){
         entity.add(Element.of("name", null));
         var documentEntity = entityManager.update(entity);
         Optional<Element> name = documentEntity.find("name");
-        SoftAssertions.assertSoftly(soft -> {
+        assertSoftly(soft -> {
             soft.assertThat(name).isPresent();
             soft.assertThat(name).get().extracting(Element::name).isEqualTo("name");
             soft.assertThat(name).get().extracting(Element::get).isNull();
@@ -359,7 +376,7 @@ void shouldInsertUUID() {
         entity.add("uuid", UUID.randomUUID());
         var documentEntity = entityManager.insert(entity);
         Optional<Element> uuid = documentEntity.find("uuid");
-        SoftAssertions.assertSoftly(soft -> {
+        assertSoftly(soft -> {
             soft.assertThat(uuid).isPresent();
             Element element = uuid.orElseThrow();
             soft.assertThat(element.name()).isEqualTo("uuid");
@@ -380,7 +397,7 @@ void shouldFindBetween() {
 
         var result = entityManager.select(query).toList();
 
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             softly.assertThat(result).hasSize(2);
             softly.assertThat(result).map(e -> e.find("age").orElseThrow().get(Integer.class)).contains(22, 23);
             softly.assertThat(result).map(e -> e.find("age").orElseThrow().get(Integer.class)).doesNotContain(25);
@@ -400,7 +417,7 @@ void shouldFindBetween2() {
 
         var result = entityManager.select(query).toList();
 
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             softly.assertThat(result).hasSize(2);
             softly.assertThat(result).map(e -> e.find("age").orElseThrow().get(Integer.class)).contains(22, 23);
             softly.assertThat(result).map(e -> e.find("age").orElseThrow().get(Integer.class)).doesNotContain(25);
@@ -416,7 +433,7 @@ void shouldFindContains() {
                 "lia")), COLLECTION_NAME, Collections.emptyList());
 
         var result = entityManager.select(query).toList();
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             softly.assertThat(result).hasSize(1);
             softly.assertThat(result.get(0).find("name").orElseThrow().get(String.class)).isEqualTo("Poliana");
         });
@@ -431,7 +448,7 @@ void shouldStartsWith() {
                 "Pol")), COLLECTION_NAME, Collections.emptyList());
 
         var result = entityManager.select(query).toList();
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             softly.assertThat(result).hasSize(1);
             softly.assertThat(result.get(0).find("name").orElseThrow().get(String.class)).isEqualTo("Poliana");
         });
@@ -446,7 +463,7 @@ void shouldEndsWith() {
                 "ana")), COLLECTION_NAME, Collections.emptyList());
 
         var result = entityManager.select(query).toList();
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             softly.assertThat(result).hasSize(1);
             softly.assertThat(result.get(0).find("name").orElseThrow().get(String.class)).isEqualTo("Poliana");
         });
@@ -483,7 +500,6 @@ private CommunicationEntity createDocumentList() {
     }
 
     private CommunicationEntity createDocumentListNotHavingId() {
-        String id = UUID.randomUUID().toString();
         CommunicationEntity entity = CommunicationEntity.of("AppointmentBook");
         entity.add(Element.of("_id", "ids"));
         List<List<Element>> documents = new ArrayList<>();
diff --git a/jnosql-arangodb/src/test/java/org/eclipse/jnosql/databases/arangodb/communication/QueryAQLConverterTest.java b/jnosql-arangodb/src/test/java/org/eclipse/jnosql/databases/arangodb/communication/QueryAQLConverterTest.java
@@ -155,4 +155,18 @@ public void shouldNegate() {
 
     }
 
+    @Test
+    public void shouldRunEqualsCountQuery() {
+        SelectQuery query = select().from("collection")
+                .where("name").eq("value").build();
+
+        AQLQueryResult convert = QueryAQLConverter.count(query);
+        String aql = convert.query();
+        Map<String, Object> values = convert.values();
+        assertEquals("value", values.get("name"));
+        assertEquals("RETURN LENGTH(FOR c IN collection FILTER  c.name == @name RETURN c)", aql);
+
+    }
+
+
 }
diff --git a/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/CassandraColumnManager.java b/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/CassandraColumnManager.java
@@ -101,6 +101,17 @@ public interface CassandraColumnManager extends DatabaseManager {
      */
     Stream<CommunicationEntity> select(SelectQuery query, ConsistencyLevel level) throws NullPointerException;
 
+    /**
+     * Count based on a query using a consistency level
+     *
+     * @param query the query
+     * @param level the consistency level
+     * @return the query using a consistency level
+     * @throws NullPointerException when either query or level are null
+     */
+    long count(SelectQuery query, ConsistencyLevel level) throws NullPointerException;
+
+
     /**
      * Executes CQL
      *
diff --git a/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/DefaultCassandraColumnManager.java b/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/DefaultCassandraColumnManager.java
@@ -159,6 +159,20 @@ public long count(String columnFamily) {
         return execute.one().getLong(0);
     }
 
+    @Override
+    public long count(SelectQuery query) {
+        requireNonNull(query, "query is required");
+        QueryExecutor executor = QueryExecutor.of(query);
+        return executor.count(keyspace, query, this);
+    }
+
+    @Override
+    public long count(SelectQuery query, ConsistencyLevel level) {
+        requireNonNull(query, "query is required");
+        requireNonNull(level, "level is required");
+        QueryExecutor executor = QueryExecutor.of(query);
+        return executor.count(keyspace, query, level, this);
+    }
 
     @Override
     public void close() {
diff --git a/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/QueryExecutor.java b/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/QueryExecutor.java
@@ -29,9 +29,17 @@ static QueryExecutor of(SelectQuery query) {
         return QueryExecutorType.DEFAULT;
     }
 
-    Stream<CommunicationEntity> execute(String keyspace, SelectQuery query, DefaultCassandraColumnManager manager);
+    default Stream<CommunicationEntity> execute(String keyspace, SelectQuery query, DefaultCassandraColumnManager manager) {
+        return execute(keyspace, query, null, manager);
+    }
 
     Stream<CommunicationEntity> execute(String keyspace, SelectQuery query, ConsistencyLevel level,
-                                 DefaultCassandraColumnManager manager);
+                                        DefaultCassandraColumnManager manager);
+
+    default long count(String keyspace, SelectQuery query, DefaultCassandraColumnManager manager) {
+        return count(keyspace, query, null, manager);
+    }
+
+    long count(String keyspace, SelectQuery query, ConsistencyLevel level, DefaultCassandraColumnManager manager);
 
 }
diff --git a/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/QueryExecutorType.java b/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/QueryExecutorType.java
@@ -30,14 +30,9 @@
 
 enum QueryExecutorType implements QueryExecutor {
     PAGING_STATE {
-        @Override
-        public Stream<CommunicationEntity> execute(String keyspace, SelectQuery query, DefaultCassandraColumnManager manager) {
-            return execute(keyspace, query, null, manager);
-        }
-
         @Override
         public Stream<CommunicationEntity> execute(String keyspace, SelectQuery q, ConsistencyLevel level,
-                                            DefaultCassandraColumnManager manager) {
+                                                   DefaultCassandraColumnManager manager) {
 
             CassandraQuery query = CassandraQuery.class.cast(q);
 
@@ -73,14 +68,9 @@ public Stream<CommunicationEntity> execute(String keyspace, SelectQuery q, Consi
 
     },
     DEFAULT {
-        @Override
-        public Stream<CommunicationEntity> execute(String keyspace, SelectQuery query, DefaultCassandraColumnManager manager) {
-            return execute(keyspace, query, null, manager);
-        }
-
         @Override
         public Stream<CommunicationEntity> execute(String keyspace, SelectQuery query, ConsistencyLevel level,
-                                            DefaultCassandraColumnManager manager) {
+                                                   DefaultCassandraColumnManager manager) {
 
             Select cassandraSelect = QueryUtils.select(query, keyspace);
 
@@ -98,5 +88,17 @@ public Stream<CommunicationEntity> execute(String keyspace, SelectQuery query, C
             }
             return resultSet.all().stream().map(CassandraConverter::toDocumentEntity);
         }
+    };
+
+    @Override
+    public long count(String keyspace, SelectQuery query, ConsistencyLevel level, DefaultCassandraColumnManager manager) {
+
+        Select cassandraSelect = QueryUtils.select(query, keyspace).countAll();
+        SimpleStatement select = cassandraSelect.build();
+        if (Objects.nonNull(level)) {
+            select = select.setConsistencyLevel(level);
+        }
+        ResultSet resultSet = manager.getSession().execute(select);
+        return resultSet.one().getLong(0);
     }
 }
diff --git a/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/mapping/CassandraTemplate.java b/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/mapping/CassandraTemplate.java
@@ -87,6 +87,17 @@ public interface CassandraTemplate extends ColumnTemplate {
      */
     void delete(DeleteQuery query, ConsistencyLevel level);
 
+    /**
+     * Returns the count of records that match the given {@link SelectQuery} using the specified
+     * {@link ConsistencyLevel}.
+     *
+     * @param query the select query defining the criteria for counting; must not be {@code null}
+     * @param level the Cassandra consistency level to use for the operation; must not be {@code null}
+     * @return the number of records matching the query
+     * @throws NullPointerException if {@code query} or {@code level} is {@code null}
+     */
+    long count(SelectQuery query, ConsistencyLevel level);
+
     /**
      * Executes a {@link SelectQuery} using a specified {@link ConsistencyLevel} and retrieves the matching records.
      *
diff --git a/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/mapping/DefaultCassandraTemplate.java b/jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/mapping/DefaultCassandraTemplate.java
@@ -147,6 +147,13 @@ public void delete(DeleteQuery query, ConsistencyLevel level) {
         manager.get().delete(query, level);
     }
 
+    @Override
+    public long count(SelectQuery query, ConsistencyLevel level) {
+        Objects.requireNonNull(query, "query is required");
+        Objects.requireNonNull(level, "level is required");
+        return manager.get().count(query, level);
+    }
+
     @Override
     public <T> Stream<T> find(SelectQuery query, ConsistencyLevel level) {
         Objects.requireNonNull(query, "query is required");
diff --git a/jnosql-cassandra/src/test/java/org/eclipse/jnosql/databases/cassandra/communication/CassandraColumnManagerTest.java b/jnosql-cassandra/src/test/java/org/eclipse/jnosql/databases/cassandra/communication/CassandraColumnManagerTest.java
@@ -48,6 +48,7 @@
 import static java.util.Collections.singletonMap;
 import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.SoftAssertions.assertSoftly;
 import static org.eclipse.jnosql.communication.driver.IntegrationTest.MATCHES;
 import static org.eclipse.jnosql.communication.driver.IntegrationTest.NAMED;
 import static org.eclipse.jnosql.communication.semistructured.DeleteQuery.delete;
@@ -451,7 +452,33 @@ void shouldCount() {
         assertTrue(contacts > 0);
     }
 
-   @Test
+    @Test
+    void shouldCountBySelectQuery() {
+        entityManager.insert(getColumnFamily());
+        var query = select().from(Constants.COLUMN_FAMILY).where("id").eq(10L).build();
+        assertSoftly(softly -> {
+
+            softly.assertThat(entityManager.count(query))
+                    .as("the implementation is returning an non expected value")
+                    .isEqualTo(1);
+
+            softly.assertThatThrownBy(() -> entityManager.count(query, null))
+                    .as("must throw NPE when call the count method passing null arguments")
+                    .isInstanceOf(NullPointerException.class);
+
+            softly.assertThatThrownBy(() -> entityManager.count(null, null))
+                    .as("must throw NPE when call the count method passing null arguments")
+                    .isInstanceOf(NullPointerException.class);
+
+            softly.assertThatThrownBy(() -> entityManager.count((SelectQuery) null))
+                    .as("must throw NPE when call the count method passing null arguments")
+                    .isInstanceOf(NullPointerException.class);
+
+        });
+
+    }
+
+    @Test
     void shouldPagingState() {
         for (long index = 1; index <= 10; index++) {
             var columnFamily = getColumnFamily();
@@ -501,7 +528,7 @@ void shouldInsertNullValues(){
         family.add(Element.of("name", null));
         var columnEntity = entityManager.insert(family);
         var column = columnEntity.find("name");
-        SoftAssertions.assertSoftly(soft -> {
+        assertSoftly(soft -> {
             soft.assertThat(column).get().extracting(Element::name).isEqualTo("name");
             soft.assertThat(column).get().extracting(Element::get).isNull();
         });
@@ -514,7 +541,7 @@ void shouldUpdateNullValues(){
         family.addNull("name");
         var columnEntity = entityManager.update(family);
         var column = columnEntity.find("name");
-        SoftAssertions.assertSoftly(soft -> {
+        assertSoftly(soft -> {
             soft.assertThat(column).get().extracting(Element::name).isEqualTo("name");
             soft.assertThat(column).get().extracting(Element::get).isNull();
         });
diff --git a/jnosql-couchbase/src/main/java/org/eclipse/jnosql/databases/couchbase/communication/DefaultCouchbaseDocumentManager.java b/jnosql-couchbase/src/main/java/org/eclipse/jnosql/databases/couchbase/communication/DefaultCouchbaseDocumentManager.java
@@ -205,6 +205,26 @@ public long count(String documentCollection) {
         });
     }
 
+    @Override
+    public long count(SelectQuery query) {
+        Objects.requireNonNull(query, "query is required");
+        return waitBucketBeReadyAndGet(() -> {
+            N1QLQuery n1QLQuery = N1QLBuilder.countOf(query, database, bucket.defaultScope().name()).get();
+            QueryResult result;
+            if (n1QLQuery.isParameterEmpty()) {
+                result = cluster.query(n1QLQuery.query());
+            } else {
+                result = cluster.query(n1QLQuery.query(), QueryOptions
+                        .queryOptions().parameters(n1QLQuery.params()));
+            }
+            return result.rowsAsObject()
+                    .stream()
+                    .findFirst()
+                    .map(json -> json.getLong("$1"))
+                    .orElse(0L);
+        });
+    }
+
     @Override
     public Stream<CommunicationEntity> n1qlQuery(final String n1ql, final JsonObject params) throws NullPointerException {
         requireNonNull(n1ql, "n1qlQuery is required");
diff --git a/jnosql-couchbase/src/main/java/org/eclipse/jnosql/databases/couchbase/communication/N1QLBuilder.java b/jnosql-couchbase/src/main/java/org/eclipse/jnosql/databases/couchbase/communication/N1QLBuilder.java
diff --git a/jnosql-couchbase/src/test/java/org/eclipse/jnosql/databases/couchbase/communication/CouchbaseDocumentManagerTest.java b/jnosql-couchbase/src/test/java/org/eclipse/jnosql/databases/couchbase/communication/CouchbaseDocumentManagerTest.java
diff --git a/jnosql-couchbase/src/test/resources/couchbase.properties b/jnosql-couchbase/src/test/resources/couchbase.properties
diff --git a/jnosql-mongodb/src/main/java/org/eclipse/jnosql/databases/mongodb/communication/MongoDBDocumentManager.java b/jnosql-mongodb/src/main/java/org/eclipse/jnosql/databases/mongodb/communication/MongoDBDocumentManager.java
diff --git a/jnosql-mongodb/src/test/java/org/eclipse/jnosql/databases/mongodb/communication/MongoDBDocumentManagerTest.java b/jnosql-mongodb/src/test/java/org/eclipse/jnosql/databases/mongodb/communication/MongoDBDocumentManagerTest.java
