Merge pull request #243 from dearrudam/issue-439

Making the Couchbase DocumentManager implementation to supports the count method

Author: otaviojava

.gitignore

@@ -14,4 +14,8 @@ test-output/
 .project
 /.idea
 .settings/
-**/.DS_Store
+**/.DS_Store
+
+# ignoring Quarkus plugin config files
+.quarkus
+.quarkus/**

CHANGELOG.adoc

@@ -11,6 +11,7 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version
 === Fixed
 
 - Fixes Repositories specializations when use methods from CrudRepository
+- Fixes in the Couchbase DocumentManager implementation to supports the count method
 
 === Added
 

jnosql-couchbase/src/main/java/org/eclipse/jnosql/databases/couchbase/communication/CouchbaseSettings.java

@@ -11,6 +11,7 @@
  *   Contributors:
  *
  *   Otavio Santana
+ *   Maximillian Arruda
  */
 package org.eclipse.jnosql.databases.couchbase.communication;
 
@@ -22,15 +23,15 @@
 import com.couchbase.client.java.manager.collection.CollectionManager;
 import com.couchbase.client.java.manager.collection.CollectionSpec;
 import com.couchbase.client.java.manager.collection.ScopeSpec;
-import com.couchbase.client.java.manager.query.QueryIndex;
 import com.couchbase.client.java.manager.query.QueryIndexManager;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+import java.util.*;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static com.couchbase.client.java.manager.query.CreatePrimaryQueryIndexOptions.createPrimaryQueryIndexOptions;
 import static com.couchbase.client.java.manager.query.GetAllQueryIndexesOptions.getAllQueryIndexesOptions;
