Merge pull request #228 from dearrudam/mongodb-count-by-filter

Adding to JNoSQL MongoDB Database Implementation a count method by Bson query filter

Author: otaviojava

CHANGELOG.adoc

@@ -16,6 +16,8 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version
 - Update package name convention to `org.jnosql.databases.[DATABASE].[LAYER]`
 - Integrate the mapping layer on this repository
 - Upgrade the AWS SDK for DynamoDB to version 2.20.65;
+- Added to the JNoSQL MongoDB Database Implementation the MongoDB Aggregation support;
+- Added into the JNoSQL MongoDB Database Implementation a count method by Bson query filter
 
 === Fixed
 

jnosql-mongodb/src/main/java/org/eclipse/jnosql/databases/mongodb/communication/MongoDBDocumentManager.java

@@ -229,8 +229,24 @@ public Stream<DocumentEntity> select(String collectionName, Bson filter) {
         return stream(documents.spliterator(), false).map(MongoDBUtils::of)
                 .map(ds -> DocumentEntity.of(collectionName, ds));
     }
+
     private Bson getSort(Sort sort) {
         return sort.isAscending() ? Sorts.ascending(sort.property()) : Sorts.descending(sort.property());
     }
 
+    /**
+     * Returns the number of documents in the collection that match the given query filter.
+     *
+     * @param collectionName the collection name
+     * @param filter         the query filter
+     * @return the number of documents founded.
+     * @throws NullPointerException when filter or collectionName is null
+     */
+    public long count(String collectionName, Bson filter) {
+        Objects.requireNonNull(filter, "filter is required");
+        Objects.requireNonNull(collectionName, "collectionName is required");
+        MongoCollection<Document> collection = mongoDatabase.getCollection(collectionName);
+        return collection.countDocuments(filter);
+    }
+
 }

jnosql-mongodb/src/main/java/org/eclipse/jnosql/databases/mongodb/mapping/DefaultMongoDBTemplate.java

@@ -42,24 +42,24 @@ class DefaultMongoDBTemplate extends AbstractDocumentTemplate implements MongoDB
 
     private final Instance<MongoDBDocumentManager> manager;
 
-    private final  DocumentEntityConverter converter;
+    private final DocumentEntityConverter converter;
 
-    private final  DocumentWorkflow workflow;
+    private final DocumentWorkflow workflow;
 
-    private final  EntitiesMetadata entities;
+    private final EntitiesMetadata entities;
 
-    private final  Converters converters;
+    private final Converters converters;
 
-    private final  DocumentEventPersistManager persistManager;
+    private final DocumentEventPersistManager persistManager;
 
 
     @Inject
     DefaultMongoDBTemplate(Instance<MongoDBDocumentManager> manager,
-            DocumentEntityConverter converter,
-            DocumentWorkflow workflow,
-            EntitiesMetadata entities,
-            Converters converters,
-            DocumentEventPersistManager persistManager) {
+                           DocumentEntityConverter converter,
+                           DocumentWorkflow workflow,
+                           EntitiesMetadata entities,
+                           Converters converters,
+                           DocumentEventPersistManager persistManager) {
         this.manager = manager;
         this.converter = converter;
         this.workflow = workflow;
@@ -145,4 +145,19 @@ public <T> Stream<Map<String, BsonValue>> aggregate(Class<T> entity, List<Bson>
         return this.getManager().aggregate(entityMetadata.name(), pipeline);
     }
 
+    @Override
+    public long count(String collectionName, Bson filter) {
+        Objects.requireNonNull(collectionName, "collection name is required");
+        Objects.requireNonNull(filter, "filter is required");
+        return this.getManager().count(collectionName, filter);
+    }
+
+    @Override
+    public <T> long count(Class<T> entity, Bson filter) {
+        Objects.requireNonNull(entity, "entity is required");
+        Objects.requireNonNull(filter, "filter is required");
+        EntityMetadata entityMetadata = this.entities.get(entity);
+        return this.getManager().count(entityMetadata.name(), filter);
+    }
+
 }

jnosql-mongodb/src/main/java/org/eclipse/jnosql/databases/mongodb/mapping/MongoDBTemplate.java

@@ -88,12 +88,31 @@ public interface MongoDBTemplate extends JNoSQLDocumentTemplate {
     /**
      * Aggregates documents according to the specified aggregation pipeline.
      *
-     * @param entity the collection name
-     * @param <T>            the entity type
-     * @param pipeline       the aggregation pipeline
+     * @param entity   the collection name
+     * @param <T>      the entity type
+     * @param pipeline the aggregation pipeline
      * @return the number of documents deleted.
      * @throws NullPointerException when filter or entity is null
      */
     <T> Stream<Map<String, BsonValue>> aggregate(Class<T> entity, List<Bson> pipeline);
-    
+
+    /**
+     * Returns the number of items in the collection that match the given query filter.
+     *
+     * @param collectionName the collection name
+     * @param filter         the query
+     * @return the number of documents founded.
+     * @throws NullPointerException when filter or collectionName is null
+     */
+    long count(String collectionName, Bson filter);
+
+    /**
+     * Returns the number of items in the collection that match the given query filter.
+     *
+     * @param entity the entity type
+     * @param filter the filter
+     * @return the number of documents founded.
+     * @throws NullPointerException when filter or collectionName is null
+     */
+    <T> long count(Class<T> entity, Bson filter);
 }

