Support cross-database ability for more interfaces (#1618)

Signed-off-by: yhmo <yihua.mo@zilliz.com>

sdk-core/src/main/java/io/milvus/v2/client/MilvusClientV2.java

@@ -306,12 +306,22 @@ public class MilvusClientV2 {
     }
 
     /**
-     * list milvus collections
+     * List milvus collections in the current database of the connection
      *
      * @return List of String collection names
      */
     public ListCollectionsResp listCollections() {
-        return rpcUtils.retry(()-> collectionService.listCollections(this.getRpcStub()));
+        return rpcUtils.retry(()-> collectionService.listCollections(this.getRpcStub(), ""));
+    }
+    /**
+     * List milvus collections, can specify the target database
+     * Note: the old API listCollections() doesn't have a ListCollectionsReq argument, we have to create
+     * this new V2 API to avoid incompatible issue.
+     *
+     * @return List of String collection names
+     */
+    public ListCollectionsResp listCollectionsV2(ListCollectionsReq request) {
+        return rpcUtils.retry(()-> collectionService.listCollections(this.getRpcStub(), request.getDatabaseName()));
     }
     /**
      * Drops a collection in Milvus.

sdk-core/src/main/java/io/milvus/v2/service/collection/CollectionService.java

@@ -52,7 +52,9 @@ public class CollectionService extends BaseService {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Dimension is undefined.");
         }
 
-        String title = String.format("CreateCollectionRequest collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Create collection: '%s' in database: '%s'", collectionName, dbName);
         FieldSchema vectorSchema = FieldSchema.newBuilder()
                 .setName(request.getVectorFieldName())
                 .setDataType(DataType.FloatVector)
@@ -71,7 +73,7 @@ public class CollectionService extends BaseService {
         }
 
         CollectionSchema schema = CollectionSchema.newBuilder()
-                .setName(request.getCollectionName())
+                .setName(collectionName)
                 .setDescription(request.getDescription())
                 .addFields(vectorSchema)
                 .addFields(idSchema)
@@ -79,13 +81,13 @@ public class CollectionService extends BaseService {
                 .build();
 
         CreateCollectionRequest.Builder builder = CreateCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
+                .setCollectionName(collectionName)
                 .setSchema(schema.toByteString())
                 .setShardsNum(request.getNumShards())
                 .setConsistencyLevelValue(request.getConsistencyLevel().getCode());
 
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         Status status = blockingStub.createCollection(builder.build());
@@ -97,8 +99,8 @@ public class CollectionService extends BaseService {
                         .fieldName(request.getVectorFieldName())
                         .build();
         CreateIndexReq createIndexReq = CreateIndexReq.builder()
-                        .databaseName(request.getDatabaseName())
-                .collectionName(request.getCollectionName())
+                        .databaseName(dbName)
+                        .collectionName(collectionName)
                         .indexParams(Collections.singletonList(indexParam))
                         .sync(false)
                         .build();
@@ -106,8 +108,8 @@ public class CollectionService extends BaseService {
         //load collection, set sync to false since no need to wait loading progress
         try {
             loadCollection(blockingStub, LoadCollectionReq.builder()
-                    .databaseName(request.getDatabaseName())
-                    .collectionName(request.getCollectionName())
+                    .databaseName(dbName)
+                    .collectionName(collectionName)
                     .sync(false)
                     .build());
         } catch (Exception e) {
@@ -117,11 +119,13 @@ public class CollectionService extends BaseService {
     }
 
     public Void createCollectionWithSchema(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateCollectionReq request) {
-        String title = String.format("CreateCollectionRequest collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Create collection: '%s' in database: '%s'", collectionName, dbName);
 
         //convert CollectionSchema to io.milvus.grpc.CollectionSchema
         CollectionSchema.Builder grpcSchemaBuilder = CollectionSchema.newBuilder()
-                .setName(request.getCollectionName())
+                .setName(collectionName)
                 .setDescription(request.getDescription())
                 .setEnableDynamicField(request.getCollectionSchema().isEnableDynamicField());
         List<String> outputFields = new ArrayList<>();
@@ -143,8 +147,8 @@ public class CollectionService extends BaseService {
                 .setSchema(grpcSchemaBuilder.build().toByteString())
                 .setShardsNum(request.getNumShards())
                 .setConsistencyLevelValue(request.getConsistencyLevel().getCode());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         List<KeyValuePair> propertiesList = ParamUtils.AssembleKvPair(request.getProperties());
@@ -161,8 +165,8 @@ public class CollectionService extends BaseService {
         if(request.getIndexParams() != null && !request.getIndexParams().isEmpty()) {
             for(IndexParam indexParam : request.getIndexParams()) {
                 CreateIndexReq createIndexReq = CreateIndexReq.builder()
-                        .databaseName(request.getDatabaseName())
-                        .collectionName(request.getCollectionName())
+                        .databaseName(dbName)
+                        .collectionName(collectionName)
                         .indexParams(Collections.singletonList(indexParam))
                         .sync(false)
                         .build();
@@ -170,8 +174,8 @@ public class CollectionService extends BaseService {
             }
             //load collection, set sync to true since no need to wait loading progress
             loadCollection(blockingStub, LoadCollectionReq.builder()
-                    .databaseName(request.getDatabaseName())
-                    .collectionName(request.getCollectionName())
+                    .databaseName(dbName)
+                    .collectionName(collectionName)
                     .sync(false)
                     .build());
         }
@@ -179,21 +183,25 @@ public class CollectionService extends BaseService {
         return null;
     }
 
-    public ListCollectionsResp listCollections(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub) {
-        ShowCollectionsRequest showCollectionsRequest = ShowCollectionsRequest.newBuilder()
-                .build();
-        ShowCollectionsResponse response = blockingStub.showCollections(showCollectionsRequest);
+    public ListCollectionsResp listCollections(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, String dbName) {
+        String title = String.format("List collections in database: '%s'", dbName);
+        ShowCollectionsRequest.Builder builder = ShowCollectionsRequest.newBuilder();
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        ShowCollectionsResponse response = blockingStub.showCollections(builder.build());
+        rpcUtils.handleResponse(title, response.getStatus());
+
         ListCollectionsResp listCollectionsResp = ListCollectionsResp.builder()
                 .collectionNames(response.getCollectionNamesList())
                 .build();
-
         return listCollectionsResp;
     }
 
     public Void dropCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropCollectionReq request) {
         String dbName = request.getDatabaseName();
         String collectionName = request.getCollectionName();
-        String title = String.format("DropCollectionRequest collectionName:%s", collectionName);
+        String title = String.format("Drop collection: '%s' in database: '%s'", collectionName, dbName);
         DropCollectionRequest.Builder builder = DropCollectionRequest.newBuilder()
                 .setCollectionName(collectionName);
         if (StringUtils.isNotEmpty(dbName)) {
@@ -209,15 +217,17 @@ public class CollectionService extends BaseService {
     }
 
     public Void alterCollectionProperties(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, AlterCollectionPropertiesReq request) {
-        String title = String.format("AlterCollectionPropertiesReq collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Alter properties of collection: '%s' in database: '%s'", collectionName, dbName);
         AlterCollectionRequest.Builder builder = AlterCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName());
+                .setCollectionName(collectionName);
         List<KeyValuePair> propertiesList = ParamUtils.AssembleKvPair(request.getProperties());
         if (CollectionUtils.isNotEmpty(propertiesList)) {
             propertiesList.forEach(builder::addProperties);
         }
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         Status response = blockingStub.alterCollection(builder.build());
@@ -227,16 +237,18 @@ public class CollectionService extends BaseService {
     }
 
     public Void alterCollectionField(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, AlterCollectionFieldReq request) {
-        String title = String.format("AlterCollectionFieldReq collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Alter field of collection: '%s' in database: '%s'", collectionName, dbName);
         AlterCollectionFieldRequest.Builder builder = AlterCollectionFieldRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
+                .setCollectionName(collectionName)
                 .setFieldName(request.getFieldName());
         List<KeyValuePair> propertiesList = ParamUtils.AssembleKvPair(request.getProperties());
         if (CollectionUtils.isNotEmpty(propertiesList)) {
             propertiesList.forEach(builder::addProperties);
         }
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         Status response = blockingStub.alterCollectionField(builder.build());
@@ -246,12 +258,14 @@ public class CollectionService extends BaseService {
     }
 
     public Void dropCollectionProperties(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropCollectionPropertiesReq request) {
-        String title = String.format("DropCollectionPropertiesReq collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Drop properties of collection: '%s' in database: '%s'", collectionName, dbName);
         AlterCollectionRequest.Builder builder = AlterCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
+                .setCollectionName(collectionName)
                 .addAllDeleteKeys(request.getPropertyKeys());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         Status response = blockingStub.alterCollection(builder.build());
@@ -261,15 +275,18 @@ public class CollectionService extends BaseService {
     }
 
     public Void dropCollectionFieldProperties(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropCollectionFieldPropertiesReq request) {
-        String title = String.format("DropCollectionFieldPropertiesReq collectionName:%s fieldName:%s",
-                request.getCollectionName(), request.getFieldName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String fieldName = request.getFieldName();
+        String title = String.format("Drop properties of field: '%s' of collection: '%s' in database: '%s'",
+                fieldName, collectionName, dbName);
 
         AlterCollectionFieldRequest.Builder builder = AlterCollectionFieldRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setFieldName(request.getFieldName())
+                .setCollectionName(collectionName)
+                .setFieldName(fieldName)
                 .addAllDeleteKeys(request.getPropertyKeys());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         Status response = blockingStub.alterCollectionField(builder.build());
@@ -279,20 +296,27 @@ public class CollectionService extends BaseService {
     }
 
     public Boolean hasCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, HasCollectionReq request) {
-        HasCollectionRequest hasCollectionRequest = HasCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .build();
-        BoolResponse response = blockingStub.hasCollection(hasCollectionRequest);
-        rpcUtils.handleResponse("HasCollectionRequest", response.getStatus());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Has collection: '%s' in database:'%s'", collectionName, dbName);
+        HasCollectionRequest.Builder builder = HasCollectionRequest.newBuilder()
+                .setCollectionName(collectionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        BoolResponse response = blockingStub.hasCollection(builder.build());
+        rpcUtils.handleResponse(title, response.getStatus());
         return response.getValue();
     }
 
     public DescribeCollectionResp describeCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DescribeCollectionReq request) {
-        String title = String.format("DescribeCollectionRequest collectionName:%s, databaseName:%s", request.getCollectionName(), request.getDatabaseName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Describe collection: '%s' in database: '%s'", collectionName, dbName);
         DescribeCollectionRequest.Builder builder = DescribeCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+                .setCollectionName(collectionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         DescribeCollectionResponse response = blockingStub.describeCollection(builder.build());
@@ -301,86 +325,115 @@ public class CollectionService extends BaseService {
     }
 
     public Void renameCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, RenameCollectionReq request) {
-        String title = String.format("RenameCollectionRequest collectionName:%s", request.getCollectionName());
-        RenameCollectionRequest renameCollectionRequest = RenameCollectionRequest.newBuilder()
-                .setOldName(request.getCollectionName())
-                .setNewName(request.getNewCollectionName())
-                .build();
-        Status status = blockingStub.renameCollection(renameCollectionRequest);
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String newName = request.getNewCollectionName();
+        String title = String.format("Rename collection: '%s' to '%s' in database: '%s'", collectionName, newName, dbName);
+        RenameCollectionRequest.Builder builder = RenameCollectionRequest.newBuilder()
+                .setOldName(collectionName)
+                .setNewName(newName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        Status status = blockingStub.renameCollection(builder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
 
     public Void loadCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, LoadCollectionReq request) {
-        String title = String.format("LoadCollectionRequest collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Load collection: '%s' in database: '%s'", collectionName, dbName);
         LoadCollectionRequest.Builder builder = LoadCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
+                .setCollectionName(collectionName)
                 .setReplicaNumber(request.getNumReplicas())
                 .setRefresh(request.getRefresh())
                 .addAllLoadFields(request.getLoadFields())
                 .setSkipLoadDynamicField(request.getSkipLoadDynamicField())
                 .addAllResourceGroups(request.getResourceGroups());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
         Status status = blockingStub.loadCollection(builder.build());
         rpcUtils.handleResponse(title, status);
         if (request.getSync()) {
-            WaitForLoadCollection(blockingStub, request.getCollectionName(), request.getTimeout());
+            WaitForLoadCollection(blockingStub, dbName, collectionName, request.getTimeout());
         }
 
         return null;
     }
 
     public Void refreshLoad(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, RefreshLoadReq request) {
-        String title = String.format("RefreshLoadRequest collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Refresh load collection: '%s' in database: '%s'", collectionName, dbName);
         LoadCollectionRequest.Builder builder = LoadCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
+                .setCollectionName(collectionName)
                 .setRefresh(true);
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
         Status status = blockingStub.loadCollection(builder.build());
         rpcUtils.handleResponse(title, status);
         if (request.getSync()) {
-            WaitForLoadCollection(blockingStub, request.getCollectionName(), request.getTimeout());
+            WaitForLoadCollection(blockingStub, dbName, collectionName, request.getTimeout());
         }
 
         return null;
     }
 
     public Void releaseCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, ReleaseCollectionReq request) {
-        String title = String.format("ReleaseCollectionRequest collectionName:%s", request.getCollectionName());
-        ReleaseCollectionRequest releaseCollectionRequest = ReleaseCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .build();
-        Status status = blockingStub.releaseCollection(releaseCollectionRequest);
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Release collection: '%s' in database: '%s'", collectionName, dbName);
+        ReleaseCollectionRequest.Builder builder = ReleaseCollectionRequest.newBuilder()
+                .setCollectionName(collectionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        Status status = blockingStub.releaseCollection(builder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
 
     public Boolean getLoadState(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GetLoadStateReq request) {
-        // getLoadState
-        String title = String.format("GetLoadStateRequest collectionName:%s", request.getCollectionName());
-        GetLoadStateRequest getLoadStateRequest = GetLoadStateRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .build();
-        if(request.getPartitionName() != null) {
-            getLoadStateRequest = getLoadStateRequest.toBuilder().addPartitionNames(request.getPartitionName()).build();
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String partitionName = request.getPartitionName();
+        String title = String.format("Get load state of collection: '%s' in database: '%s'", collectionName, dbName);
+        GetLoadStateRequest.Builder builder = GetLoadStateRequest.newBuilder()
+                .setCollectionName(collectionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
-        GetLoadStateResponse response = blockingStub.getLoadState(getLoadStateRequest);
+        if (StringUtils.isNotEmpty(partitionName)) {
+            builder.addPartitionNames(partitionName);
+        }
+        GetLoadStateResponse response = blockingStub.getLoadState(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
+        // throw error if cannot find the collection of partition
+        if (response.getState() == LoadState.LoadStateNotExist) {
+            String msg = String.format("collection: '%s' doesn't exist in database: '%s'", collectionName, dbName);
+            if (StringUtils.isNotEmpty(partitionName)) {
+                msg = String.format("partition: '%s' of %s", partitionName, msg);
+            }
+            throw new MilvusClientException(ErrorCode.SERVER_ERROR, msg);
+        }
         return response.getState() == LoadState.LoadStateLoaded;
     }
 
     public GetCollectionStatsResp getCollectionStats(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GetCollectionStatsReq request) {
-        String title = String.format("GetCollectionStatisticsRequest collectionName:%s", request.getCollectionName());
-        GetCollectionStatisticsRequest getCollectionStatisticsRequest = GetCollectionStatisticsRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .build();
-        GetCollectionStatisticsResponse response = blockingStub.getCollectionStatistics(getCollectionStatisticsRequest);
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Get statistics of collection: '%s' in database: '%s'", collectionName, dbName);
+        GetCollectionStatisticsRequest.Builder builder = GetCollectionStatisticsRequest.newBuilder()
+                .setCollectionName(collectionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        GetCollectionStatisticsResponse response = blockingStub.getCollectionStatistics(builder.build());
 
         rpcUtils.handleResponse(title, response.getStatus());
         GetCollectionStatsResp getCollectionStatsResp = GetCollectionStatsResp.builder()
@@ -396,18 +449,18 @@ public class CollectionService extends BaseService {
 
     public DescribeReplicasResp describeReplicas(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                                  DescribeReplicasReq request) {
-        if (StringUtils.isEmpty(request.getCollectionName())) {
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        if (StringUtils.isEmpty(collectionName)) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Invalid collection name");
         }
 
-        String title = String.format("DescribeReplicas collectionName:%s", request.getCollectionName());
-
+        String title = String.format("Describe replicas of collection: '%s' in database: '%s'", collectionName, dbName);
         GetReplicasRequest.Builder requestBuilder = GetReplicasRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
+                .setCollectionName(collectionName)
                 .setWithShardNodes(true);
-
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            requestBuilder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            requestBuilder.setDbName(dbName);
         }
 
         GetReplicasResponse response = blockingStub.getReplicas(requestBuilder.build());
@@ -443,13 +496,16 @@ public class CollectionService extends BaseService {
                 .build();
     }
 
-    private void WaitForLoadCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
+    private void WaitForLoadCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, String databaseName,
                                        String collectionName, long timeoutMs) {
         long startTime = System.currentTimeMillis(); // Capture start time/ Timeout in milliseconds (60 seconds)
 
         while (true) {
             // Call the getLoadState method
-            boolean isLoaded = getLoadState(blockingStub, GetLoadStateReq.builder().collectionName(collectionName).build());
+            boolean isLoaded = getLoadState(blockingStub, GetLoadStateReq.builder()
+                    .databaseName(databaseName)
+                    .collectionName(collectionName)
+                    .build());
             if (isLoaded) {
                 return;
             }

sdk-core/src/main/java/io/milvus/v2/service/collection/request/GetCollectionStatsReq.java

@@ -25,5 +25,6 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class GetCollectionStatsReq {
+    private String databaseName;
     private String collectionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/collection/request/GetLoadStateReq.java

@@ -25,6 +25,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class GetLoadStateReq {
+    private String databaseName;
     private String collectionName;
     private String partitionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/collection/request/HasCollectionReq.java

@@ -25,5 +25,6 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class HasCollectionReq {
+    private String databaseName;
     private String collectionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/collection/request/ListCollectionsReq.java

@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class ListCollectionsReq {
+    private String databaseName;
+}

sdk-core/src/main/java/io/milvus/v2/service/collection/request/ReleaseCollectionReq.java

@@ -26,6 +26,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class ReleaseCollectionReq {
+    private String databaseName;
     private String collectionName;
     @Deprecated
     @Builder.Default

sdk-core/src/main/java/io/milvus/v2/service/collection/request/RenameCollectionReq.java

@@ -25,6 +25,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class RenameCollectionReq {
+    private String databaseName;
     private String collectionName;
     private String newCollectionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/database/DatabaseService.java

@@ -32,7 +32,7 @@ import java.util.Map;
 
 public class DatabaseService extends BaseService {
     public Void createDatabase(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateDatabaseReq request) {
-        String title = String.format("CreateDatabaseRequest databaseName:%s", request.getDatabaseName());
+        String title = String.format("Create database: '%s'", request.getDatabaseName());
         CreateDatabaseRequest.Builder builder = CreateDatabaseRequest.newBuilder()
                 .setDbName(request.getDatabaseName());
         List<KeyValuePair> propertiesList = ParamUtils.AssembleKvPair(request.getProperties());
@@ -46,7 +46,7 @@ public class DatabaseService extends BaseService {
     }
 
     public Void dropDatabase(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropDatabaseReq request) {
-        String title = String.format("DropDatabaseRequest databaseName:%s", request.getDatabaseName());
+        String title = String.format("Drop database: '%s'", request.getDatabaseName());
         DropDatabaseRequest rpcRequest = DropDatabaseRequest.newBuilder()
                 .setDbName(request.getDatabaseName())
                 .build();
@@ -58,6 +58,7 @@ public class DatabaseService extends BaseService {
 
     public ListDatabasesResp listDatabases(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub) {
         ListDatabasesResponse response = blockingStub.listDatabases(ListDatabasesRequest.newBuilder().build());
+        rpcUtils.handleResponse("List databases", response.getStatus());
         ListDatabasesResp listDatabasesResp = ListDatabasesResp.builder()
                 .databaseNames(response.getDbNamesList())
                 .build();
@@ -66,7 +67,7 @@ public class DatabaseService extends BaseService {
     }
 
     public Void alterDatabaseProperties(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, AlterDatabasePropertiesReq request) {
-        String title = String.format("AlterDatabasePropertiesReq databaseName:%s", request.getDatabaseName());
+        String title = String.format("Alter properties of database: '%s'", request.getDatabaseName());
         AlterDatabaseRequest.Builder builder = AlterDatabaseRequest.newBuilder()
                 .setDbName(request.getDatabaseName());
         List<KeyValuePair> propertiesList = ParamUtils.AssembleKvPair(request.getProperties());
@@ -80,7 +81,7 @@ public class DatabaseService extends BaseService {
     }
 
     public Void dropDatabaseProperties(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropDatabasePropertiesReq request) {
-        String title = String.format("DropDatabasePropertiesReq databaseName:%s", request.getDatabaseName());
+        String title = String.format("Drop properties of database: '%s'", request.getDatabaseName());
         AlterDatabaseRequest.Builder builder = AlterDatabaseRequest.newBuilder()
                 .setDbName(request.getDatabaseName())
                 .addAllDeleteKeys(request.getPropertyKeys());
@@ -91,7 +92,7 @@ public class DatabaseService extends BaseService {
     }
 
     public DescribeDatabaseResp describeDatabase(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DescribeDatabaseReq request) {
-        String title = String.format("DescribeDatabaseRequest databaseName:%s", request.getDatabaseName());
+        String title = String.format("Describe database: '%s'", request.getDatabaseName());
         DescribeDatabaseRequest rpcRequest = DescribeDatabaseRequest.newBuilder()
                 .setDbName(request.getDatabaseName())
                 .build();

sdk-core/src/main/java/io/milvus/v2/service/index/IndexService.java

@@ -55,23 +55,25 @@ import java.util.stream.Collectors;
 public class IndexService extends BaseService {
 
     public Void createIndex(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateIndexReq request) {
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
         for(IndexParam indexParam : request.getIndexParams()) {
-            String title = String.format("CreateIndexRequest collectionName:%s, fieldName:%s",
-                    request.getCollectionName(), indexParam.getFieldName());
+            String fieldName = indexParam.getFieldName();
+            String indexName = indexParam.getIndexName();
+            String title = String.format("Create index for field: '%s' in collection: '%s' in database: '%s'",
+                    fieldName, collectionName, dbName);
             CreateIndexRequest.Builder builder = CreateIndexRequest.newBuilder();
-            builder.setCollectionName(request.getCollectionName())
-                    .setFieldName(indexParam.getFieldName())
+            builder.setCollectionName(collectionName)
+                    .setFieldName(fieldName)
                     .addExtraParams(KeyValuePair.newBuilder()
                             .setKey(Constant.INDEX_TYPE)
                             .setValue(indexParam.getIndexType().getName())
                             .build());
-
-            if (StringUtils.isNotEmpty(indexParam.getIndexName())) {
-                builder.setIndexName(indexParam.getIndexName());
+            if (StringUtils.isNotEmpty(indexName)) {
+                builder.setIndexName(indexName);
             }
-
-            if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-                builder.setDbName(request.getDatabaseName());
+            if (StringUtils.isNotEmpty(dbName)) {
+                builder.setDbName(dbName);
             }
 
             if(indexParam.getMetricType()!= null){
@@ -94,8 +96,7 @@ public class IndexService extends BaseService {
             Status status = blockingStub.createIndex(builder.build());
             rpcUtils.handleResponse(title, status);
             if (request.getSync()) {
-                WaitForIndexComplete(blockingStub, request.getDatabaseName(), request.getCollectionName(), indexParam.getFieldName(),
-                        indexParam.getIndexName(), request.getTimeout());
+                WaitForIndexComplete(blockingStub, dbName, collectionName, fieldName, indexName, request.getTimeout());
             }
         }
 
@@ -103,35 +104,43 @@ public class IndexService extends BaseService {
     }
 
     public Void dropIndex(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropIndexReq request) {
-        String title = String.format("DropIndexRequest collectionName:%s, fieldName:%s, indexName:%s",
-                request.getCollectionName(), request.getFieldName(), request.getIndexName());
-        DropIndexRequest dropIndexRequest = DropIndexRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setFieldName(request.getFieldName() == null ? "" : request.getFieldName())
-                .setIndexName(request.getIndexName() == null ? "" : request.getIndexName())
-                .build();
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String fieldName = request.getFieldName();
+        String indexName = request.getIndexName();
+        String title = String.format("Drop index in collection: '%s' in database: '%s', fieldName: '%s', indexName: '%s'",
+                collectionName, dbName, fieldName, indexName);
 
-        Status status = blockingStub.dropIndex(dropIndexRequest);
+        DropIndexRequest.Builder builder = DropIndexRequest.newBuilder()
+                .setCollectionName(collectionName)
+                .setFieldName(fieldName == null ? "" : fieldName)
+                .setIndexName(indexName == null ? "" : indexName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        Status status = blockingStub.dropIndex(builder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
     
     public Void alterIndexProperties(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, AlterIndexPropertiesReq request) {
-        String title = String.format("AlterIndexPropertiesReq collectionName:%s, indexName:%s",
-                request.getCollectionName(), request.getIndexName());
-        AlterIndexRequest.Builder builder = AlterIndexRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setIndexName(request.getIndexName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String indexName = request.getIndexName();
+        String title = String.format("Alter properties of index: '%s' in collection: '%s' in database: '%s'",
+                indexName, collectionName, dbName);
 
+        AlterIndexRequest.Builder builder = AlterIndexRequest.newBuilder()
+                .setCollectionName(collectionName)
+                .setIndexName(indexName);
         List<KeyValuePair> propertiesList = ParamUtils.AssembleKvPair(request.getProperties());
         if (CollectionUtils.isNotEmpty(propertiesList)) {
             propertiesList.forEach(builder::addExtraParams);
         }
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
-
         Status response = blockingStub.alterIndex(builder.build());
         rpcUtils.handleResponse(title, response);
 
@@ -139,17 +148,19 @@ public class IndexService extends BaseService {
     }
 
     public Void dropIndexProperties(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropIndexPropertiesReq request) {
-        String title = String.format("DropIndexPropertiesReq collectionName:%s, indexName:%s",
-                request.getCollectionName(), request.getIndexName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String indexName = request.getIndexName();
+        String title = String.format("Drop properties of index: '%s' in collection: '%s' in database: '%s'",
+                indexName, collectionName, dbName);
+
         AlterIndexRequest.Builder builder = AlterIndexRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setIndexName(request.getIndexName())
+                .setCollectionName(collectionName)
+                .setIndexName(indexName)
                 .addAllDeleteKeys(request.getPropertyKeys());
-
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
-
         Status response = blockingStub.alterIndex(builder.build());
         rpcUtils.handleResponse(title, response);
 
@@ -157,33 +168,41 @@ public class IndexService extends BaseService {
     }
 
     public DescribeIndexResp describeIndex(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DescribeIndexReq request) {
-        String title = String.format("DescribeIndexRequest databaseName:%s collectionName:%s, fieldName:%s, indexName:%s",
-               request.getDatabaseName(), request.getCollectionName(), request.getFieldName(), request.getIndexName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String fieldName = request.getFieldName();
+        String indexName = request.getIndexName();
+        String title = String.format("Describe index in collection: '%s' in database: '%s', fieldName: '%s', indexName: '%s'",
+                collectionName, dbName, fieldName, indexName);
+
         DescribeIndexRequest.Builder builder = DescribeIndexRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setFieldName(request.getFieldName() == null ? "" : request.getFieldName())
-                .setIndexName(request.getIndexName() == null ? "" : request.getIndexName());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            builder.setDbName(request.getDatabaseName());
+                .setCollectionName(collectionName)
+                .setFieldName(fieldName == null ? "" : fieldName)
+                .setIndexName(indexName == null ? "" : indexName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         DescribeIndexResponse response = blockingStub.describeIndex(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
-        List<IndexDescription> indexs = response.getIndexDescriptionsList().stream().filter(index -> index.getIndexName().equals(request.getIndexName()) || index.getFieldName().equals(request.getFieldName())).collect(Collectors.toList());
-        return convertUtils.convertToDescribeIndexResp(indexs);
+        List<IndexDescription> indexes = response.getIndexDescriptionsList().stream().filter(index -> index.getIndexName().equals(request.getIndexName()) || index.getFieldName().equals(request.getFieldName())).collect(Collectors.toList());
+        return convertUtils.convertToDescribeIndexResp(indexes);
     }
 
     public List<String> listIndexes(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, ListIndexesReq request) {
-        String title = String.format("ListIndexesRequest collectionName:%s", request.getCollectionName());
-        DescribeIndexRequest describeIndexRequest = DescribeIndexRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .build();
-        if (request.getFieldName() != null) {
-            describeIndexRequest = describeIndexRequest.toBuilder()
-                    .setFieldName(request.getFieldName())
-                    .build();
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String fieldName = request.getFieldName();
+        String title = String.format("List indexes in collection: '%s' in database: '%s'", collectionName, dbName);
+        DescribeIndexRequest.Builder builder = DescribeIndexRequest.newBuilder()
+                .setCollectionName(collectionName);
+        if (StringUtils.isNotEmpty(fieldName)) {
+            builder.setFieldName(fieldName);
         }
-        DescribeIndexResponse response = blockingStub.describeIndex(describeIndexRequest);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        DescribeIndexResponse response = blockingStub.describeIndex(builder.build());
         // if the collection has no index, return empty list, instead of throwing an exception
         if (response.getStatus().getErrorCode() == io.milvus.grpc.ErrorCode.IndexNotExist ||
                 response.getStatus().getCode() == 700) {
@@ -192,46 +211,45 @@ public class IndexService extends BaseService {
         rpcUtils.handleResponse(title, response.getStatus());
 
         return response.getIndexDescriptionsList().stream()
-                .filter(desc -> request.getFieldName() == null || desc.getFieldName().equals(request.getFieldName()))
+                .filter(desc -> fieldName == null || desc.getFieldName().equals(fieldName))
                 .map(IndexDescription::getIndexName)
                 .collect(Collectors.toList());
     }
 
-    private void WaitForIndexComplete(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
-                                     String databaseName, String collectionName, String fieldName, String indexName, long timeoutMs) {
+    private void WaitForIndexComplete(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, String dbName,
+                                      String collectionName, String fieldName, String indexName, long timeoutMs) {
         long startTime = System.currentTimeMillis(); // Capture start time/ Timeout in milliseconds (60 seconds)
 
         // alloc a timestamp from the server, the DescribeIndex() will use this timestamp to check the segments
         // which are generated before this timestamp.
         AllocTimestampResponse allocTsResp = blockingStub.allocTimestamp(AllocTimestampRequest.newBuilder().build());
-        rpcUtils.handleResponse("AllocTimestampRequest", allocTsResp.getStatus());
+        rpcUtils.handleResponse("Alloc timestamp", allocTsResp.getStatus());
         long serverTs = allocTsResp.getTimestamp();
 
         while (true) {
             DescribeIndexReq describeIndexReq = DescribeIndexReq.builder()
+                    .databaseName(dbName)
                     .collectionName(collectionName)
                     .fieldName(fieldName)
                     .indexName(indexName)
                     .timestamp(serverTs)
                     .build();
-            if (StringUtils.isNotEmpty(databaseName)) {
-                describeIndexReq.setDatabaseName(databaseName);
-            }
             DescribeIndexResp response = describeIndex(blockingStub, describeIndexReq);
-            List<DescribeIndexResp.IndexDesc> indices = response.getIndexDescriptions();
-            if (CollectionUtils.isEmpty(indices)) {
-                String msg = String.format("Failed to describe the index '%s' of field '%s' from serv side", fieldName, indexName);
+            List<DescribeIndexResp.IndexDesc> descs = response.getIndexDescriptions();
+            if (CollectionUtils.isEmpty(descs)) {
+                String msg = String.format("No index is found, indexName: '%s' fieldName: '%s' in collection: '%s' in database: '%s'",
+                        fieldName, indexName, collectionName, dbName);
                 throw new MilvusClientException(ErrorCode.SERVER_ERROR, msg);
             }
 
             boolean allIndexBuildCompleted = true;
-            for (DescribeIndexResp.IndexDesc index : indices) {
-                if (index.getIndexState() == IndexBuildState.Failed) {
-                    String msg = "Index is failed, reason: " + index.getIndexFailedReason();
-                    throw new MilvusClientException(ErrorCode.SERVER_ERROR, msg);
+            for (DescribeIndexResp.IndexDesc desc : descs) {
+                if (desc.getIndexState() == IndexBuildState.Failed) {
+                    throw new MilvusClientException(ErrorCode.SERVER_ERROR,
+                            "Index is failed, reason: " + desc.getIndexFailedReason());
                 }
 
-                if (index.getIndexState() != IndexBuildState.Finished) {
+                if (desc.getIndexState() != IndexBuildState.Finished) {
                     allIndexBuildCompleted = false;
                 }
             }

sdk-core/src/main/java/io/milvus/v2/service/index/request/DropIndexReq.java

@@ -26,6 +26,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class DropIndexReq {
+    private String databaseName;
     @NonNull
     private String collectionName;
     private String fieldName;

sdk-core/src/main/java/io/milvus/v2/service/index/request/ListIndexesReq.java

@@ -26,6 +26,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class ListIndexesReq {
+    private String databaseName;
     @NonNull
     private String collectionName;
     private String fieldName;

sdk-core/src/main/java/io/milvus/v2/service/partition/PartitionService.java

@@ -25,119 +25,166 @@ import io.milvus.v2.exception.MilvusClientException;
 import io.milvus.v2.service.BaseService;
 import io.milvus.v2.service.partition.request.*;
 import io.milvus.v2.service.partition.response.*;
+import org.apache.commons.lang3.StringUtils;
 
 import java.util.List;
 
 public class PartitionService extends BaseService {
     public Void createPartition(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreatePartitionReq request) {
-        String title = String.format("Create partition %s in collection %s", request.getPartitionName(), request.getCollectionName());
-
-        CreatePartitionRequest createPartitionRequest = io.milvus.grpc.CreatePartitionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setPartitionName(request.getPartitionName()).build();
-
-        Status status = blockingStub.createPartition(createPartitionRequest);
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String partitionName = request.getPartitionName();
+        String title = String.format("Create partition: '%s' in collection: '%s' in database: '%s'",
+                partitionName, collectionName, dbName);
+
+        CreatePartitionRequest.Builder builder = CreatePartitionRequest.newBuilder()
+                .setCollectionName(collectionName)
+                .setPartitionName(partitionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        Status status = blockingStub.createPartition(builder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
 
     public Void dropPartition(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropPartitionReq request) {
-        String title = String.format("Drop partition %s in collection %s", request.getPartitionName(), request.getCollectionName());
-
-        io.milvus.grpc.DropPartitionRequest dropPartitionRequest = io.milvus.grpc.DropPartitionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setPartitionName(request.getPartitionName()).build();
-
-        Status status = blockingStub.dropPartition(dropPartitionRequest);
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String partitionName = request.getPartitionName();
+        String title = String.format("Drop partition: '%s' in collection: '%s' in database: '%s'",
+                partitionName, collectionName, dbName);
+
+        DropPartitionRequest.Builder builder = DropPartitionRequest.newBuilder()
+                .setCollectionName(collectionName)
+                .setPartitionName(partitionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        Status status = blockingStub.dropPartition(builder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
 
     public Boolean hasPartition(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, HasPartitionReq request) {
-        String title = String.format("Has partition %s in collection %s", request.getPartitionName(), request.getCollectionName());
-
-        io.milvus.grpc.HasPartitionRequest hasPartitionRequest = io.milvus.grpc.HasPartitionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setPartitionName(request.getPartitionName()).build();
-
-        io.milvus.grpc.BoolResponse boolResponse = blockingStub.hasPartition(hasPartitionRequest);
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String partitionName = request.getPartitionName();
+        String title = String.format("Has partition: '%s' in collection: '%s' in database: '%s'",
+                partitionName, collectionName, dbName);
+
+        HasPartitionRequest.Builder builder = HasPartitionRequest.newBuilder()
+                .setCollectionName(collectionName)
+                .setPartitionName(partitionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        BoolResponse boolResponse = blockingStub.hasPartition(builder.build());
         rpcUtils.handleResponse(title, boolResponse.getStatus());
 
         return boolResponse.getValue();
     }
 
     public List<String> listPartitions(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, ListPartitionsReq request) {
-        String title = String.format("List partitions in collection %s", request.getCollectionName());
-
-        io.milvus.grpc.ShowPartitionsRequest showPartitionsRequest = io.milvus.grpc.ShowPartitionsRequest.newBuilder()
-                .setCollectionName(request.getCollectionName()).build();
-
-        io.milvus.grpc.ShowPartitionsResponse showPartitionsResponse = blockingStub.showPartitions(showPartitionsRequest);
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("List partitions in collection: '%s' in database: '%s'", collectionName, dbName);
+
+        ShowPartitionsRequest.Builder builder = ShowPartitionsRequest.newBuilder()
+                .setCollectionName(request.getCollectionName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        ShowPartitionsResponse showPartitionsResponse = blockingStub.showPartitions(builder.build());
         rpcUtils.handleResponse(title, showPartitionsResponse.getStatus());
 
         return showPartitionsResponse.getPartitionNamesList();
     }
 
-    public GetPartitionStatsResp getPartitionStats(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GetPartitionStatsReq request) {
-        String title = String.format("GetCollectionStatisticsRequest collectionName:%s", request.getCollectionName());
-        GetPartitionStatisticsRequest getPartitionStatisticsRequest = GetPartitionStatisticsRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setPartitionName(request.getPartitionName())
-                .build();
-        GetPartitionStatisticsResponse response = blockingStub.getPartitionStatistics(getPartitionStatisticsRequest);
-
+    public GetPartitionStatsResp getPartitionStats(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
+                                                   GetPartitionStatsReq request) {
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String partitionName = request.getPartitionName();
+        String title = String.format("Get statistics of partition: '%s' in collection: '%s' in database: '%s'",
+                partitionName, collectionName, dbName);
+
+        GetPartitionStatisticsRequest.Builder builder = GetPartitionStatisticsRequest.newBuilder()
+                .setCollectionName(collectionName)
+                .setPartitionName(partitionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        GetPartitionStatisticsResponse response = blockingStub.getPartitionStatistics(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
         GetPartitionStatsResp getPartitionStatsResp = GetPartitionStatsResp.builder()
-                .numOfEntities(response.getStatsList().stream().filter(stat -> stat.getKey().equals("row_count")).map(stat -> Long.parseLong(stat.getValue())).findFirst().get())
+                .numOfEntities(response.getStatsList().stream().filter(stat -> stat.getKey().equals("row_count"))
+                        .map(stat -> Long.parseLong(stat.getValue())).findFirst().get())
                 .build();
         return getPartitionStatsResp;
     }
 
     public Void loadPartitions(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, LoadPartitionsReq request) {
-        String title = String.format("Load partitions %s in collection %s", request.getPartitionNames(), request.getCollectionName());
-
-        io.milvus.grpc.LoadPartitionsRequest loadPartitionsRequest = io.milvus.grpc.LoadPartitionsRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .addAllPartitionNames(request.getPartitionNames())
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        List<String> partitionNames = request.getPartitionNames();
+        String title = String.format("Load partitions: %s in collection: '%s' in database: '%s'",
+                partitionNames, collectionName, dbName);
+
+        LoadPartitionsRequest.Builder builder = LoadPartitionsRequest.newBuilder()
+                .setCollectionName(collectionName)
+                .addAllPartitionNames(partitionNames)
                 .setReplicaNumber(request.getNumReplicas())
                 .setRefresh(request.getRefresh())
                 .addAllLoadFields(request.getLoadFields())
                 .setSkipLoadDynamicField(request.getSkipLoadDynamicField())
-                .addAllResourceGroups(request.getResourceGroups())
-                .build();
-        Status status = blockingStub.loadPartitions(loadPartitionsRequest);
+                .addAllResourceGroups(request.getResourceGroups());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        Status status = blockingStub.loadPartitions(builder.build());
         rpcUtils.handleResponse(title, status);
         if (request.getSync()) {
-            WaitForLoadPartitions(blockingStub, request.getCollectionName(), request.getPartitionNames(), request.getTimeout());
+            WaitForLoadPartitions(blockingStub, dbName, collectionName, partitionNames, request.getTimeout());
         }
 
         return null;
     }
 
     public Void releasePartitions(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, ReleasePartitionsReq request) {
-        String title = String.format("Release partitions %s in collection %s", request.getPartitionNames(), request.getCollectionName());
-
-        io.milvus.grpc.ReleasePartitionsRequest releasePartitionsRequest = io.milvus.grpc.ReleasePartitionsRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .addAllPartitionNames(request.getPartitionNames()).build();
-        Status status = blockingStub.releasePartitions(releasePartitionsRequest);
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        List<String> partitionNames = request.getPartitionNames();
+        String title = String.format("Release partitions: %s in collection: '%s' in database: '%s'",
+                partitionNames, collectionName, dbName);
+
+        ReleasePartitionsRequest.Builder builder = ReleasePartitionsRequest.newBuilder()
+                .setCollectionName(collectionName)
+                .addAllPartitionNames(partitionNames);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        Status status = blockingStub.releasePartitions(builder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
 
-    private void WaitForLoadPartitions(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
+    private void WaitForLoadPartitions(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, String dbName,
                                        String collectionName, List<String> partitions, long timeoutMs) {
         long startTime = System.currentTimeMillis(); // Capture start time/ Timeout in milliseconds (60 seconds)
 
         while (true) {
-            GetLoadingProgressResponse response = blockingStub.getLoadingProgress(GetLoadingProgressRequest.newBuilder()
+            GetLoadingProgressRequest.Builder builder = GetLoadingProgressRequest.newBuilder()
                     .setCollectionName(collectionName)
-                    .addAllPartitionNames(partitions)
-                    .build());
-            String title = String.format("GetLoadingProgressRequest collectionName:%s", collectionName);
+                    .addAllPartitionNames(partitions);
+            if (StringUtils.isNotEmpty(dbName)) {
+                builder.setDbName(dbName);
+            }
+            GetLoadingProgressResponse response = blockingStub.getLoadingProgress(builder.build());
+            String title = String.format("Get loading progress of collection: '%s' in database: '%s'", collectionName, dbName);
             rpcUtils.handleResponse(title, response.getStatus());
             if (response.getProgress() >= 100) {
                 return;

sdk-core/src/main/java/io/milvus/v2/service/partition/request/CreatePartitionReq.java

@@ -25,6 +25,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class CreatePartitionReq {
+    private String databaseName;
     private String collectionName;
     private String partitionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/partition/request/DropPartitionReq.java

@@ -25,6 +25,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class DropPartitionReq {
+    private String databaseName;
     private String collectionName;
     private String partitionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/partition/request/GetPartitionStatsReq.java

@@ -25,6 +25,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class GetPartitionStatsReq {
+    private String databaseName;
     private String collectionName;
     private String partitionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/partition/request/HasPartitionReq.java

@@ -25,6 +25,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class HasPartitionReq {
+    private String databaseName;
     private String collectionName;
     private String partitionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/partition/request/ListPartitionsReq.java

@@ -25,5 +25,6 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class ListPartitionsReq {
+    private String databaseName;
     private String collectionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/partition/request/LoadPartitionsReq.java

@@ -29,6 +29,7 @@ import java.util.List;
 @Data
 @SuperBuilder
 public class LoadPartitionsReq {
+    private String databaseName;
     private String collectionName;
     @Builder.Default
     private List<String> partitionNames = new ArrayList<>();

sdk-core/src/main/java/io/milvus/v2/service/partition/request/ReleasePartitionsReq.java

@@ -27,6 +27,7 @@ import java.util.List;
 @Data
 @SuperBuilder
 public class ReleasePartitionsReq {
+    private String databaseName;
     private String collectionName;
     private List<String> partitionNames;
 }

sdk-core/src/main/java/io/milvus/v2/service/rbac/RBACService.java

@@ -35,16 +35,15 @@ import java.util.stream.Collectors;
 
 public class RBACService extends BaseService {
     public List<String> listRoles(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub) {
-        String title = "listRoles";
         SelectRoleRequest request = SelectRoleRequest.newBuilder().build();
         SelectRoleResponse response = blockingStub.selectRole(request);
 
-        rpcUtils.handleResponse(title, response.getStatus());
+        rpcUtils.handleResponse("List roles", response.getStatus());
         return response.getResultsList().stream().map(roleResult -> roleResult.getRole().getName()).collect(Collectors.toList());
     }
 
     public Void createRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateRoleReq request) {
-        String title = "createRole";
+        String title = String.format("Create role: '%s'", request.getRoleName());
         CreateRoleRequest createRoleRequest = CreateRoleRequest.newBuilder()
                 .setEntity(RoleEntity.newBuilder()
                         .setName(request.getRoleName())
@@ -57,13 +56,15 @@ public class RBACService extends BaseService {
     }
 
     public DescribeRoleResp describeRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DescribeRoleReq request) {
-        String title = "describeRole";
+        String dbName = request.getDbName();
+        String roleName = request.getRoleName();
+        String title = String.format("Describe role: '%s' in database: '%s'", roleName, dbName);
         GrantEntity.Builder builder = GrantEntity.newBuilder()
                 .setRole(RoleEntity.newBuilder()
-                        .setName(request.getRoleName())
+                        .setName(roleName)
                         .build());
-        if (StringUtils.isNotEmpty(request.getDbName())) {
-            builder.setDbName(request.getDbName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
         SelectGrantRequest selectGrantRequest = SelectGrantRequest.newBuilder()
@@ -84,7 +85,7 @@ public class RBACService extends BaseService {
     }
 
     public Void dropRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropRoleReq request) {
-        String title = "dropRole";
+        String title = String.format("Drop role: '%s'", request.getRoleName());
         DropRoleRequest dropRoleRequest = DropRoleRequest.newBuilder()
                 .setRoleName(request.getRoleName())
                 .build();
@@ -95,7 +96,7 @@ public class RBACService extends BaseService {
     }
 
     public Void grantPrivilege(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GrantPrivilegeReq request) {
-        String title = "grantPrivilege";
+        String title = String.format("Grant privilege for role: '%s'", request.getRoleName());
         GrantEntity entity = GrantEntity.newBuilder()
                 .setRole(RoleEntity.newBuilder()
                         .setName(request.getRoleName())
@@ -116,7 +117,7 @@ public class RBACService extends BaseService {
     }
 
     public Void revokePrivilege(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, RevokePrivilegeReq request) {
-        String title = "revokePrivilege";
+        String title = String.format("Revoke privilege for role: '%s'", request.getRoleName());
         GrantEntity entity = GrantEntity.newBuilder()
                 .setRole(RoleEntity.newBuilder()
                         .setName(request.getRoleName())
@@ -137,10 +138,12 @@ public class RBACService extends BaseService {
     }
 
     public Void grantRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GrantRoleReq request) {
-        String title = "grantRole";
+        String roleName = request.getRoleName();
+        String userName = request.getUserName();
+        String title = String.format("Grant role: '%s' to user: '%s'", roleName, userName);
         OperateUserRoleRequest operateUserRoleRequest = OperateUserRoleRequest.newBuilder()
-                .setUsername(request.getUserName())
-                .setRoleName(request.getRoleName())
+                .setUsername(userName)
+                .setRoleName(roleName)
                 .setType(OperateUserRoleType.AddUserToRole)
                 .build();
         Status status = blockingStub.operateUserRole(operateUserRoleRequest);
@@ -150,10 +153,12 @@ public class RBACService extends BaseService {
     }
 
     public Void revokeRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, RevokeRoleReq request) {
-        String title = "grantRole";
+        String roleName = request.getRoleName();
+        String userName = request.getUserName();
+        String title = String.format("Revoke role: '%s' from user: '%s'", roleName, userName);
         OperateUserRoleRequest operateUserRoleRequest = OperateUserRoleRequest.newBuilder()
-                .setUsername(request.getUserName())
-                .setRoleName(request.getRoleName())
+                .setUsername(userName)
+                .setRoleName(roleName)
                 .setType(OperateUserRoleType.RemoveUserFromRole)
                 .build();
         Status status = blockingStub.operateUserRole(operateUserRoleRequest);
@@ -164,21 +169,19 @@ public class RBACService extends BaseService {
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////
     public List<String> listUsers(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub) {
-        String title = "list users";
         ListCredUsersRequest request = ListCredUsersRequest.newBuilder().build();
         ListCredUsersResponse response = blockingStub.listCredUsers(request);
-        rpcUtils.handleResponse(title, response.getStatus());
+        rpcUtils.handleResponse("List users", response.getStatus());
         return response.getUsernamesList();
     }
 
     public DescribeUserResp describeUser(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DescribeUserReq request) {
-        String title = String.format("describe user %s", request.getUserName());
-        // TODO: check user exists
+        String title = String.format("Describe user: '%s'", request.getUserName());
         SelectUserRequest selectUserRequest = SelectUserRequest.newBuilder()
                 .setUser(UserEntity.newBuilder().setName(request.getUserName()).build())
                 .setIncludeRoleInfo(Boolean.TRUE)
                 .build();
-        io.milvus.grpc.SelectUserResponse response = blockingStub.selectUser(selectUserRequest);
+        SelectUserResponse response = blockingStub.selectUser(selectUserRequest);
         rpcUtils.handleResponse(title, response.getStatus());
         DescribeUserResp describeUserResp = DescribeUserResp.builder()
                 .roles(response.getResultsList().isEmpty()? null : response.getResultsList().get(0).getRolesList().stream().map(RoleEntity::getName).collect(Collectors.toList()))
@@ -187,7 +190,7 @@ public class RBACService extends BaseService {
     }
 
     public Void createUser(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateUserReq request) {
-        String title = String.format("create user %s", request.getUserName());
+        String title = String.format("Create user: '%s'", request.getUserName());
         CreateCredentialRequest createCredentialRequest = CreateCredentialRequest.newBuilder()
                 .setUsername(request.getUserName())
                 .setPassword(Base64.getEncoder().encodeToString(request.getPassword().getBytes(StandardCharsets.UTF_8)))
@@ -200,7 +203,7 @@ public class RBACService extends BaseService {
 
 
     public Void updatePassword(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, UpdatePasswordReq request) {
-        String title = String.format("update password for user %s", request.getUserName());
+        String title = String.format("Update password for user: '%s'", request.getUserName());
         UpdateCredentialRequest updateCredentialRequest = UpdateCredentialRequest.newBuilder()
                 .setUsername(request.getUserName())
                 .setOldPassword(Base64.getEncoder().encodeToString(request.getPassword().getBytes(StandardCharsets.UTF_8)))
@@ -213,7 +216,7 @@ public class RBACService extends BaseService {
     }
 
     public Void dropUser(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropUserReq request) {
-        String title = String.format("drop user %s", request.getUserName());
+        String title = String.format("Drop user: '%s'", request.getUserName());
         DeleteCredentialRequest deleteCredentialRequest = DeleteCredentialRequest.newBuilder()
                 .setUsername(request.getUserName())
                 .build();
@@ -225,7 +228,7 @@ public class RBACService extends BaseService {
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////
     public Void createPrivilegeGroup(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreatePrivilegeGroupReq request) {
-        String title = String.format("create privilege group %s", request.getGroupName());
+        String title = String.format("Create privilege group: '%s'", request.getGroupName());
         CreatePrivilegeGroupRequest createPrivilegeGroupRequest = CreatePrivilegeGroupRequest.newBuilder()
                 .setGroupName(request.getGroupName())
                 .build();
@@ -236,7 +239,7 @@ public class RBACService extends BaseService {
     }
 
     public Void dropPrivilegeGroup(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropPrivilegeGroupReq request) {
-        String title = String.format("drop privilege group %s", request.getGroupName());
+        String title = String.format("Drop privilege group: '%s'", request.getGroupName());
         DropPrivilegeGroupRequest dropPrivilegeGroupRequest = DropPrivilegeGroupRequest.newBuilder()
                 .setGroupName(request.getGroupName())
                 .build();
@@ -247,11 +250,10 @@ public class RBACService extends BaseService {
     }
 
     public ListPrivilegeGroupsResp listPrivilegeGroups(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, ListPrivilegeGroupsReq request) {
-        String title = "list privilege groups";
         ListPrivilegeGroupsRequest listPrivilegeGroupsRequest = ListPrivilegeGroupsRequest.newBuilder()
                 .build();
         ListPrivilegeGroupsResponse response = blockingStub.listPrivilegeGroups(listPrivilegeGroupsRequest);
-        rpcUtils.handleResponse(title, response.getStatus());
+        rpcUtils.handleResponse("List privilege groups", response.getStatus());
 
         List<PrivilegeGroup> privilegeGroups = new ArrayList<>();
         response.getPrivilegeGroupsList().forEach((privilegeGroupInfo)->{
@@ -268,7 +270,7 @@ public class RBACService extends BaseService {
     }
 
     public Void addPrivilegesToGroup(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, AddPrivilegesToGroupReq request) {
-        String title = String.format("add privilege to group %s", request.getGroupName());
+        String title = String.format("Add privilege to group: '%s'", request.getGroupName());
         OperatePrivilegeGroupRequest.Builder builder = OperatePrivilegeGroupRequest.newBuilder()
                 .setGroupName(request.getGroupName())
                 .setType(OperatePrivilegeGroupType.AddPrivilegesToGroup);
@@ -283,7 +285,7 @@ public class RBACService extends BaseService {
     }
 
     public Void removePrivilegesFromGroup(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, RemovePrivilegesFromGroupReq request) {
-        String title = String.format("remove privilege from group %s", request.getGroupName());
+        String title = String.format("Remove privilege from group: '%s'", request.getGroupName());
         OperatePrivilegeGroupRequest.Builder builder = OperatePrivilegeGroupRequest.newBuilder()
                 .setGroupName(request.getGroupName())
                 .setType(OperatePrivilegeGroupType.RemovePrivilegesFromGroup);
@@ -298,12 +300,15 @@ public class RBACService extends BaseService {
     }
 
     public Void grantPrivilegeV2(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GrantPrivilegeReqV2 request) {
-        String title = "grantPrivilegeV2";
+        String dbName = request.getDbName();
+        String roleName = request.getRoleName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Grant privilege to user: '%s' for collection: '%s' in database: '%s'", roleName, collectionName, dbName);
         OperatePrivilegeV2Request.Builder builder = OperatePrivilegeV2Request.newBuilder()
-                .setRole(RoleEntity.newBuilder().setName(request.getRoleName()).build())
+                .setRole(RoleEntity.newBuilder().setName(roleName).build())
                 .setGrantor(GrantorEntity.newBuilder().setPrivilege(PrivilegeEntity.newBuilder().setName(request.getPrivilege()).build()).build())
-                .setDbName(request.getDbName())
-                .setCollectionName(request.getCollectionName())
+                .setDbName(dbName)
+                .setCollectionName(collectionName)
                 .setType(OperatePrivilegeType.Grant);
 
         Status response = blockingStub.operatePrivilegeV2(builder.build());
@@ -313,12 +318,15 @@ public class RBACService extends BaseService {
     }
 
     public Void revokePrivilegeV2(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, RevokePrivilegeReqV2 request) {
-        String title = "revokePrivilegeV2";
+        String dbName = request.getDbName();
+        String roleName = request.getRoleName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Revoke privilege from user: '%s' for collection: '%s' in database: '%s'", roleName, collectionName, dbName);
         OperatePrivilegeV2Request.Builder builder = OperatePrivilegeV2Request.newBuilder()
-                .setRole(RoleEntity.newBuilder().setName(request.getRoleName()).build())
+                .setRole(RoleEntity.newBuilder().setName(roleName).build())
                 .setGrantor(GrantorEntity.newBuilder().setPrivilege(PrivilegeEntity.newBuilder().setName(request.getPrivilege()).build()).build())
-                .setDbName(request.getDbName())
-                .setCollectionName(request.getCollectionName())
+                .setDbName(dbName)
+                .setCollectionName(collectionName)
                 .setType(OperatePrivilegeType.Revoke);
 
         Status response = blockingStub.operatePrivilegeV2(builder.build());

sdk-core/src/main/java/io/milvus/v2/service/resourcegroup/ResourceGroupService.java

@@ -67,7 +67,7 @@ public class ResourceGroupService extends BaseService {
 
     public Void createResourceGroup(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                     CreateResourceGroupReq request) {
-        String title = String.format("CreateResourceGroupReq groupName:%s", request.getGroupName());
+        String title = String.format("Create resource group: '%s'", request.getGroupName());
 
         ResourceGroupConfig rpcConfig = convertResourceGroupConfig(request.getConfig());
         CreateResourceGroupRequest rpcRequest = CreateResourceGroupRequest.newBuilder()
@@ -82,8 +82,6 @@ public class ResourceGroupService extends BaseService {
 
     public Void updateResourceGroups(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                      UpdateResourceGroupsReq request) {
-        String title = "UpdateResourceGroupsReq";
-
         Map<String, io.milvus.common.resourcegroup.ResourceGroupConfig> resourceGroups = request.getResourceGroups();
         if (resourceGroups.isEmpty()) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Resource group configurations cannot be empty");
@@ -96,13 +94,13 @@ public class ResourceGroupService extends BaseService {
         });
 
         Status status = blockingStub.updateResourceGroups(requestBuilder.build());
-        rpcUtils.handleResponse(title, status);
+        rpcUtils.handleResponse("Update resource groups", status);
         return null;
     }
 
     public Void dropResourceGroup(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                   DropResourceGroupReq request) {
-        String title = String.format("DropResourceGroupReq groupName:%s", request.getGroupName());
+        String title = String.format("Drop resource group: '%s'", request.getGroupName());
 
         DropResourceGroupRequest rpcRequest = DropResourceGroupRequest.newBuilder()
                 .setResourceGroup(request.getGroupName())
@@ -115,9 +113,8 @@ public class ResourceGroupService extends BaseService {
 
     public ListResourceGroupsResp listResourceGroups(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                                      ListResourceGroupsReq request) {
-        String title = "ListResourceGroupsReq";
         ListResourceGroupsResponse response = blockingStub.listResourceGroups(ListResourceGroupsRequest.newBuilder().build());
-        rpcUtils.handleResponse(title, response.getStatus());
+        rpcUtils.handleResponse("List resource groups", response.getStatus());
         return ListResourceGroupsResp.builder()
                 .groupNames(response.getResourceGroupsList())
                 .build();
@@ -125,8 +122,7 @@ public class ResourceGroupService extends BaseService {
 
     public DescribeResourceGroupResp describeResourceGroup(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                                            DescribeResourceGroupReq request) {
-        String title = String.format("DescribeResourceGroupReq groupName:%s", request.getGroupName());
-
+        String title = String.format("Describe resource group: '%s'", request.getGroupName());
         DescribeResourceGroupRequest rpcRequest = DescribeResourceGroupRequest.newBuilder()
                 .setResourceGroup(request.getGroupName())
                 .build();
@@ -156,19 +152,21 @@ public class ResourceGroupService extends BaseService {
     }
 
     public Void transferNode(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, TransferNodeReq request) {
-        if (StringUtils.isEmpty(request.getSourceGroupName())) {
+        String sourceGroup = request.getSourceGroupName();
+        if (StringUtils.isEmpty(sourceGroup)) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Invalid source group name");
         }
-        if (StringUtils.isEmpty(request.getTargetGroupName())) {
+        String targetGroup = request.getTargetGroupName();
+        if (StringUtils.isEmpty(targetGroup)) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Invalid target group name");
         }
 
-        String title = String.format("TransferNode %d nodes from %s to %s", request.getNumOfNodes(),
-                request.getSourceGroupName(), request.getTargetGroupName());
+        Integer numOfNodes = request.getNumOfNodes();
+        String title = String.format("Transfer %d nodes from group: '%s' to group: '%s'", numOfNodes, sourceGroup, targetGroup);
         Status response = blockingStub.transferNode(TransferNodeRequest.newBuilder()
-                .setSourceResourceGroup(request.getSourceGroupName())
-                .setTargetResourceGroup(request.getTargetGroupName())
-                .setNumNode(request.getNumOfNodes())
+                .setSourceResourceGroup(sourceGroup)
+                .setTargetResourceGroup(targetGroup)
+                .setNumNode(numOfNodes)
                 .build());
         rpcUtils.handleResponse(title, response);
         return null;
@@ -176,27 +174,32 @@ public class ResourceGroupService extends BaseService {
 
     public Void transferReplica(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                 TransferReplicaReq request) {
-        if (StringUtils.isEmpty(request.getSourceGroupName())) {
+        String sourceGroup = request.getSourceGroupName();
+        if (StringUtils.isEmpty(sourceGroup)) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Invalid source group name");
         }
-        if (StringUtils.isEmpty(request.getTargetGroupName())) {
+        String targetGroup = request.getTargetGroupName();
+        if (StringUtils.isEmpty(targetGroup)) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Invalid target group name");
         }
-        if (StringUtils.isEmpty(request.getCollectionName())) {
+        String collectionName = request.getCollectionName();
+        if (StringUtils.isEmpty(collectionName)) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Invalid collection name");
         }
 
-        String title = String.format("TransferReplicaReq sourceGroupName:%s targetGroupName:%s collectionName:%s",
-                request.getSourceGroupName(), request.getTargetGroupName(), request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        Long numOfReplicas = request.getNumberOfReplicas();
+        String title = String.format("Transfer %d replicas from group: '%s' to group: '%s' of collection: '%s'",
+                numOfReplicas, sourceGroup, targetGroup, collectionName);
 
         TransferReplicaRequest.Builder requestBuilder = TransferReplicaRequest.newBuilder()
-                .setSourceResourceGroup(request.getSourceGroupName())
-                .setTargetResourceGroup(request.getTargetGroupName())
-                .setCollectionName(request.getCollectionName())
-                .setNumReplica(request.getNumberOfReplicas());
+                .setSourceResourceGroup(sourceGroup)
+                .setTargetResourceGroup(targetGroup)
+                .setCollectionName(collectionName)
+                .setNumReplica(numOfReplicas);
 
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            requestBuilder.setDbName(request.getDatabaseName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            requestBuilder.setDbName(dbName);
         }
 
         Status status = blockingStub.transferReplica(requestBuilder.build());

sdk-core/src/main/java/io/milvus/v2/service/utility/UtilityService.java

@@ -33,20 +33,23 @@ import java.util.stream.Collectors;
 
 public class UtilityService extends BaseService {
     public FlushResp flush(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, FlushReq request) {
+        String dbName = request.getDatabaseName();
         List<String> collectionNames = request.getCollectionNames();
-        String title = String.format("Flush collections %s", collectionNames);
+        String title = String.format("Flush collections: '%s' in database: '%s'", collectionNames, dbName);
         if (collectionNames.isEmpty()) {
             // consistent with python sdk behavior, throw an error if collection names list is null or empty
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "Collection name list can not be null or empty");
         }
 
-        FlushRequest flushRequest = io.milvus.grpc.FlushRequest.newBuilder()
-                .addAllCollectionNames(collectionNames)
-                .build();
-        FlushResponse response = blockingStub.flush(flushRequest);
+        FlushRequest.Builder builder = FlushRequest.newBuilder()
+                .addAllCollectionNames(collectionNames);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        FlushResponse response = blockingStub.flush(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
 
-        Map<String, io.milvus.grpc.LongArray> rpcCollSegIDs = response.getCollSegIDsMap();
+        Map<String, LongArray> rpcCollSegIDs = response.getCollSegIDsMap();
         Map<String, List<Long>> collectionSegmentIDs = new HashMap<>();
         rpcCollSegIDs.forEach((key, value)->{
             collectionSegmentIDs.put(key, value.getDataList());
@@ -83,18 +86,25 @@ public class UtilityService extends BaseService {
     }
 
     public CompactResp compact(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CompactReq request) {
-        String title = String.format("Compact collection %s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Compact collection: '%s' in database: '%s'", collectionName, dbName);
 
-        DescribeCollectionResponse descResponse = blockingStub.describeCollection(DescribeCollectionRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .build());
+        DescribeCollectionRequest.Builder descBuilder = DescribeCollectionRequest.newBuilder()
+                .setCollectionName(request.getCollectionName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            descBuilder.setDbName(dbName);
+        }
+        DescribeCollectionResponse descResponse = blockingStub.describeCollection(descBuilder.build());
         rpcUtils.handleResponse(title, descResponse.getStatus());
 
-        io.milvus.grpc.ManualCompactionRequest compactRequest = io.milvus.grpc.ManualCompactionRequest.newBuilder()
+        ManualCompactionRequest.Builder builder = ManualCompactionRequest.newBuilder()
                 .setCollectionID(descResponse.getCollectionID())
-                .setMajorCompaction(request.getIsClustering())
-                .build();
-        io.milvus.grpc.ManualCompactionResponse response = blockingStub.manualCompaction(compactRequest);
+                .setMajorCompaction(request.getIsClustering());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        ManualCompactionResponse response = blockingStub.manualCompaction(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
 
         return CompactResp.builder()
@@ -104,11 +114,11 @@ public class UtilityService extends BaseService {
 
     public GetCompactionStateResp getCompactionState(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                                      GetCompactionStateReq request) {
-        String title = "GetCompactionState";
-        io.milvus.grpc.GetCompactionStateRequest getRequest = io.milvus.grpc.GetCompactionStateRequest.newBuilder()
+        String title = "Get compaction state";
+        GetCompactionStateRequest getRequest = GetCompactionStateRequest.newBuilder()
                 .setCompactionID(request.getCompactionID())
                 .build();
-        io.milvus.grpc.GetCompactionStateResponse response = blockingStub.getCompactionState(getRequest);
+        GetCompactionStateResponse response = blockingStub.getCompactionState(getRequest);
         rpcUtils.handleResponse(title, response.getStatus());
 
         return GetCompactionStateResp.builder()
@@ -120,60 +130,68 @@ public class UtilityService extends BaseService {
     }
 
     public Void createAlias(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateAliasReq request) {
-        String title = String.format("CreateAlias %s for database %s collection %s", request.getAlias(), request.getDatabaseName(), request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String alias = request.getAlias();
+        String title = String.format("Create alias '%s' of collection: '%s' in database: '%s' ", alias, collectionName, dbName);
         CreateAliasRequest.Builder createAliasRequestBuilder = CreateAliasRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setAlias(request.getAlias());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            createAliasRequestBuilder.setDbName(request.getDatabaseName());
+                .setCollectionName(collectionName)
+                .setAlias(alias);
+        if (StringUtils.isNotEmpty(dbName)) {
+            createAliasRequestBuilder.setDbName(dbName);
         }
 
-        io.milvus.grpc.Status status = blockingStub.createAlias(createAliasRequestBuilder.build());
+        Status status = blockingStub.createAlias(createAliasRequestBuilder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
 
     public Void dropAlias(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropAliasReq request) {
-        String title = String.format("DropAlias %s for database %s", request.getAlias(), request.getDatabaseName());
-        DropAliasRequest.Builder dropAliasRequestBuilder = io.milvus.grpc.DropAliasRequest.newBuilder()
-                .setAlias(request.getAlias());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            dropAliasRequestBuilder.setDbName(request.getDatabaseName());
+        String dbName = request.getDatabaseName();
+        String alias = request.getAlias();
+        String title = String.format("Drop aliases '%s' in database: '%s'", alias, dbName);
+        DropAliasRequest.Builder dropAliasRequestBuilder = DropAliasRequest.newBuilder()
+                .setAlias(alias);
+        if (StringUtils.isNotEmpty(dbName)) {
+            dropAliasRequestBuilder.setDbName(dbName);
         }
-        io.milvus.grpc.Status status = blockingStub.dropAlias(dropAliasRequestBuilder.build());
+        Status status = blockingStub.dropAlias(dropAliasRequestBuilder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
 
     public Void alterAlias(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, AlterAliasReq request) {
-        String title = String.format("AlterAlias %s for database %s collection %s", request.getAlias(), request.getDatabaseName(), request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String alias = request.getAlias();
+        String title = String.format("Alter alias '%s' of collection: '%s' in database: '%s'", alias, collectionName, dbName);
         AlterAliasRequest.Builder alterAliasRequestBuilder = AlterAliasRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .setAlias(request.getAlias());
-
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            alterAliasRequestBuilder.setDbName(request.getDatabaseName());
+                .setCollectionName(collectionName)
+                .setAlias(alias);
+        if (StringUtils.isNotEmpty(dbName)) {
+            alterAliasRequestBuilder.setDbName(dbName);
         }
 
-        io.milvus.grpc.Status status = blockingStub.alterAlias(alterAliasRequestBuilder.build());
+        Status status = blockingStub.alterAlias(alterAliasRequestBuilder.build());
         rpcUtils.handleResponse(title, status);
 
         return null;
     }
 
     public DescribeAliasResp describeAlias(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DescribeAliasReq request) {
-        String title = String.format("DescribeAlias %s for database %s", request.getAlias(), request.getDatabaseName());
-        DescribeAliasRequest.Builder describeAliasRequestBuilder = io.milvus.grpc.DescribeAliasRequest.newBuilder()
-                .setAlias(request.getAlias());
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            describeAliasRequestBuilder.setDbName(request.getDatabaseName());
+        String dbName = request.getDatabaseName();
+        String alias = request.getAlias();
+        String title = String.format("Describe alias '%s' in database: '%s'", alias, dbName);
+        DescribeAliasRequest.Builder builder = DescribeAliasRequest.newBuilder()
+                .setAlias(alias);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
-        io.milvus.grpc.DescribeAliasResponse response = blockingStub.describeAlias(describeAliasRequestBuilder.build());
 
+        DescribeAliasResponse response = blockingStub.describeAlias(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
-
         return DescribeAliasResp.builder()
                 .databaseName(response.getDbName())
                 .collectionName(response.getCollection())
@@ -182,18 +200,17 @@ public class UtilityService extends BaseService {
     }
 
     public ListAliasResp listAliases(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, ListAliasesReq request) {
-        String title = "ListAliases";
-        ListAliasesRequest.Builder listAliasesRequestBuilder = ListAliasesRequest.newBuilder()
-                .setCollectionName(request.getCollectionName());
-
-        if (StringUtils.isNotEmpty(request.getDatabaseName())) {
-            listAliasesRequestBuilder.setDbName(request.getDatabaseName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("List alias of collection: '%s' in database: '%s'", collectionName, dbName);
+        ListAliasesRequest.Builder builder = ListAliasesRequest.newBuilder()
+                .setCollectionName(collectionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
 
-        io.milvus.grpc.ListAliasesResponse response = blockingStub.listAliases(listAliasesRequestBuilder.build());
-
+        ListAliasesResponse response = blockingStub.listAliases(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
-
         return ListAliasResp.builder()
                 .collectionName(response.getCollectionName())
                 .alias(response.getAliasesList())
@@ -201,7 +218,7 @@ public class UtilityService extends BaseService {
     }
 
     public CheckHealthResp checkHealth(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub) {
-        String title = "CheckHealth";
+        String title = "Check health";
         CheckHealthResponse response = blockingStub.checkHealth(CheckHealthRequest.newBuilder().build());
         rpcUtils.handleResponse(title, response.getStatus());
 
@@ -216,10 +233,15 @@ public class UtilityService extends BaseService {
 
     public GetPersistentSegmentInfoResp getPersistentSegmentInfo(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
                                     GetPersistentSegmentInfoReq request) {
-        String title = String.format("GetPersistentSegmentInfo collectionName %s", request.getCollectionName());
-        GetPersistentSegmentInfoResponse response = blockingStub.getPersistentSegmentInfo(GetPersistentSegmentInfoRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .build());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Get persistent segment info in collection: '%s' in database: '%s'", collectionName, dbName);
+        GetPersistentSegmentInfoRequest.Builder builder = GetPersistentSegmentInfoRequest.newBuilder()
+                .setCollectionName(collectionName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        GetPersistentSegmentInfoResponse response = blockingStub.getPersistentSegmentInfo(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
 
         List<GetPersistentSegmentInfoResp.PersistentSegmentInfo> segmentInfos = new ArrayList<>();
@@ -238,11 +260,16 @@ public class UtilityService extends BaseService {
     }
 
     public GetQuerySegmentInfoResp getQuerySegmentInfo(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
-                                                            GetQuerySegmentInfoReq request) {
-        String title = String.format("GetQuerySegmentInfo collectionName %s", request.getCollectionName());
-        GetQuerySegmentInfoResponse response = blockingStub.getQuerySegmentInfo(GetQuerySegmentInfoRequest.newBuilder()
-                .setCollectionName(request.getCollectionName())
-                .build());
+                                                       GetQuerySegmentInfoReq request) {
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Get query segment info in collection: '%s' in database: '%s'", collectionName, dbName);
+        GetQuerySegmentInfoRequest.Builder builder = GetQuerySegmentInfoRequest.newBuilder()
+                .setCollectionName(request.getCollectionName());
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
+        }
+        GetQuerySegmentInfoResponse response = blockingStub.getQuerySegmentInfo(builder.build());
         rpcUtils.handleResponse(title, response.getStatus());
 
         List<GetQuerySegmentInfoResp.QuerySegmentInfo> segmentInfos = new ArrayList<>();

sdk-core/src/main/java/io/milvus/v2/service/utility/request/CompactReq.java

@@ -26,6 +26,7 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class CompactReq {
+    private String databaseName;
     private String collectionName;
 
     @Builder.Default

sdk-core/src/main/java/io/milvus/v2/service/utility/request/FlushReq.java

@@ -29,6 +29,7 @@ import java.util.List;
 @Data
 @SuperBuilder
 public class FlushReq {
+    private String databaseName;
     @Builder.Default
     private List<String> collectionNames = new ArrayList<>();
 

sdk-core/src/main/java/io/milvus/v2/service/utility/request/GetPersistentSegmentInfoReq.java

@@ -6,5 +6,6 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class GetPersistentSegmentInfoReq {
+    private String databaseName;
     private String collectionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/utility/request/GetQuerySegmentInfoReq.java

@@ -6,5 +6,6 @@ import lombok.experimental.SuperBuilder;
 @Data
 @SuperBuilder
 public class GetQuerySegmentInfoReq {
+    private String databaseName;
     private String collectionName;
 }

sdk-core/src/main/java/io/milvus/v2/service/vector/VectorService.java

@@ -27,14 +27,11 @@ import io.milvus.orm.iterator.*;
 import io.milvus.v2.exception.ErrorCode;
 import io.milvus.v2.exception.MilvusClientException;
 import io.milvus.v2.service.BaseService;
-import io.milvus.v2.service.collection.CollectionService;
 import io.milvus.v2.service.collection.request.CreateCollectionReq;
-import io.milvus.v2.service.collection.request.DescribeCollectionReq;
 import io.milvus.v2.service.collection.response.DescribeCollectionResp;
 import io.milvus.v2.service.vector.request.*;
 import io.milvus.v2.service.vector.response.*;
 import io.milvus.v2.utils.DataUtils;
-import io.milvus.v2.utils.VectorUtils;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
@@ -42,27 +39,22 @@ import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 public class VectorService extends BaseService {
     Logger logger = LoggerFactory.getLogger(VectorService.class);
-    public CollectionService collectionService = new CollectionService();
     private ConcurrentHashMap<String, DescribeCollectionResponse> cacheCollectionInfo = new ConcurrentHashMap<>();
 
     private DescribeCollectionResponse describeCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub,
-                                                          String databaseName, String collectionName) {
-        String msg = String.format("Fail to describe collection '%s'", collectionName);
+                                                          String dbName, String collectionName) {
+        String title = String.format("Describe collection '%s' in database: '%s'", collectionName, dbName);
         DescribeCollectionRequest.Builder builder = DescribeCollectionRequest.newBuilder()
                 .setCollectionName(collectionName);
-        if (StringUtils.isNotEmpty(databaseName)) {
-            builder.setDbName(databaseName);
-            msg = String.format("Fail to describe collection '%s' in database '%s'",
-                    collectionName, databaseName);
+        if (StringUtils.isNotEmpty(dbName)) {
+            builder.setDbName(dbName);
         }
-        DescribeCollectionRequest describeCollectionRequest = builder.build();
-        DescribeCollectionResponse response = blockingStub.describeCollection(describeCollectionRequest);
-        rpcUtils.handleResponse(msg, response.getStatus());
+        DescribeCollectionResponse response = blockingStub.describeCollection(builder.build());
+        rpcUtils.handleResponse(title, response.getStatus());
         return response;
     }
 
@@ -115,7 +107,7 @@ public class VectorService extends BaseService {
     public InsertResp insert(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, InsertReq request) {
         String dbName = request.getDatabaseName();
         String collectionName = request.getCollectionName();
-        String title = String.format("InsertRequest collectionName:%s", collectionName);
+        String title = String.format("Insert to collection: '%s' in database: '%s'", collectionName, dbName);
 
         DescribeCollectionResponse descResp = getCollectionInfo(blockingStub, dbName, collectionName, false);
 
@@ -172,7 +164,7 @@ public class VectorService extends BaseService {
     public UpsertResp upsert(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, UpsertReq request) {
         String dbName = request.getDatabaseName();
         String collectionName = request.getCollectionName();
-        String title = String.format("UpsertRequest collectionName:%s", collectionName);
+        String title = String.format("Upsert to collection: '%s' in database: '%s'", collectionName, dbName);
 
         DescribeCollectionResponse descResp = getCollectionInfo(blockingStub, dbName, collectionName, false);
 
@@ -223,7 +215,7 @@ public class VectorService extends BaseService {
     public QueryResp query(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, QueryReq request) {
         String dbName = request.getDatabaseName();
         String collectionName = request.getCollectionName();
-        String title = String.format("QueryRequest collectionName:%s, databaseName:%s", collectionName, dbName);
+        String title = String.format("Query collection: '%s' in database: '%s'", collectionName, dbName);
         if (StringUtils.isNotEmpty(request.getFilter()) && CollectionUtils.isNotEmpty(request.getIds())) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "filter and ids can't be set at the same time");
         }
@@ -257,16 +249,17 @@ public class VectorService extends BaseService {
     }
 
     public SearchResp search(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, SearchReq request) {
-        String title = String.format("SearchRequest collectionName:%s, databaseName:%s", request.getCollectionName(), request.getDatabaseName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Search collection: '%s' in database: '%s'", collectionName, dbName);
 
         //checkCollectionExist(blockingStub, request.getCollectionName());
 
         // reset the db name so that the timestamp cache can set correct key for this collection
-        request.setDatabaseName(actualDbName(request.getDatabaseName()));
+        request.setDatabaseName(actualDbName(dbName));
         SearchRequest searchRequest = vectorUtils.ConvertToGrpcSearchRequest(request);
 
         SearchResults response = blockingStub.search(searchRequest);
-
         rpcUtils.handleResponse(title, response.getStatus());
 
         return SearchResp.builder()
@@ -277,16 +270,17 @@ public class VectorService extends BaseService {
     }
 
     public SearchResp hybridSearch(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, HybridSearchReq request) {
-        String title = String.format("HybridSearchRequest collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Hybrid search collection: '%s' in database: '%s'", collectionName, dbName);
 
         //checkCollectionExist(blockingStub, request.getCollectionName());
 
         // reset the db name so that the timestamp cache can set correct key for this collection
-        request.setDatabaseName(actualDbName(request.getDatabaseName()));
+        request.setDatabaseName(actualDbName(dbName));
         HybridSearchRequest searchRequest = vectorUtils.ConvertToGrpcHybridSearchRequest(request);
 
         SearchResults response = blockingStub.hybridSearch(searchRequest);
-
         rpcUtils.handleResponse(title, response.getStatus());
 
         return SearchResp.builder()
@@ -321,7 +315,7 @@ public class VectorService extends BaseService {
     public DeleteResp delete(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DeleteReq request) {
         String dbName = request.getDatabaseName();
         String collectionName = request.getCollectionName();
-        String title = String.format("DeleteRequest collectionName:%s", collectionName);
+        String title = String.format("Delete entities of collection: '%s' in database: '%s'", collectionName, dbName);
 
         if (request.getFilter() != null && request.getIds() != null) {
             throw new MilvusClientException(ErrorCode.INVALID_PARAMS, "filter and ids can't be set at the same time");
@@ -349,10 +343,13 @@ public class VectorService extends BaseService {
     }
 
     public GetResp get(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GetReq request) {
-        String title = String.format("GetRequest collectionName:%s", request.getCollectionName());
+        String dbName = request.getDatabaseName();
+        String collectionName = request.getCollectionName();
+        String title = String.format("Get entities of collection: '%s' in database: '%s'", collectionName, dbName);
         logger.debug(title);
         QueryReq queryReq = QueryReq.builder()
-                .collectionName(request.getCollectionName())
+                .databaseName(dbName)
+                .collectionName(collectionName)
                 .ids(request.getIds())
                 .build();
         if (request.getOutputFields() != null) {

sdk-core/src/main/java/io/milvus/v2/service/vector/request/GetReq.java

@@ -28,6 +28,7 @@ import java.util.List;
 @Data
 @SuperBuilder
 public class GetReq {
+    private String databaseName;
     private String collectionName;
     @Builder.Default
     private String partitionName = "";

sdk-core/src/main/java/io/milvus/v2/utils/RpcUtils.java

@@ -63,7 +63,9 @@ public class RpcUtils {
                     code, status.getErrorCode().getNumber());
         }
 
-        logger.debug("{} successfully!", requestInfo);
+        if (logger.isDebugEnabled()) {
+            logger.debug("{} successfully!", requestInfo);
+        }
     }
 
     public <T> T retry(Callable<T> callable) {

sdk-core/src/test/java/io/milvus/v2/client/MilvusClientV2DockerTest.java

@@ -1872,7 +1872,7 @@ class MilvusClientV2DockerTest {
         Assertions.assertEquals(1, dbNames.size());
         String currentDbName = dbNames.get(0);
 
-        // create a new database
+        // create a temp database
         String tempDatabaseName = "db_temp";
         Map<String, String> properties = new HashMap<>();
         properties.put(Constant.DATABASE_REPLICA_NUMBER, "5");
@@ -1920,10 +1920,10 @@ class MilvusClientV2DockerTest {
         propertiesResp = descDBResp.getProperties();
         Assertions.assertFalse(propertiesResp.containsKey("prop"));
 
-        // switch to the new database
+        // switch to the temp database
         Assertions.assertDoesNotThrow(()->client.useDatabase(tempDatabaseName));
 
-        // create a collection in the new database
+        // create a collection in the temp database
         String randomCollectionName = generator.generate(10);
         String vectorFieldName = "float_vector";
         CreateCollectionReq.CollectionSchema collectionSchema = baseSchema();
@@ -1944,30 +1944,219 @@ class MilvusClientV2DockerTest {
                 .indexParams(Collections.singletonList(indexParam))
                 .build();
         client.createCollection(requestCreate);
-        ListCollectionsResp listCollectionsResp = client.listCollections();
+
+        // switch to the default database
+        Assertions.assertDoesNotThrow(()->client.useDatabase(currentDbName));
+
+        // list collections in the temp database
+        ListCollectionsResp listCollectionsResp = client.listCollectionsV2(ListCollectionsReq.builder()
+                .databaseName(tempDatabaseName)
+                .build());
+
         List<String> collectionNames = listCollectionsResp.getCollectionNames();
         Assertions.assertEquals(1, collectionNames.size());
         Assertions.assertTrue(collectionNames.contains(randomCollectionName));
 
-        // drop the collection so that we can drop the database later
+        // drop the collection so that we can drop the temp database later
         client.dropCollection(DropCollectionReq.builder()
+                .databaseName(tempDatabaseName)
                 .collectionName(randomCollectionName)
                 .build());
 
-        // switch to the old database
-        Assertions.assertDoesNotThrow(()->client.useDatabase(currentDbName));
-
-        // drop the new database
+        // drop the temp database
         client.dropDatabase(DropDatabaseReq.builder()
                 .databaseName(tempDatabaseName)
                 .build());
 
-        // check the new database is deleted
+        // check the temp database is deleted
         listDatabasesResp = client.listDatabases();
         dbNames = listDatabasesResp.getDatabaseNames();
         Assertions.assertFalse(dbNames.contains(tempDatabaseName));
     }
 
+    @Test
+    void testOperationsAcrossDB() {
+        // create a temp database
+        String tempDatabaseName = "db_temp";
+        Map<String, String> properties = new HashMap<>();
+        properties.put(Constant.DATABASE_REPLICA_NUMBER, "5");
+        CreateDatabaseReq createDatabaseReq = CreateDatabaseReq.builder()
+                .databaseName(tempDatabaseName)
+                .properties(properties)
+                .build();
+        client.createDatabase(createDatabaseReq);
+
+        // create a collection in the temp database
+        String randomCollectionName = generator.generate(10);
+        String vectorFieldName = "float_vector";
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
+                .build();
+        collectionSchema.addField(AddFieldReq.builder()
+                .fieldName("id")
+                .dataType(DataType.Int64)
+                .isPrimaryKey(true)
+                .autoID(true)
+                .build());
+        collectionSchema.addField(AddFieldReq.builder()
+                .fieldName(vectorFieldName)
+                .dataType(DataType.FloatVector)
+                .dimension(DIMENSION)
+                .build());
+
+        CreateCollectionReq requestCreate = CreateCollectionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .collectionSchema(collectionSchema)
+                .build();
+        client.createCollection(requestCreate);
+
+        // has collection
+        Assertions.assertTrue(client.hasCollection(HasCollectionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .build()));
+
+        // list collections
+        ListCollectionsResp listResp = client.listCollectionsV2(ListCollectionsReq.builder()
+                .databaseName(tempDatabaseName)
+                .build());
+        Assertions.assertTrue(listResp.getCollectionNames().contains(randomCollectionName));
+
+        // specify the temp database name to create index
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(vectorFieldName)
+                .indexType(IndexParam.IndexType.FLAT)
+                .metricType(IndexParam.MetricType.COSINE)
+                .build();
+        client.createIndex(CreateIndexReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .sync(true)
+                .build());
+
+        // specify the temp database name to list index
+        List<String> indexes = client.listIndexes(ListIndexesReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .fieldName(vectorFieldName)
+                .build());
+        Assertions.assertTrue(indexes.contains(vectorFieldName));
+
+        // specify the temp database name to insert
+        JsonObject row = new JsonObject();
+        row.add(vectorFieldName, JsonUtils.toJsonTree(utils.generateFloatVector(DIMENSION)));
+        client.insert(InsertReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .data(Collections.singletonList(row))
+                .build());
+
+        // specify the temp database name to flush collection
+        client.flush(FlushReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionNames(Collections.singletonList(randomCollectionName))
+                .waitFlushedTimeoutMs(5000L)
+                .build());
+
+        // specify the temp database name to compact collection
+        client.compact(CompactReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .build());
+
+        // specify the temp database name to load collection
+        client.loadCollection(LoadCollectionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .sync(true)
+                .build());
+
+        // specify the temp database name to release collection
+        client.releaseCollection(ReleaseCollectionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .build());
+
+        // specify the temp database name to get load state of collection
+        Assertions.assertFalse(client.getLoadState(GetLoadStateReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .build()));
+
+        // create a partition in the temp database
+        String partitionName = "temp_part";
+        client.createPartition(CreatePartitionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .partitionName(partitionName)
+                .build());
+
+        // has partition
+        Assertions.assertTrue(client.hasPartition(HasPartitionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .partitionName(partitionName)
+                .build()));
+
+        // list partitions
+        List<String> partitions = client.listPartitions(ListPartitionsReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .build());
+        Assertions.assertTrue(partitions.contains(partitionName));
+
+        // specify the temp database name to load partition
+        client.loadPartitions(LoadPartitionsReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .partitionNames(Collections.singletonList(partitionName))
+                .sync(true)
+                .build());
+
+        // specify the temp database name to get load state of partition
+        Assertions.assertTrue(client.getLoadState(GetLoadStateReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .partitionName(partitionName)
+                .build()));
+
+        // specify the temp database name to release partition
+        client.releasePartitions(ReleasePartitionsReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .partitionNames(Collections.singletonList(partitionName))
+                .build());
+
+        // specify the temp database name to drop partition
+        client.dropPartition(DropPartitionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .partitionName(partitionName)
+                .build());
+
+        // specify the temp database name to drop index
+        client.dropIndex(DropIndexReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .fieldName(vectorFieldName)
+                .build());
+
+        // specify the temp database name to rename collection
+        String newCollName = "new_name";
+        client.renameCollection(RenameCollectionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(randomCollectionName)
+                .newCollectionName(newCollName)
+                .build());
+
+        // specify the temp database name to drop collection
+        client.dropCollection(DropCollectionReq.builder()
+                .databaseName(tempDatabaseName)
+                .collectionName(newCollName)
+                .build());
+    }
+
     @Test
     void testClientPool() {
         // create a temp database