@@ -154,8 +155,19 @@ public Cluster getCluster() {
      * @throws NullPointerException when parameter is null
      */
     public void setUp(String database) {
+
         Objects.requireNonNull(database, "database is required");
 
+        var collections = getCollections().stream().map(String::trim)
+                .filter(index -> !index.isBlank()).toList();
+
+        var collectionsToIndex = Arrays
+                .stream(Optional.ofNullable(getIndex()).orElse("").split(","))
+                .map(String::trim)
+                .filter(index -> !index.isBlank()).collect(Collectors.toSet());
+
+        var scope = getScope();
+
         long start = System.currentTimeMillis();
         LOGGER.log(Level.FINEST, "starting the setup with database: " + database);
 
@@ -168,47 +180,54 @@ public void setUp(String database) {
                 LOGGER.log(Level.FINEST, "The database/bucket does not exist, creating it: " + database);
                 buckets.createBucket(BucketSettings.create(database));
             }
+
             Bucket bucket = cluster.bucket(database);
 
+            waitUntilReady(bucket);
+
             CollectionManager manager = bucket.collections();
+
             List<ScopeSpec> scopes = manager.getAllScopes();
-            String finalScope = getScope().orElseGet(() -> bucket.defaultScope().name());
+            String finalScope = scope.orElseGet(() -> bucket.defaultScope().name());
             ScopeSpec spec = scopes.stream().filter(s -> finalScope.equals(s.name()))
                     .findFirst().get();
-            for (String collection : collections) {
-                if (spec.collections().stream().noneMatch(c -> collection.equals(c.name()))) {
+
+            collections.forEach(collection -> {
+                if (spec.collections().stream().noneMatch(c -> collectionsToIndex.contains(c.name()))) {
                     manager.createCollection(CollectionSpec.create(collection, finalScope));
                 }
-            }
-            if (index != null) {
+            });
+
+            waitUntilReady(bucket);
+
+            if (!collectionsToIndex.isEmpty()) {
+
                 QueryIndexManager queryIndexManager = cluster.queryIndexes();
-                List<QueryIndex> indexes = queryIndexManager.getAllIndexes(database, getAllQueryIndexesOptions()
-                        .scopeName(finalScope).collectionName(index));
-                if (indexes.isEmpty()) {
-                    LOGGER.log(Level.FINEST, "Index does not exist, creating primary key with scope "
-                            + scope + " collection " + index + " at database " + database);
-                    queryIndexManager.createPrimaryIndex(database, createPrimaryQueryIndexOptions()
-                            .scopeName(finalScope).collectionName(index));
-                }
 
-                for (String collection : collections) {
-                    queryIndexManager = cluster.queryIndexes();
-                    indexes = queryIndexManager.getAllIndexes(database, getAllQueryIndexesOptions()
-                            .scopeName(finalScope).collectionName(collection));
-                    if (indexes.isEmpty()) {
-                        LOGGER.log(Level.FINEST, "Index for " + collection + " collection does not exist, creating primary key with scope "
-                                + scope + " collection " + collection + " at database " + database);
-                        queryIndexManager.createPrimaryIndex(database, createPrimaryQueryIndexOptions()
-                                .scopeName(finalScope).collectionName(collection));
-                    }
-                }
+                Stream.concat(collectionsToIndex.stream(), collectionsToIndex.stream())
+                        .distinct()
+                        .forEach(collection -> {
+                            var allIndexes = queryIndexManager.getAllIndexes(database, getAllQueryIndexesOptions()
+                                    .scopeName(finalScope).collectionName(collection));
+                            if (allIndexes.isEmpty()) {
+                                LOGGER.log(Level.FINEST, "Index for " + collection + " collection does not exist, creating primary key with scope "
+                                        + finalScope + " collection " + collection + " at database " + database);
+                                queryIndexManager.createPrimaryIndex(database, createPrimaryQueryIndexOptions()
+                                        .scopeName(finalScope).collectionName(collection));
+                            }
+                        });
 
             }
 
             long end = System.currentTimeMillis() - start;
             LOGGER.log(Level.FINEST, "Finished the setup with database: " + database + " end with millis "
                     + end);
         }
+
+    }
+
+    private void waitUntilReady(Bucket bucket) {
+        bucket.waitUntilReady(Duration.of(4, ChronoUnit.SECONDS));
     }
 
     @Override

jnosql-couchbase/src/main/java/org/eclipse/jnosql/databases/couchbase/communication/DefaultCouchbaseDocumentManager.java

@@ -188,10 +188,21 @@ public Stream<DocumentEntity> select(final DocumentQuery query) throws NullPoint
 
     @Override
     public long count(String documentCollection) {
-        throw new UnsupportedOperationException("Couchbase does not support count method by document collection");
+        Objects.requireNonNull(documentCollection, "documentCollection is required");
+        return waitBucketBeReadyAndGet(() -> {
+            DocumentQuery countQuery = DocumentQuery
+                    .select("COUNT(*)").from(documentCollection).build();
+            N1QLQuery n1QLQuery = N1QLBuilder
+                    .of(countQuery, database, bucket.defaultScope().name()).get();
+            QueryResult query = cluster.query(n1QLQuery.getQuery());
+            List<JsonObject> result = query.rowsAsObject();
+            var count = result.stream().findFirst()
+                    .map(data -> data.getNumber("$1"))
+                    .orElse(0L);
+            return count.longValue();
+        });
     }
 
-
     @Override
     public Stream<DocumentEntity> n1qlQuery(final String n1ql, final JsonObject params) throws NullPointerException {
         requireNonNull(n1ql, "n1qlQuery is required");

jnosql-couchbase/src/test/java/org/eclipse/jnosql/databases/couchbase/communication/CouchbaseDocumentManagerTest.java

@@ -201,6 +201,14 @@ public void shouldRetrieveListDocumentList() {
         assertTrue(contacts.stream().allMatch(d -> d.size() == 3));
     }
 
+    @Test
+    public void shouldCount() {
+        DocumentEntity entity = getEntity();
+        entityManager.insert(entity);
+        long counted = entityManager.count(COLLECTION_PERSON_NAME);
+        assertTrue(counted > 0);
+    }
+
     private DocumentEntity createSubdocumentList() {
         DocumentEntity entity = DocumentEntity.of(COLLECTION_APP_NAME);
         entity.add(Document.of("_id", "ids"));