Merge pull request #345 from eclipse-jnosql/optimize-count-queries

Optimized count query methods for MongoDB, Cassandra, ArangoDB, and Couchbase database drivers

Author: otaviojava

CHANGELOG.adoc

@@ -8,6 +8,14 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version
 
 == [Unreleased]
 
+=== Added
+
+- Add count method to MongoDB Document Manager for optimized count queries
+- Add count method to Cassandra Column Manager with consistency level support
+- Add count method to Cassandra Template with entity mapping
+- Add count method to ArangoDB Document Manager using AQL LENGTH function
+- Add count method to Couchbase Document Manager using N1QL COUNT queries
+
 === Changed
 
 - Update OrientDB driver to 3.2.44
@@ -20,6 +28,9 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version
 - Update Hazelcast to version 5.6.0
 - Update Redis driver to version 7.0.0
 - Update Oracle driver to version 5.4.18
+- Enhance QueryAQLConverter to support count query generation for ArangoDB
+- Enhance N1QLBuilder to support count query generation for Couchbase
+- Enhance QueryExecutor in Cassandra to support count operations
 
 == [1.1.10] - 2025-08-19
 

jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/DefaultArangoDBDocumentManager.java

@@ -148,6 +148,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 {

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,

jnosql-arangodb/src/test/java/org/eclipse/jnosql/databases/arangodb/communication/ArangoDBDocumentManagerTest.java

@@ -46,6 +46,7 @@
 import static java.util.Collections.emptyMap;
 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;
@@ -225,6 +226,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());
@@ -273,7 +290,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();
@@ -286,7 +303,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();
@@ -361,7 +378,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");
@@ -382,7 +399,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);
@@ -402,7 +419,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);
@@ -418,7 +435,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");
         });
@@ -433,7 +450,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");
         });
@@ -448,7 +465,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");
         });
@@ -481,7 +498,7 @@ void shouldCreateEdge() {
         );
 
         var result = entityManager.aql(aql, parameters).toList();
-        SoftAssertions.assertSoftly(softly -> softly.assertThat(result).isNotEmpty());
+        assertSoftly(softly -> softly.assertThat(result).isNotEmpty());
 
         entityManager.remove(person1, "FRIEND", person2);
     }
@@ -504,7 +521,7 @@ void shouldRemoveEdge() {
                      """;
         Map<String, Object> parameters = Map.of("edgeId", edge.id());
         var result = entityManager.aql(aql, parameters).toList();
-        SoftAssertions.assertSoftly(softly -> softly.assertThat(result).isEmpty());
+        assertSoftly(softly -> softly.assertThat(result).isEmpty());
     }
 
     @Test
@@ -520,7 +537,7 @@ void shouldDeleteEdgeById() {
                 """;
         Map<String, Object> parameters = Map.of("id", edge.id());
         var result = entityManager.aql(aql, parameters).toList();
-        SoftAssertions.assertSoftly(softly -> softly.assertThat(result).isEmpty());
+        assertSoftly(softly -> softly.assertThat(result).isEmpty());
     }
 
     @Test
@@ -532,7 +549,7 @@ void shouldFindEdgeById() {
         var edgeId = edge.id();
         var retrievedEdge = entityManager.findEdgeById(edgeId);
 
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             softly.assertThat(retrievedEdge).isPresent();
             softly.assertThat(retrievedEdge.get().label()).isEqualTo("FRIEND");
             softly.assertThat(retrievedEdge.get().properties()).containsEntry("since", 2020);
@@ -555,7 +572,7 @@ void shouldCreateEdgeWithProperties() {
         Map<String, Object> parameters = Map.of("edgeId", edge.id());
 
         var result = entityManager.aql(aql, parameters).toList();
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             softly.assertThat(result).isNotEmpty();
             softly.assertThat(edge.properties()).containsEntry("since", 2019);
             softly.assertThat(edge.properties()).containsEntry("strength", "strong");

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);
+
+    }
+
+
 }

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
      *

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() {

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);
 
 }

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);
     }
 }

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.
      *