jnosql-mongodb/src/test/java/org/eclipse/jnosql/databases/mongodb/communication/MongoDBSpecificFeaturesTest.java

@@ -37,6 +37,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static com.mongodb.client.model.Filters.and;
 import static com.mongodb.client.model.Filters.eq;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.eclipse.jnosql.communication.driver.IntegrationTest.NAMED;
@@ -60,14 +61,14 @@ public void beforeEach() {
     }
 
     @Test
-    public void shouldReturnErrorOnSelectWhenThereIsNullParameter(){
+    public void shouldReturnErrorOnSelectWhenThereIsNullParameter() {
         Assertions.assertThrows(NullPointerException.class,
                 () -> entityManager.select(null, null));
         Assertions.assertThrows(NullPointerException.class,
                 () -> entityManager.select(COLLECTION_NAME, null));
 
         Assertions.assertThrows(NullPointerException.class,
-                () -> entityManager.select(null,  eq("name", "Poliana")));
+                () -> entityManager.select(null, eq("name", "Poliana")));
     }
 
     @Test
@@ -81,14 +82,14 @@ public void shouldFindDocument() {
     }
 
     @Test
-    public void shouldReturnErrorOnDeleteWhenThereIsNullParameter(){
+    public void shouldReturnErrorOnDeleteWhenThereIsNullParameter() {
         Assertions.assertThrows(NullPointerException.class,
                 () -> entityManager.delete(null, null));
         Assertions.assertThrows(NullPointerException.class,
                 () -> entityManager.delete(COLLECTION_NAME, null));
 
         Assertions.assertThrows(NullPointerException.class,
-                () -> entityManager.delete(null,  eq("name", "Poliana")));
+                () -> entityManager.delete(null, eq("name", "Poliana")));
     }
 
     @Test
@@ -105,7 +106,7 @@ public void shouldDelete() {
     }
 
     @Test
-    public void shouldReturnErrorOnAggregateWhenThereIsNullParameter(){
+    public void shouldReturnErrorOnAggregateWhenThereIsNullParameter() {
         Assertions.assertThrows(NullPointerException.class,
                 () -> entityManager.aggregate(null, null));
         Assertions.assertThrows(NullPointerException.class,
@@ -146,4 +147,32 @@ private DocumentEntity getEntity() {
         return entity;
     }
 
+    @Test
+    public void shouldCountWithFilter() {
+
+        entityManager.insert(getEntity());
+        var filter = eq("name", "Poliana");
+        Assertions.assertEquals(1L, entityManager.count(COLLECTION_NAME, filter));
+
+        var filter2 = and(filter,eq("city", "Salvador"));
+        Assertions.assertEquals(1L, entityManager.count(COLLECTION_NAME, filter2));
+
+        var filter3 = and(filter,eq("city", "São Paulo"));
+        Assertions.assertEquals(0L, entityManager.count(COLLECTION_NAME, filter3));
+
+    }
+
+    @Test
+    public void shouldReturnErrorOnCountWithInvalidFilter() {
+
+        Assertions.assertThrows(NullPointerException.class,
+                () -> entityManager.count(null, null));
+        Assertions.assertThrows(NullPointerException.class,
+                () -> entityManager.count(COLLECTION_NAME, null));
+        Assertions.assertThrows(NullPointerException.class,
+                () -> entityManager.count(null, eq("name","Poliana")));
+
+    }
+
+
 }

jnosql-mongodb/src/test/java/org/eclipse/jnosql/databases/mongodb/mapping/DefaultMongoDBTemplateTest.java

@@ -192,4 +192,33 @@ public void shouldAggregateWithEntity() {
         Mockito.verify(manager).aggregate("Person", predicates);
     }
 
+    @Test
+    public void shouldCountByFilterWithCollectionName() {
+        var filter = eq("name", "Poliana");
+
+        template.count("Person", filter);
+
+        Mockito.verify(manager).count("Person", filter);
+    }
+
+    @Test
+    public void shouldCountByFilterWithEntity() {
+        var filter = eq("name", "Poliana");
+
+        template.count(Person.class, filter);
+
+        Mockito.verify(manager).count("Person", filter);
+    }
+
+    @Test
+    public void shouldReturnErrorOnCountByFilterMethod() {
+        var filter = eq("name", "Poliana");
+        assertThrows(NullPointerException.class, () -> template.count((String) null, null));
+        assertThrows(NullPointerException.class, () -> template.count((String) null, filter));
+        assertThrows(NullPointerException.class, () -> template.count("Person", null));
+        assertThrows(NullPointerException.class, () -> template.count((Class<Person>) null, null));
+        assertThrows(NullPointerException.class, () -> template.count((Class<Person>) null, filter));
+        assertThrows(NullPointerException.class, () -> template.count(Person.class, null));
+    }
+
 }