diff --git a/pom.xml b/pom.xml
index f6cb92ca9..ff81fb87b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -77,7 +77,7 @@
1.7.30
2.17.1
4.13.2
- 5.7.0
+ 5.10.1
1.18.22
4.10.0
3.0.24
@@ -89,11 +89,12 @@
3.0.0-M2
2.19.1
1.1.0
- 5.1.0
+ 5.10.1
2.12.7.1
2.10.1
1.6.20
1.2.83
+ 5.8.0
@@ -109,6 +110,18 @@
+
+ org.mockito
+ mockito-core
+ ${mockito.version}
+ test
+
+
+ org.mockito
+ mockito-junit-jupiter
+ ${mockito.version}
+ test
+
io.grpc
grpc-netty-shaded
diff --git a/src/main/java/io/milvus/v2/client/ConnectConfig.java b/src/main/java/io/milvus/v2/client/ConnectConfig.java
new file mode 100644
index 000000000..9c8024a79
--- /dev/null
+++ b/src/main/java/io/milvus/v2/client/ConnectConfig.java
@@ -0,0 +1,60 @@
+package io.milvus.v2.client;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.concurrent.TimeUnit;
+
+@Data
+@SuperBuilder
+public class ConnectConfig {
+ private String uri;
+ private String token;
+ private String username;
+ private String password;
+ private String databaseName;
+ @Builder.Default
+ private long connectTimeoutMs = 10000;
+ @Builder.Default
+ private long keepAliveTimeMs = 55000;
+ @Builder.Default
+ private long keepAliveTimeoutMs = 20000;
+ @Builder.Default
+ private boolean keepAliveWithoutCalls = false;
+ @Builder.Default
+ private long rpcDeadlineMs = 0; // Disabling deadline
+
+ private String clientKeyPath;
+ private String clientPemPath;
+ private String caPemPath;
+ private String serverPemPath;
+ private String serverName;
+
+ @Builder.Default
+ private boolean secure = true;
+ @Builder.Default
+ private long idleTimeoutMs = TimeUnit.MILLISECONDS.convert(24, TimeUnit.HOURS);
+
+ public String getHost() {
+ URI uri = URI.create(this.uri);
+ return uri.getHost();
+ }
+
+ public int getPort() {
+ URI uri = URI.create(this.uri);
+ return uri.getPort();
+ }
+
+ public String getAuthorization() {
+ if (token != null) {
+ return token;
+ }else if (username != null && password != null) {
+ return username + ":" + password;
+ }
+ return null;
+ }
+}
diff --git a/src/main/java/io/milvus/v2/client/MilvusClientV2.java b/src/main/java/io/milvus/v2/client/MilvusClientV2.java
new file mode 100644
index 000000000..b167db5b0
--- /dev/null
+++ b/src/main/java/io/milvus/v2/client/MilvusClientV2.java
@@ -0,0 +1,521 @@
+package io.milvus.v2.client;
+
+import io.grpc.ManagedChannel;
+import io.milvus.grpc.MilvusServiceGrpc;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.v2.service.collection.CollectionService;
+import io.milvus.v2.service.collection.request.*;
+import io.milvus.v2.service.collection.response.DescribeCollectionResp;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import io.milvus.v2.service.index.IndexService;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.index.request.DescribeIndexReq;
+import io.milvus.v2.service.index.request.DropIndexReq;
+import io.milvus.v2.service.index.response.DescribeIndexResp;
+import io.milvus.v2.service.partition.PartitionService;
+import io.milvus.v2.service.partition.request.*;
+import io.milvus.v2.service.rbac.RoleService;
+import io.milvus.v2.service.rbac.UserService;
+import io.milvus.v2.service.rbac.request.*;
+import io.milvus.v2.service.rbac.response.DescribeRoleResp;
+import io.milvus.v2.service.rbac.response.DescribeUserResp;
+import io.milvus.v2.service.utility.UtilityService;
+import io.milvus.v2.service.utility.request.AlterAliasReq;
+import io.milvus.v2.service.utility.request.CreateAliasReq;
+import io.milvus.v2.service.utility.request.DropAliasReq;
+import io.milvus.v2.service.utility.request.FlushReq;
+import io.milvus.v2.service.vector.VectorService;
+import io.milvus.v2.service.vector.request.*;
+import io.milvus.v2.service.vector.response.GetResp;
+import io.milvus.v2.service.vector.response.QueryResp;
+import io.milvus.v2.service.vector.response.SearchResp;
+import io.milvus.v2.utils.ClientUtils;
+import lombok.NonNull;
+import lombok.Setter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+public class MilvusClientV2 {
+ private static final Logger logger = LoggerFactory.getLogger(MilvusClientV2.class);
+ private ManagedChannel channel;
+ @Setter
+ private MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub;
+ private final ClientUtils clientUtils = new ClientUtils();
+ private final CollectionService collectionService = new CollectionService();
+ private final IndexService indexService = new IndexService();
+ private final VectorService vectorService = new VectorService();
+ private final PartitionService partitionService = new PartitionService();
+ private final UserService userService = new UserService();
+ private final RoleService roleService = new RoleService();
+ private final UtilityService utilityService = new UtilityService();
+ private ConnectConfig connectConfig;
+
+ /**
+ * Creates a Milvus client instance.
+ * @param connectConfig Milvus server connection configuration
+ */
+ public MilvusClientV2(ConnectConfig connectConfig) {
+ if (connectConfig != null) {
+ connect(connectConfig);
+ }
+ }
+ /**
+ * connect to Milvus server
+ *
+ * @param connectConfig Milvus server connection configuration
+ */
+ private void connect(ConnectConfig connectConfig){
+ this.connectConfig = connectConfig;
+ try {
+ if(this.channel != null) {
+ // close channel first
+ close(3);
+ }
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ channel = clientUtils.getChannel(connectConfig);
+
+ if (connectConfig.getRpcDeadlineMs() > 0) {
+ blockingStub = MilvusServiceGrpc.newBlockingStub(channel).withWaitForReady()
+ .withDeadlineAfter(connectConfig.getRpcDeadlineMs(), TimeUnit.MILLISECONDS);
+ }else {
+ blockingStub = MilvusServiceGrpc.newBlockingStub(channel);
+ }
+
+ if (connectConfig.getDatabaseName() != null) {
+ // check if database exists
+ clientUtils.checkDatabaseExist(this.blockingStub, connectConfig.getDatabaseName());
+ }
+ }
+
+ /**
+ * use Database
+ * @param dbName databaseName
+ */
+ public void useDatabase(@NonNull String dbName) {
+ // check if database exists
+ clientUtils.checkDatabaseExist(this.blockingStub, dbName);
+ try {
+ this.connectConfig.setDatabaseName(dbName);
+ this.close(3);
+ this.connect(this.connectConfig);
+ }catch (InterruptedException e){
+ logger.error("close connect error");
+ }
+ }
+
+ //Collection Operations
+ /**
+ * Fast Creates a collection in Milvus.
+ *
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R createCollection(CreateCollectionReq request) {
+ return collectionService.createCollection(this.blockingStub, request);
+ }
+
+ /**
+ * Creates a collection with Schema in Milvus.
+ *
+ * @param request create collection request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R createCollectionWithSchema(CreateCollectionWithSchemaReq request) {
+ return collectionService.createCollectionWithSchema(this.blockingStub, request);
+ }
+
+ /**
+ * list milvus collections
+ *
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R listCollections(){
+ return collectionService.listCollections(this.blockingStub);
+ }
+
+ /**
+ * Drops a collection in Milvus.
+ *
+ * @param request drop collection request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R dropCollection(DropCollectionReq request){
+ return collectionService.dropCollection(this.blockingStub, request);
+ }
+ /**
+ * Checks whether a collection exists in Milvus.
+ *
+ * @param request has collection request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R hasCollection(HasCollectionReq request){
+ return collectionService.hasCollection(this.blockingStub, request);
+ }
+ /**
+ * Gets the collection info in Milvus.
+ *
+ * @param request describe collection request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R describeCollection(DescribeCollectionReq request){
+ return collectionService.describeCollection(this.blockingStub, request);
+ }
+ /**
+ * get collection stats for a collection in Milvus.
+ *
+ * @param request get collection stats request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+// public R getCollectionStats(GetCollectionStatsReq request){
+// return collectionService.getCollectionStats(this.blockingStub, request);
+// }
+ /**
+ * rename collection in a collection in Milvus.
+ *
+ * @param request rename collection request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R renameCollection(RenameCollectionReq request){
+ return collectionService.renameCollection(this.blockingStub, request);
+ }
+ /**
+ * Loads a collection into memory in Milvus.
+ *
+ * @param request load collection request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R loadCollection(LoadCollectionReq request){
+ return collectionService.loadCollection(this.blockingStub, request);
+ }
+ /**
+ * Releases a collection from memory in Milvus.
+ *
+ * @param request release collection request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R releaseCollection(ReleaseCollectionReq request){
+ return collectionService.releaseCollection(this.blockingStub, request);
+ }
+ /**
+ * Checks whether a collection is loaded in Milvus.
+ *
+ * @param request get load state request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R getLoadState(GetLoadStateReq request){
+ return collectionService.getLoadState(this.blockingStub, request);
+ }
+
+ //Index Operations
+ /**
+ * Creates an index for a specified field in a collection in Milvus.
+ *
+ * @param request create index request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R createIndex(CreateIndexReq request){
+ return indexService.createIndex(this.blockingStub, request);
+ }
+ /**
+ * Drops an index for a specified field in a collection in Milvus.
+ *
+ * @param request drop index request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R dropIndex(DropIndexReq request){
+ return indexService.dropIndex(this.blockingStub, request);
+ }
+ /**
+ * Checks whether an index exists for a specified field in a collection in Milvus.
+ *
+ * @param request describe index request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R describeIndex(DescribeIndexReq request){
+ return indexService.describeIndex(this.blockingStub, request);
+ }
+
+ // Vector Operations
+
+ /**
+ * Inserts vectors into a collection in Milvus.
+ *
+ * @param request insert request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R insert(InsertReq request){
+ return vectorService.insert(this.blockingStub, request);
+ }
+ /**
+ * Upsert vectors into a collection in Milvus.
+ *
+ * @param request upsert request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R upsert(UpsertReq request){
+ return vectorService.upsert(this.blockingStub, request);
+ }
+ /**
+ * Deletes vectors in a collection in Milvus.
+ *
+ * @param request delete request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R delete(DeleteReq request){
+ return vectorService.delete(this.blockingStub, request);
+ }
+ /**
+ * Gets vectors in a collection in Milvus.
+ *
+ * @param request get request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R get(GetReq request){
+ return vectorService.get(this.blockingStub, request);
+ }
+
+ /**
+ * Queries vectors in a collection in Milvus.
+ *
+ * @param request query request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R query(QueryReq request){
+ return vectorService.query(this.blockingStub, request);
+ }
+ /**
+ * Searches vectors in a collection in Milvus.
+ *
+ * @param request search request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R search(SearchReq request){
+ return vectorService.search(this.blockingStub, request);
+ }
+
+ // Partition Operations
+ /**
+ * Creates a partition in a collection in Milvus.
+ *
+ * @param request create partition request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R createPartition(CreatePartitionReq request) {
+ return partitionService.createPartition(this.blockingStub, request);
+ }
+
+ /**
+ * Drops a partition in a collection in Milvus.
+ *
+ * @param request drop partition request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R dropPartition(DropPartitionReq request) {
+ return partitionService.dropPartition(this.blockingStub, request);
+ }
+
+ /**
+ * Checks whether a partition exists in a collection in Milvus.
+ *
+ * @param request has partition request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R hasPartition(HasPartitionReq request) {
+ return partitionService.hasPartition(this.blockingStub, request);
+ }
+
+ /**
+ * Lists all partitions in a collection in Milvus.
+ *
+ * @param request list partitions request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R> listPartitions(ListPartitionsReq request) {
+ return partitionService.listPartitions(this.blockingStub, request);
+ }
+
+ /**
+ * Loads partitions in a collection in Milvus.
+ *
+ * @param request load partitions request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R loadPartitions(LoadPartitionsReq request) {
+ return partitionService.loadPartitions(this.blockingStub, request);
+ }
+ /**
+ * Releases partitions in a collection in Milvus.
+ *
+ * @param request release partitions request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R releasePartitions(ReleasePartitionsReq request) {
+ return partitionService.releasePartitions(this.blockingStub, request);
+ }
+ // rbac operations
+ // user operations
+ /**
+ * list users
+ *
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R> listUsers(){
+ return userService.listUsers(this.blockingStub);
+ }
+ /**
+ * describe user
+ *
+ * @param request describe user request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R describeUser(DescribeUserReq request){
+ return userService.describeUser(this.blockingStub, request);
+ }
+ /**
+ * create user
+ *
+ * @param request create user request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R createUser(CreateUserReq request){
+ return userService.createUser(this.blockingStub, request);
+ }
+ /**
+ * change password
+ *
+ * @param request change password request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R updatePassword(UpdatePasswordReq request) {
+ return userService.updatePassword(this.blockingStub, request);
+ }
+ /**
+ * drop user
+ *
+ * @param request drop user request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R dropUser(DropUserReq request){
+ return userService.dropUser(this.blockingStub, request);
+ }
+ // role operations
+ /**
+ * list roles
+ *
+ * @return {status:result code, data:List{msg: result message}}
+ */
+ public R> listRoles() {
+ return roleService.listRoles(this.blockingStub);
+ }
+ /**
+ * describe role
+ *
+ * @param request describe role request
+ * @return {status:result code, data:DescribeRoleResp{msg: result message}}
+ */
+ public R describeRole(DescribeRoleReq request) {
+ return roleService.describeRole(this.blockingStub, request);
+ }
+ /**
+ * create role
+ *
+ * @param request create role request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R createRole(CreateRoleReq request) {
+ return roleService.createRole(this.blockingStub, request);
+ }
+ /**
+ * drop role
+ *
+ * @param request drop role request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R dropRole(DropRoleReq request) {
+ return roleService.dropRole(this.blockingStub, request);
+ }
+ /**
+ * grant privilege
+ *
+ * @param request grant privilege request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R grantPrivilege(GrantPrivilegeReq request) {
+ return roleService.grantPrivilege(this.blockingStub, request);
+ }
+ /**
+ * revoke privilege
+ *
+ * @param request revoke privilege request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R revokePrivilege(RevokePrivilegeReq request) {
+ return roleService.revokePrivilege(this.blockingStub, request);
+ }
+ /**
+ * grant role
+ *
+ * @param request grant role request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R grantRole(GrantRoleReq request) {
+ return roleService.grantRole(this.blockingStub, request);
+ }
+ /**
+ * revoke role
+ *
+ * @param request revoke role request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R revokeRole(RevokeRoleReq request) {
+ return roleService.revokeRole(this.blockingStub, request);
+ }
+
+ // Utility Operations
+
+ /**
+ * create aliases
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R createAlias(CreateAliasReq request) {
+ return utilityService.createAlias(this.blockingStub, request);
+ }
+ /**
+ * drop aliases
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R dropAlias(DropAliasReq request) {
+ return utilityService.dropAlias(this.blockingStub, request);
+ }
+ /**
+ * alter aliases
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R alterAlias(AlterAliasReq request) {
+ return utilityService.alterAlias(this.blockingStub, request);
+ }
+ /**
+ * flush collection
+ * @param request flush request
+ * @return {status:result code, data:RpcStatus{msg: result message}}
+ */
+ public R flush(FlushReq request) {
+ return utilityService.flush(this.blockingStub, request);
+ }
+ /**
+ * close client
+ *
+ * @param maxWaitSeconds max wait seconds
+ */
+ public void close(long maxWaitSeconds) throws InterruptedException {
+ if(channel!= null){
+ channel.shutdownNow();
+ channel.awaitTermination(maxWaitSeconds, TimeUnit.SECONDS);
+ }
+ }
+}
diff --git a/src/main/java/io/milvus/v2/common/ConsistencyLevel.java b/src/main/java/io/milvus/v2/common/ConsistencyLevel.java
new file mode 100644
index 000000000..c37b2a953
--- /dev/null
+++ b/src/main/java/io/milvus/v2/common/ConsistencyLevel.java
@@ -0,0 +1,17 @@
+package io.milvus.v2.common;
+
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import lombok.Getter;
+@Getter
+public enum ConsistencyLevel{
+ STRONG("Strong", 0),
+ BOUNDED("Bounded", 2),
+ EVENTUALLY("Eventually",3),
+ ;
+ private final String name;
+ private final int code;
+ ConsistencyLevel(String name, int code) {
+ this.name = name;
+ this.code = code;
+ }
+}
diff --git a/src/main/java/io/milvus/v2/common/DataType.java b/src/main/java/io/milvus/v2/common/DataType.java
new file mode 100644
index 000000000..8c3d538ce
--- /dev/null
+++ b/src/main/java/io/milvus/v2/common/DataType.java
@@ -0,0 +1,32 @@
+package io.milvus.v2.common;
+
+import lombok.Getter;
+
+@Getter
+public enum DataType {
+ None(0),
+ Bool(1),
+ Int8(2),
+ Int16(3),
+ Int32(4),
+ Int64(5),
+
+ Float(10),
+ Double(11),
+
+ String(20),
+ VarChar(21), // variable-length strings with a specified maximum length
+ Array(22),
+ JSON(23),
+
+ BinaryVector(100),
+ FloatVector(101),
+ Float16Vector(102),
+ BFloat16Vector(103);
+
+ private final int code;
+ DataType(int code) {
+ this.code = code;
+ }
+ ;
+}
diff --git a/src/main/java/io/milvus/v2/common/IndexParam.java b/src/main/java/io/milvus/v2/common/IndexParam.java
new file mode 100644
index 000000000..c7770d37a
--- /dev/null
+++ b/src/main/java/io/milvus/v2/common/IndexParam.java
@@ -0,0 +1,84 @@
+package io.milvus.v2.common;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class IndexParam {
+ @NonNull
+ private String fieldName;
+ private String indexName;
+ @Builder.Default
+ private IndexType indexType = IndexType.AUTOINDEX;
+ private MetricType metricType;
+
+ public String getIndexName() {
+ if(indexName == null) {
+ return fieldName;
+ }
+ return indexName;
+ }
+
+ public enum MetricType {
+ INVALID,
+ // Only for float vectors
+ L2,
+ IP,
+ COSINE,
+
+ // Only for binary vectors
+ HAMMING,
+ JACCARD,
+ ;
+ }
+
+ @Getter
+ public enum IndexType {
+ INVALID,
+ //Only supported for float vectors
+ FLAT(1),
+ IVF_FLAT(2),
+ IVF_SQ8(3),
+ IVF_PQ(4),
+ HNSW(5),
+ DISKANN(10),
+ AUTOINDEX(11),
+ SCANN(12),
+
+ // GPU index
+ GPU_IVF_FLAT(50),
+ GPU_IVF_PQ(51),
+
+ //Only supported for binary vectors
+ BIN_FLAT(80),
+ BIN_IVF_FLAT(81),
+
+ //Scalar field index start from here
+ //Only for varchar type field
+ TRIE("Trie", 100),
+ //Only for scalar type field
+ STL_SORT(200),
+ ;
+ private final String name;
+ private final int code;
+
+ IndexType(){
+ this.name = this.toString();
+ this.code = this.ordinal();
+ }
+
+ IndexType(int code){
+ this.name = this.toString();
+ this.code = code;
+ }
+
+ IndexType(String name, int code){
+ this.name = name;
+ this.code = code;
+ }
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/BaseService.java b/src/main/java/io/milvus/v2/service/BaseService.java
new file mode 100644
index 000000000..6560fab97
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/BaseService.java
@@ -0,0 +1,27 @@
+package io.milvus.v2.service;
+
+import io.milvus.exception.MilvusException;
+import io.milvus.grpc.BoolResponse;
+import io.milvus.grpc.HasCollectionRequest;
+import io.milvus.grpc.MilvusServiceGrpc;
+import io.milvus.param.R;
+import io.milvus.v2.utils.ConvertUtils;
+import io.milvus.v2.utils.DataUtils;
+import io.milvus.v2.utils.VectorUtils;
+import io.milvus.v2.utils.RpcUtils;
+
+public class BaseService {
+ public RpcUtils rpcUtils = new RpcUtils();
+ public DataUtils dataUtils = new DataUtils();
+ public VectorUtils vectorUtils = new VectorUtils();
+ public ConvertUtils convertUtils = new ConvertUtils();
+
+ protected void checkCollectionExist(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, String collectionName) {
+ HasCollectionRequest request = HasCollectionRequest.newBuilder().setCollectionName(collectionName).build();
+ BoolResponse result = blockingStub.hasCollection(request);
+ rpcUtils.handleResponse("", result.getStatus());
+ if (!result.getValue() == Boolean.TRUE) {
+ throw new MilvusException("Collection " + collectionName + " not exist", R.Status.CollectionNotExists.getCode());
+ }
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/CollectionService.java b/src/main/java/io/milvus/v2/service/collection/CollectionService.java
new file mode 100644
index 000000000..906e638ff
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/CollectionService.java
@@ -0,0 +1,218 @@
+package io.milvus.v2.service.collection;
+
+import io.milvus.grpc.*;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.v2.service.BaseService;
+import io.milvus.v2.service.collection.request.*;
+import io.milvus.v2.service.collection.response.DescribeCollectionResp;
+import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.index.IndexService;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.utils.SchemaUtils;
+
+public class CollectionService extends BaseService {
+ public IndexService indexService = new IndexService();
+
+ public R createCollection(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateCollectionReq request) {
+ String title = String.format("CreateCollectionRequest collectionName:%s", request.getCollectionName());
+ FieldSchema vectorSchema = FieldSchema.newBuilder()
+ .setName(request.getVectorFieldName())
+ .setDataType(DataType.FloatVector)
+ .setIsPrimaryKey(Boolean.FALSE)
+ .addTypeParams(KeyValuePair.newBuilder().setKey("dim").setValue(String.valueOf(request.getDimension())).build())
+ .build();
+
+ FieldSchema idSchema = FieldSchema.newBuilder()
+ .setName("id")
+ .setDataType(DataType.valueOf(request.getPrimaryFieldType()))
+ .setIsPrimaryKey(Boolean.TRUE)
+ .setAutoID(request.getAutoID())
+ .build();
+ if(request.getPrimaryFieldType().equals("VarChar") && request.getMaxLength() != null){
+ idSchema = idSchema.toBuilder().addTypeParams(KeyValuePair.newBuilder().setKey("max_length").setValue(String.valueOf(request.getMaxLength())).build()).build();
+ }
+
+ CollectionSchema schema = CollectionSchema.newBuilder()
+ .setName(request.getCollectionName())
+ .addFields(vectorSchema)
+ .addFields(idSchema)
+ .setEnableDynamicField(Boolean.TRUE)
+ .build();
+
+
+ CreateCollectionRequest createCollectionRequest = CreateCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .setSchema(schema.toByteString())
+ .build();
+
+ Status status = blockingStub.createCollection(createCollectionRequest);
+ rpcUtils.handleResponse(title, status);
+
+ //create index
+ IndexParam indexParam = IndexParam.builder()
+ .metricType(IndexParam.MetricType.valueOf(request.getMetricType()))
+ .fieldName("vector")
+ .build();
+ CreateIndexReq createIndexReq = CreateIndexReq.builder()
+ .indexParam(indexParam)
+ .collectionName(request.getCollectionName())
+ .build();
+ indexService.createIndex(blockingStub, createIndexReq);
+ //load collection
+ loadCollection(blockingStub, LoadCollectionReq.builder().collectionName(request.getCollectionName()).build());
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R createCollectionWithSchema(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateCollectionWithSchemaReq request) {
+ String title = String.format("CreateCollectionRequest collectionName:%s", request.getCollectionName());
+
+ //convert CollectionSchema to io.milvus.grpc.CollectionSchema
+ CollectionSchema grpcSchema = CollectionSchema.newBuilder()
+ .setName(request.getCollectionName())
+ .setDescription(request.getCollectionSchema().getDescription())
+ .setEnableDynamicField(request.getCollectionSchema().getEnableDynamicField())
+ .build();
+ for (CreateCollectionWithSchemaReq.FieldSchema fieldSchema : request.getCollectionSchema().getFieldSchemaList()) {
+ grpcSchema = grpcSchema.toBuilder().addFields(SchemaUtils.convertToGrpcFieldSchema(fieldSchema)).build();
+ }
+
+ //create collection
+ CreateCollectionRequest createCollectionRequest = CreateCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .setSchema(grpcSchema.toByteString())
+ .build();
+
+ Status createCollectionResponse = blockingStub.createCollection(createCollectionRequest);
+ rpcUtils.handleResponse(title, createCollectionResponse);
+
+ //create index
+ if(request.getIndexParams() != null && !request.getIndexParams().isEmpty()) {
+ for(IndexParam indexParam : request.getIndexParams()) {
+ CreateIndexReq createIndexReq = CreateIndexReq.builder()
+ .indexParam(indexParam)
+ .collectionName(request.getCollectionName())
+ .build();
+ indexService.createIndex(blockingStub, createIndexReq);
+ }
+ }
+
+ //load collection
+ loadCollection(blockingStub, LoadCollectionReq.builder().collectionName(request.getCollectionName()).build());
+
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R listCollections(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub) {
+ ShowCollectionsRequest showCollectionsRequest = ShowCollectionsRequest.newBuilder()
+ .build();
+ ShowCollectionsResponse response = milvusServiceBlockingStub.showCollections(showCollectionsRequest);
+ ListCollectionsResp a = ListCollectionsResp.builder()
+ .collectionNames(response.getCollectionNamesList())
+ .build();
+
+ return R.success(a);
+ }
+
+ public R dropCollection(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, DropCollectionReq request) {
+
+ String title = String.format("DropCollectionRequest collectionName:%s", request.getCollectionName());
+ DropCollectionRequest dropCollectionRequest = DropCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .build();
+ Status status = milvusServiceBlockingStub.dropCollection(dropCollectionRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R hasCollection(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, HasCollectionReq request) {
+ HasCollectionRequest hasCollectionRequest = HasCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .build();
+ BoolResponse response = milvusServiceBlockingStub.hasCollection(hasCollectionRequest);
+ return R.success(response.getValue());
+ }
+
+ public R describeCollection(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, DescribeCollectionReq request) {
+ //check collection exists
+ checkCollectionExist(milvusServiceBlockingStub, request.getCollectionName());
+
+ DescribeCollectionRequest describeCollectionRequest = DescribeCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .build();
+ DescribeCollectionResponse response = milvusServiceBlockingStub.describeCollection(describeCollectionRequest);
+
+ DescribeCollectionResp describeCollectionResp = DescribeCollectionResp.builder()
+ .collectionName(response.getCollectionName())
+ .description(response.getSchema().getDescription())
+ .numOfPartitions(response.getNumPartitions())
+ .collectionSchema(SchemaUtils.convertFromGrpcCollectionSchema(response.getSchema()))
+ .autoID(response.getSchema().getFieldsList().stream().anyMatch(FieldSchema::getAutoID))
+ .enableDynamicField(response.getSchema().getEnableDynamicField())
+ .fieldNames(response.getSchema().getFieldsList().stream().map(FieldSchema::getName).collect(java.util.stream.Collectors.toList()))
+ .vectorFieldName(response.getSchema().getFieldsList().stream().filter(fieldSchema -> fieldSchema.getDataType() == DataType.FloatVector || fieldSchema.getDataType() == DataType.BinaryVector).map(FieldSchema::getName).collect(java.util.stream.Collectors.toList()))
+ .primaryFieldName(response.getSchema().getFieldsList().stream().filter(FieldSchema::getIsPrimaryKey).map(FieldSchema::getName).collect(java.util.stream.Collectors.toList()).get(0))
+ .createTime(response.getCreatedTimestamp())
+ .build();
+
+ return R.success(describeCollectionResp);
+ }
+
+ public R renameCollection(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, RenameCollectionReq request) {
+ String title = String.format("RenameCollectionRequest collectionName:%s", request.getCollectionName());
+ RenameCollectionRequest renameCollectionRequest = RenameCollectionRequest.newBuilder()
+ .setOldName(request.getCollectionName())
+ .setNewName(request.getNewCollectionName())
+ .build();
+ Status status = milvusServiceBlockingStub.renameCollection(renameCollectionRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R loadCollection(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, LoadCollectionReq request) {
+ String title = String.format("LoadCollectionRequest collectionName:%s", request.getCollectionName());
+ LoadCollectionRequest loadCollectionRequest = LoadCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .build();
+ Status status = milvusServiceBlockingStub.loadCollection(loadCollectionRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R releaseCollection(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, ReleaseCollectionReq request) {
+ String title = String.format("ReleaseCollectionRequest collectionName:%s", request.getCollectionName());
+ ReleaseCollectionRequest releaseCollectionRequest = ReleaseCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .build();
+ Status status = milvusServiceBlockingStub.releaseCollection(releaseCollectionRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R getLoadState(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, GetLoadStateReq request) {
+ // getLoadState
+ String title = String.format("GetLoadStateRequest collectionName:%s", request.getCollectionName());
+ GetLoadStateRequest getLoadStateRequest = GetLoadStateRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .build();
+ GetLoadStateResponse response = milvusServiceBlockingStub.getLoadState(getLoadStateRequest);
+ rpcUtils.handleResponse(title, response.getStatus());
+ return R.success(response.getState() == LoadState.LoadStateLoaded);
+ }
+
+ public R 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);
+
+ rpcUtils.handleResponse(title, response.getStatus());
+ GetCollectionStatsResp getCollectionStatsResp = GetCollectionStatsResp.builder()
+ .numOfEntities(response.getStatsList().stream().filter(stat -> stat.getKey().equals("row_count")).map(stat -> Long.parseLong(stat.getValue())).findFirst().get())
+ .build();
+ return R.success(getCollectionStatsResp);
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/CreateCollectionReq.java b/src/main/java/io/milvus/v2/service/collection/request/CreateCollectionReq.java
new file mode 100644
index 000000000..ebbf5b2f9
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/CreateCollectionReq.java
@@ -0,0 +1,27 @@
+package io.milvus.v2.service.collection.request;
+
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.common.IndexParam;
+import lombok.Builder;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class CreateCollectionReq {
+ private String collectionName;
+ private Integer dimension;
+
+ @Builder.Default
+ private String primaryFieldName = "id";
+ @Builder.Default
+ private String primaryFieldType = DataType.VarChar.name();
+ @Builder.Default
+ private Integer maxLength = 65535;
+ @Builder.Default
+ private String vectorFieldName = "vector";
+ @Builder.Default
+ private String metricType = IndexParam.MetricType.IP.name();
+ @Builder.Default
+ private Boolean autoID = Boolean.TRUE;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/CreateCollectionWithSchemaReq.java b/src/main/java/io/milvus/v2/service/collection/request/CreateCollectionWithSchemaReq.java
new file mode 100644
index 000000000..1aeb90ef9
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/CreateCollectionWithSchemaReq.java
@@ -0,0 +1,52 @@
+package io.milvus.v2.service.collection.request;
+
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.common.IndexParam;
+import lombok.Builder;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@SuperBuilder
+@Data
+public class CreateCollectionWithSchemaReq {
+ private String collectionName;
+ private CollectionSchema collectionSchema;
+ private List indexParams;
+
+ @Data
+ @SuperBuilder
+ public static class CollectionSchema {
+ private List fieldSchemaList;
+ @Builder.Default
+ private String description = "";
+ private Boolean enableDynamicField;
+
+ public FieldSchema getField(String fieldName) {
+ for (FieldSchema field : fieldSchemaList) {
+ if (field.getName().equals(fieldName)) {
+ return field;
+ }
+ }
+ return null;
+ }
+ }
+
+ @Data
+ @SuperBuilder
+ public static class FieldSchema {
+ //TODO: check here
+ private String name;
+ private DataType dataType;
+ @Builder.Default
+ private Integer maxLength = 65535;
+ private Integer dimension;
+ @Builder.Default
+ private Boolean isPrimaryKey = Boolean.FALSE;
+ @Builder.Default
+ private Boolean autoID = Boolean.FALSE;
+ }
+
+
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/DescribeCollectionReq.java b/src/main/java/io/milvus/v2/service/collection/request/DescribeCollectionReq.java
new file mode 100644
index 000000000..e27780c36
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/DescribeCollectionReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DescribeCollectionReq {
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/DropCollectionReq.java b/src/main/java/io/milvus/v2/service/collection/request/DropCollectionReq.java
new file mode 100644
index 000000000..05134415b
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/DropCollectionReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DropCollectionReq {
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/GetCollectionStatsReq.java b/src/main/java/io/milvus/v2/service/collection/request/GetCollectionStatsReq.java
new file mode 100644
index 000000000..17d6309f1
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/GetCollectionStatsReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class GetCollectionStatsReq {
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/GetLoadStateReq.java b/src/main/java/io/milvus/v2/service/collection/request/GetLoadStateReq.java
new file mode 100644
index 000000000..e102645d1
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/GetLoadStateReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class GetLoadStateReq {
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/HasCollectionReq.java b/src/main/java/io/milvus/v2/service/collection/request/HasCollectionReq.java
new file mode 100644
index 000000000..c0deabf38
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/HasCollectionReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class HasCollectionReq {
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/LoadCollectionReq.java b/src/main/java/io/milvus/v2/service/collection/request/LoadCollectionReq.java
new file mode 100644
index 000000000..8c022bf37
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/LoadCollectionReq.java
@@ -0,0 +1,13 @@
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class LoadCollectionReq {
+ private String collectionName;
+ private List partitionNames;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/ReleaseCollectionReq.java b/src/main/java/io/milvus/v2/service/collection/request/ReleaseCollectionReq.java
new file mode 100644
index 000000000..d91888384
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/ReleaseCollectionReq.java
@@ -0,0 +1,13 @@
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class ReleaseCollectionReq {
+ private String collectionName;
+ private List partitionNames;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/request/RenameCollectionReq.java b/src/main/java/io/milvus/v2/service/collection/request/RenameCollectionReq.java
new file mode 100644
index 000000000..3c27cc57f
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/request/RenameCollectionReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.collection.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class RenameCollectionReq {
+ private String collectionName;
+ private String newCollectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/response/DescribeCollectionResp.java b/src/main/java/io/milvus/v2/service/collection/response/DescribeCollectionResp.java
new file mode 100644
index 000000000..3792335c0
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/response/DescribeCollectionResp.java
@@ -0,0 +1,24 @@
+package io.milvus.v2.service.collection.response;
+
+import io.milvus.v2.service.collection.request.CreateCollectionWithSchemaReq;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class DescribeCollectionResp {
+ private String collectionName;
+ private String description;
+ private Long numOfPartitions;
+
+ private List fieldNames;
+ private List vectorFieldName;
+ private String primaryFieldName;
+ private Boolean enableDynamicField;
+ private Boolean autoID;
+
+ private CreateCollectionWithSchemaReq.CollectionSchema collectionSchema;
+ private Long createTime;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/response/GetCollectionStatsResp.java b/src/main/java/io/milvus/v2/service/collection/response/GetCollectionStatsResp.java
new file mode 100644
index 000000000..f440e8e7f
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/response/GetCollectionStatsResp.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.collection.response;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class GetCollectionStatsResp {
+ private Long numOfEntities;
+}
diff --git a/src/main/java/io/milvus/v2/service/collection/response/ListCollectionsResp.java b/src/main/java/io/milvus/v2/service/collection/response/ListCollectionsResp.java
new file mode 100644
index 000000000..ee28fdc46
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/collection/response/ListCollectionsResp.java
@@ -0,0 +1,12 @@
+package io.milvus.v2.service.collection.response;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class ListCollectionsResp {
+ private List collectionNames;
+}
diff --git a/src/main/java/io/milvus/v2/service/index/IndexService.java b/src/main/java/io/milvus/v2/service/index/IndexService.java
new file mode 100644
index 000000000..9291ffe87
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/index/IndexService.java
@@ -0,0 +1,64 @@
+package io.milvus.v2.service.index;
+
+import io.milvus.grpc.*;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.BaseService;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.index.request.DescribeIndexReq;
+import io.milvus.v2.service.index.request.DropIndexReq;
+import io.milvus.v2.service.index.response.DescribeIndexResp;
+
+public class IndexService extends BaseService {
+ public R createIndex(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, CreateIndexReq request) {
+ String title = String.format("CreateIndexRequest collectionName:%s, fieldName:%s",
+ request.getCollectionName(), request.getIndexParam().getFieldName());
+ CreateIndexRequest createIndexRequest = CreateIndexRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .setIndexName(request.getIndexParam().getIndexName())
+ .setFieldName(request.getIndexParam().getFieldName())
+ .addExtraParams(KeyValuePair.newBuilder()
+ .setKey("index_type")
+ .setValue(String.valueOf(request.getIndexParam().getIndexType()))
+ .build())
+ .addExtraParams(KeyValuePair.newBuilder()
+ .setKey("metric_type")
+ .setValue(String.valueOf(request.getIndexParam().getMetricType()))
+ .build())
+ .build();
+
+ Status status = milvusServiceBlockingStub.createIndex(createIndexRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R dropIndex(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, 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())
+ .setIndexName(request.getIndexName())
+ .build();
+
+ Status status = milvusServiceBlockingStub.dropIndex(dropIndexRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R describeIndex(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, DescribeIndexReq request) {
+ String title = String.format("DescribeIndexRequest collectionName:%s, fieldName:%s, indexName:%s",
+ request.getCollectionName(), request.getFieldName(), request.getIndexName());
+ DescribeIndexRequest describeIndexRequest = DescribeIndexRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .setFieldName(request.getFieldName())
+ .setIndexName(request.getIndexName())
+ .build();
+
+ DescribeIndexResponse response = milvusServiceBlockingStub.describeIndex(describeIndexRequest);
+ rpcUtils.handleResponse(title, response.getStatus());
+
+ return convertUtils.convertToDescribeIndexResp(response);
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/index/request/CreateIndexReq.java b/src/main/java/io/milvus/v2/service/index/request/CreateIndexReq.java
new file mode 100644
index 000000000..422c54123
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/index/request/CreateIndexReq.java
@@ -0,0 +1,12 @@
+package io.milvus.v2.service.index.request;
+
+import io.milvus.v2.common.IndexParam;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class CreateIndexReq {
+ private String collectionName;
+ private IndexParam indexParam;
+}
diff --git a/src/main/java/io/milvus/v2/service/index/request/DescribeIndexReq.java b/src/main/java/io/milvus/v2/service/index/request/DescribeIndexReq.java
new file mode 100644
index 000000000..1c89eca70
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/index/request/DescribeIndexReq.java
@@ -0,0 +1,14 @@
+package io.milvus.v2.service.index.request;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DescribeIndexReq {
+ private String collectionName;
+ private String fieldName;
+ @Builder.Default
+ private String indexName = "";
+}
diff --git a/src/main/java/io/milvus/v2/service/index/request/DropIndexReq.java b/src/main/java/io/milvus/v2/service/index/request/DropIndexReq.java
new file mode 100644
index 000000000..75fdea3ea
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/index/request/DropIndexReq.java
@@ -0,0 +1,14 @@
+package io.milvus.v2.service.index.request;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DropIndexReq {
+ private String collectionName;
+ private String fieldName;
+ @Builder.Default
+ private String indexName = "";
+}
diff --git a/src/main/java/io/milvus/v2/service/index/response/DescribeIndexResp.java b/src/main/java/io/milvus/v2/service/index/response/DescribeIndexResp.java
new file mode 100644
index 000000000..16d3aa22b
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/index/response/DescribeIndexResp.java
@@ -0,0 +1,13 @@
+package io.milvus.v2.service.index.response;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DescribeIndexResp {
+ private String indexName;
+ private String indexType;
+ private String metricType;
+ private String fieldName;
+}
diff --git a/src/main/java/io/milvus/v2/service/partition/PartitionService.java b/src/main/java/io/milvus/v2/service/partition/PartitionService.java
new file mode 100644
index 000000000..e0a3df78c
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/partition/PartitionService.java
@@ -0,0 +1,88 @@
+package io.milvus.v2.service.partition;
+
+import io.milvus.grpc.CreatePartitionRequest;
+import io.milvus.grpc.MilvusServiceGrpc;
+import io.milvus.grpc.Status;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.v2.service.partition.request.*;
+import io.milvus.v2.service.BaseService;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.collection.request.ReleaseCollectionReq;
+
+import java.util.List;
+
+public class PartitionService extends BaseService {
+ public R 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);
+ rpcUtils.handleResponse(title, status);
+
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R 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);
+ rpcUtils.handleResponse(title, status);
+
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R 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);
+ rpcUtils.handleResponse(title, boolResponse.getStatus());
+
+ return R.success(boolResponse.getValue());
+ }
+
+ public R> 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);
+ rpcUtils.handleResponse(title, showPartitionsResponse.getStatus());
+
+ return R.success(showPartitionsResponse.getPartitionNamesList());
+ }
+
+ public R 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()).build();
+ Status status = blockingStub.loadPartitions(loadPartitionsRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R 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);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/partition/request/CreatePartitionReq.java b/src/main/java/io/milvus/v2/service/partition/request/CreatePartitionReq.java
new file mode 100644
index 000000000..65fb764aa
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/partition/request/CreatePartitionReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.partition.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class CreatePartitionReq {
+ private String collectionName;
+ private String partitionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/partition/request/DropPartitionReq.java b/src/main/java/io/milvus/v2/service/partition/request/DropPartitionReq.java
new file mode 100644
index 000000000..600f611ec
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/partition/request/DropPartitionReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.partition.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DropPartitionReq {
+ private String collectionName;
+ private String partitionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/partition/request/HasPartitionReq.java b/src/main/java/io/milvus/v2/service/partition/request/HasPartitionReq.java
new file mode 100644
index 000000000..0f281e7e8
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/partition/request/HasPartitionReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.partition.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class HasPartitionReq {
+ private String collectionName;
+ private String partitionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/partition/request/ListPartitionsReq.java b/src/main/java/io/milvus/v2/service/partition/request/ListPartitionsReq.java
new file mode 100644
index 000000000..364627ef2
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/partition/request/ListPartitionsReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.partition.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class ListPartitionsReq {
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/partition/request/LoadPartitionsReq.java b/src/main/java/io/milvus/v2/service/partition/request/LoadPartitionsReq.java
new file mode 100644
index 000000000..308185498
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/partition/request/LoadPartitionsReq.java
@@ -0,0 +1,13 @@
+package io.milvus.v2.service.partition.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class LoadPartitionsReq {
+ private String collectionName;
+ private List partitionNames;
+}
diff --git a/src/main/java/io/milvus/v2/service/partition/request/ReleasePartitionsReq.java b/src/main/java/io/milvus/v2/service/partition/request/ReleasePartitionsReq.java
new file mode 100644
index 000000000..4210387c3
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/partition/request/ReleasePartitionsReq.java
@@ -0,0 +1,13 @@
+package io.milvus.v2.service.partition.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class ReleasePartitionsReq {
+ private String collectionName;
+ private List partitionNames;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/RoleService.java b/src/main/java/io/milvus/v2/service/rbac/RoleService.java
new file mode 100644
index 000000000..d26f46310
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/RoleService.java
@@ -0,0 +1,133 @@
+package io.milvus.v2.service.rbac;
+
+import io.milvus.grpc.*;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.v2.service.BaseService;
+import io.milvus.v2.service.rbac.request.*;
+import io.milvus.v2.service.rbac.response.DescribeRoleResp;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class RoleService extends BaseService {
+
+ public R> listRoles(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub) {
+ String title = "listRoles";
+ SelectRoleRequest request = SelectRoleRequest.newBuilder().build();
+ SelectRoleResponse response = blockingStub.selectRole(request);
+
+ rpcUtils.handleResponse(title, response.getStatus());
+ List roles = response.getResultsList().stream().map(roleResult -> roleResult.getRole().getName()).collect(Collectors.toList());
+ return R.success(roles);
+ }
+
+ public R createRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateRoleReq request) {
+ String title = "createRole";
+ CreateRoleRequest createRoleRequest = CreateRoleRequest.newBuilder()
+ .setEntity(RoleEntity.newBuilder()
+ .setName(request.getRoleName())
+ .build())
+ .build();
+ Status status = blockingStub.createRole(createRoleRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R describeRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DescribeRoleReq request) {
+ String title = "describeRole";
+ SelectGrantRequest selectGrantRequest = SelectGrantRequest.newBuilder()
+ .setEntity(GrantEntity.newBuilder()
+ .setRole(RoleEntity.newBuilder()
+ .setName(request.getRoleName())
+ .build())
+ .build())
+ .build();
+ SelectGrantResponse response = blockingStub.selectGrant(selectGrantRequest);
+ rpcUtils.handleResponse(title, response.getStatus());
+ DescribeRoleResp describeRoleResp = DescribeRoleResp.builder()
+ .grantInfos(response.getEntitiesList().stream().map(grantEntity -> DescribeRoleResp.GrantInfo.builder()
+ .dbName(grantEntity.getDbName())
+ .objectName(grantEntity.getObjectName())
+ .objectType(grantEntity.getObject().getName())
+ .privilege(grantEntity.getGrantor().getPrivilege().getName())
+ .grantor(grantEntity.getGrantor().getUser().getName())
+ .build()).collect(Collectors.toList()))
+ .build();
+ return R.success(describeRoleResp);
+ }
+
+ public R dropRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropRoleReq request) {
+ String title = "dropRole";
+ DropRoleRequest dropRoleRequest = DropRoleRequest.newBuilder()
+ .setRoleName(request.getRoleName())
+ .build();
+ Status status = blockingStub.dropRole(dropRoleRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R grantPrivilege(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GrantPrivilegeReq request) {
+ String title = "grantPrivilege";
+ GrantEntity entity = GrantEntity.newBuilder()
+ .setRole(RoleEntity.newBuilder()
+ .setName(request.getRoleName())
+ .build())
+ .setObjectName(request.getObjectName())
+ .setObject(ObjectEntity.newBuilder().setName(request.getObjectType()).build())
+ .setGrantor(GrantorEntity.newBuilder()
+ .setPrivilege(PrivilegeEntity.newBuilder().setName(request.getPrivilege()).build()).build())
+ .build();
+ OperatePrivilegeRequest operatePrivilegeRequest = OperatePrivilegeRequest.newBuilder()
+ .setEntity(entity)
+ .setType(OperatePrivilegeType.Grant)
+ .build();
+ Status status = blockingStub.operatePrivilege(operatePrivilegeRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R revokePrivilege(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, RevokePrivilegeReq request) {
+ String title = "revokePrivilege";
+ GrantEntity entity = GrantEntity.newBuilder()
+ .setRole(RoleEntity.newBuilder()
+ .setName(request.getRoleName())
+ .build())
+ .setObjectName(request.getObjectName())
+ .setObject(ObjectEntity.newBuilder().setName(request.getObjectType()).build())
+ .setGrantor(GrantorEntity.newBuilder()
+ .setPrivilege(PrivilegeEntity.newBuilder().setName(request.getPrivilege()).build()).build())
+ .build();
+ OperatePrivilegeRequest operatePrivilegeRequest = OperatePrivilegeRequest.newBuilder()
+ .setEntity(entity)
+ .setType(OperatePrivilegeType.Revoke)
+ .build();
+ Status status = blockingStub.operatePrivilege(operatePrivilegeRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R grantRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, GrantRoleReq request) {
+ String title = "grantRole";
+ OperateUserRoleRequest operateUserRoleRequest = OperateUserRoleRequest.newBuilder()
+ .setUsername(request.getUserName())
+ .setRoleName(request.getRoleName())
+ .setType(OperateUserRoleType.AddUserToRole)
+ .build();
+ Status status = blockingStub.operateUserRole(operateUserRoleRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R revokeRole(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, RevokeRoleReq request) {
+ String title = "grantRole";
+ OperateUserRoleRequest operateUserRoleRequest = OperateUserRoleRequest.newBuilder()
+ .setUsername(request.getUserName())
+ .setRoleName(request.getRoleName())
+ .setType(OperateUserRoleType.RemoveUserFromRole)
+ .build();
+ Status status = blockingStub.operateUserRole(operateUserRoleRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/UserService.java b/src/main/java/io/milvus/v2/service/rbac/UserService.java
new file mode 100644
index 000000000..7db4f0cac
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/UserService.java
@@ -0,0 +1,73 @@
+package io.milvus.v2.service.rbac;
+
+import io.milvus.grpc.*;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.v2.service.rbac.request.*;
+import io.milvus.v2.service.BaseService;
+import io.milvus.v2.service.rbac.response.DescribeUserResp;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class UserService extends BaseService {
+
+ public R> listUsers(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub) {
+ String title = "list users";
+ ListCredUsersRequest request = ListCredUsersRequest.newBuilder().build();
+ ListCredUsersResponse response = blockingStub.listCredUsers(request);
+ rpcUtils.handleResponse(title, response.getStatus());
+ return R.success(response.getUsernamesList());
+ }
+
+ public R describeUser(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DescribeUserReq request) {
+ String title = String.format("describe user %s", request.getUserName());
+ // TODO: check user exists
+ SelectUserRequest selectUserRequest = SelectUserRequest.newBuilder()
+ .setUser(UserEntity.newBuilder().setName(request.getUserName()).build())
+ .setIncludeRoleInfo(Boolean.TRUE)
+ .build();
+ io.milvus.grpc.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()))
+ .build();
+ return R.success(describeUserResp);
+ }
+
+ public R createUser(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateUserReq request) {
+ 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)))
+ .build();
+ Status response = blockingStub.createCredential(createCredentialRequest);
+ rpcUtils.handleResponse(title, response);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+
+ public R updatePassword(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, UpdatePasswordReq request) {
+ 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)))
+ .setNewPassword(Base64.getEncoder().encodeToString(request.getNewPassword().getBytes(StandardCharsets.UTF_8)))
+ .build();
+ Status response = blockingStub.updateCredential(updateCredentialRequest);
+ rpcUtils.handleResponse(title, response);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R dropUser(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropUserReq request) {
+ String title = String.format("drop user %s", request.getUserName());
+ DeleteCredentialRequest deleteCredentialRequest = DeleteCredentialRequest.newBuilder()
+ .setUsername(request.getUserName())
+ .build();
+ Status response = blockingStub.deleteCredential(deleteCredentialRequest);
+ rpcUtils.handleResponse(title, response);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/CreateRoleReq.java b/src/main/java/io/milvus/v2/service/rbac/request/CreateRoleReq.java
new file mode 100644
index 000000000..55b53d092
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/CreateRoleReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class CreateRoleReq {
+ private String roleName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/CreateUserReq.java b/src/main/java/io/milvus/v2/service/rbac/request/CreateUserReq.java
new file mode 100644
index 000000000..57b317510
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/CreateUserReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class CreateUserReq {
+ private String userName;
+ private String password;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/DescribeRoleReq.java b/src/main/java/io/milvus/v2/service/rbac/request/DescribeRoleReq.java
new file mode 100644
index 000000000..9ca09de4e
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/DescribeRoleReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DescribeRoleReq {
+ private String roleName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/DescribeUserReq.java b/src/main/java/io/milvus/v2/service/rbac/request/DescribeUserReq.java
new file mode 100644
index 000000000..444e4a6b9
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/DescribeUserReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DescribeUserReq {
+ private String userName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/DropRoleReq.java b/src/main/java/io/milvus/v2/service/rbac/request/DropRoleReq.java
new file mode 100644
index 000000000..aa2544375
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/DropRoleReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DropRoleReq {
+ private String roleName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/DropUserReq.java b/src/main/java/io/milvus/v2/service/rbac/request/DropUserReq.java
new file mode 100644
index 000000000..cb4333e85
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/DropUserReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DropUserReq {
+ private String userName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/GrantPrivilegeReq.java b/src/main/java/io/milvus/v2/service/rbac/request/GrantPrivilegeReq.java
new file mode 100644
index 000000000..9455322a4
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/GrantPrivilegeReq.java
@@ -0,0 +1,13 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class GrantPrivilegeReq {
+ private String roleName;
+ private String objectType;
+ private String privilege;
+ private String objectName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/GrantRoleReq.java b/src/main/java/io/milvus/v2/service/rbac/request/GrantRoleReq.java
new file mode 100644
index 000000000..d0fa77ddc
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/GrantRoleReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class GrantRoleReq {
+ private String userName;
+ private String roleName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/RevokePrivilegeReq.java b/src/main/java/io/milvus/v2/service/rbac/request/RevokePrivilegeReq.java
new file mode 100644
index 000000000..f739e6113
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/RevokePrivilegeReq.java
@@ -0,0 +1,14 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class RevokePrivilegeReq {
+ private String roleName;
+ private String dbName;
+ private String objectType;
+ private String privilege;
+ private String objectName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/RevokeRoleReq.java b/src/main/java/io/milvus/v2/service/rbac/request/RevokeRoleReq.java
new file mode 100644
index 000000000..303ff6359
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/RevokeRoleReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class RevokeRoleReq {
+ private String userName;
+ private String roleName;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/request/UpdatePasswordReq.java b/src/main/java/io/milvus/v2/service/rbac/request/UpdatePasswordReq.java
new file mode 100644
index 000000000..d0348e294
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/request/UpdatePasswordReq.java
@@ -0,0 +1,12 @@
+package io.milvus.v2.service.rbac.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class UpdatePasswordReq {
+ private String userName;
+ private String password;
+ private String newPassword;
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/response/DescribeRoleResp.java b/src/main/java/io/milvus/v2/service/rbac/response/DescribeRoleResp.java
new file mode 100644
index 000000000..da2275335
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/response/DescribeRoleResp.java
@@ -0,0 +1,23 @@
+package io.milvus.v2.service.rbac.response;
+
+import io.milvus.grpc.GrantEntity;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class DescribeRoleResp {
+ List grantInfos;
+
+ @Data
+ @SuperBuilder
+ public static class GrantInfo {
+ private String objectType;
+ private String privilege;
+ private String objectName;
+ private String dbName;
+ private String grantor;
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/rbac/response/DescribeUserResp.java b/src/main/java/io/milvus/v2/service/rbac/response/DescribeUserResp.java
new file mode 100644
index 000000000..de5a3d758
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/rbac/response/DescribeUserResp.java
@@ -0,0 +1,12 @@
+package io.milvus.v2.service.rbac.response;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class DescribeUserResp {
+ private List roles;
+}
diff --git a/src/main/java/io/milvus/v2/service/utility/UtilityService.java b/src/main/java/io/milvus/v2/service/utility/UtilityService.java
new file mode 100644
index 000000000..ef0aa5525
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/utility/UtilityService.java
@@ -0,0 +1,86 @@
+package io.milvus.v2.service.utility;
+
+import io.milvus.grpc.FlushResponse;
+import io.milvus.grpc.MilvusServiceGrpc;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.v2.service.utility.request.FlushReq;
+import io.milvus.v2.service.BaseService;
+import io.milvus.v2.service.utility.request.AlterAliasReq;
+import io.milvus.v2.service.utility.request.CreateAliasReq;
+import io.milvus.v2.service.utility.request.DropAliasReq;
+import io.milvus.v2.service.utility.response.DescribeAliasResp;
+import io.milvus.v2.service.utility.response.ListAliasResp;
+
+public class UtilityService extends BaseService {
+ public R flush(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, FlushReq request) {
+ String title = String.format("Flush collection %s", request.getCollectionName());
+ io.milvus.grpc.FlushRequest flushRequest = io.milvus.grpc.FlushRequest.newBuilder()
+ .addCollectionNames(request.getCollectionName())
+ .build();
+ FlushResponse status = blockingStub.flush(flushRequest);
+ rpcUtils.handleResponse(title, status.getStatus());
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R createAlias(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, CreateAliasReq request) {
+ String title = String.format("Create alias %s for collection %s", request.getAlias(), request.getCollectionName());
+ io.milvus.grpc.CreateAliasRequest createAliasRequest = io.milvus.grpc.CreateAliasRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .setAlias(request.getAlias())
+ .build();
+ io.milvus.grpc.Status status = blockingStub.createAlias(createAliasRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R dropAlias(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, DropAliasReq request) {
+ String title = String.format("Drop alias %s", request.getAlias());
+ io.milvus.grpc.DropAliasRequest dropAliasRequest = io.milvus.grpc.DropAliasRequest.newBuilder()
+ .setAlias(request.getAlias())
+ .build();
+ io.milvus.grpc.Status status = blockingStub.dropAlias(dropAliasRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R alterAlias(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, AlterAliasReq request) {
+ String title = String.format("Alter alias %s for collection %s", request.getAlias(), request.getCollectionName());
+ io.milvus.grpc.AlterAliasRequest alterAliasRequest = io.milvus.grpc.AlterAliasRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .setAlias(request.getAlias())
+ .build();
+ io.milvus.grpc.Status status = blockingStub.alterAlias(alterAliasRequest);
+ rpcUtils.handleResponse(title, status);
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R describeAlias(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, String alias) {
+ String title = String.format("Describe alias %s", alias);
+ io.milvus.grpc.DescribeAliasRequest describeAliasRequest = io.milvus.grpc.DescribeAliasRequest.newBuilder()
+ .setAlias(alias)
+ .build();
+ io.milvus.grpc.DescribeAliasResponse response = blockingStub.describeAlias(describeAliasRequest);
+
+ rpcUtils.handleResponse(title, response.getStatus());
+
+ return R.success(DescribeAliasResp.builder()
+ .collectionName(response.getCollection())
+ .alias(response.getAlias())
+ .build());
+ }
+
+ public R listAliases(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub) {
+ String title = "List aliases";
+ io.milvus.grpc.ListAliasesRequest listAliasesRequest = io.milvus.grpc.ListAliasesRequest.newBuilder()
+ .build();
+ io.milvus.grpc.ListAliasesResponse response = blockingStub.listAliases(listAliasesRequest);
+
+ rpcUtils.handleResponse(title, response.getStatus());
+
+ return R.success(ListAliasResp.builder()
+ .collectionName(response.getCollectionName())
+ .alias(response.getAliasesList())
+ .build());
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/utility/request/AlterAliasReq.java b/src/main/java/io/milvus/v2/service/utility/request/AlterAliasReq.java
new file mode 100644
index 000000000..a4dc28f86
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/utility/request/AlterAliasReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.utility.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class AlterAliasReq {
+ private String alias;
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/utility/request/CreateAliasReq.java b/src/main/java/io/milvus/v2/service/utility/request/CreateAliasReq.java
new file mode 100644
index 000000000..2a8f97c16
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/utility/request/CreateAliasReq.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.utility.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class CreateAliasReq {
+ private String alias;
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/utility/request/DropAliasReq.java b/src/main/java/io/milvus/v2/service/utility/request/DropAliasReq.java
new file mode 100644
index 000000000..f564b0272
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/utility/request/DropAliasReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.utility.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DropAliasReq {
+ private String alias;
+}
diff --git a/src/main/java/io/milvus/v2/service/utility/request/FlushReq.java b/src/main/java/io/milvus/v2/service/utility/request/FlushReq.java
new file mode 100644
index 000000000..4bbdd0b41
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/utility/request/FlushReq.java
@@ -0,0 +1,10 @@
+package io.milvus.v2.service.utility.request;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class FlushReq {
+ private String collectionName;
+}
diff --git a/src/main/java/io/milvus/v2/service/utility/response/DescribeAliasResp.java b/src/main/java/io/milvus/v2/service/utility/response/DescribeAliasResp.java
new file mode 100644
index 000000000..e43b32a96
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/utility/response/DescribeAliasResp.java
@@ -0,0 +1,11 @@
+package io.milvus.v2.service.utility.response;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+public class DescribeAliasResp {
+ private String collectionName;
+ private String alias;
+}
diff --git a/src/main/java/io/milvus/v2/service/utility/response/ListAliasResp.java b/src/main/java/io/milvus/v2/service/utility/response/ListAliasResp.java
new file mode 100644
index 000000000..df1baa486
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/utility/response/ListAliasResp.java
@@ -0,0 +1,13 @@
+package io.milvus.v2.service.utility.response;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class ListAliasResp {
+ private String collectionName;
+ private List alias;
+}
diff --git a/src/main/java/io/milvus/v2/service/vector/VectorService.java b/src/main/java/io/milvus/v2/service/vector/VectorService.java
new file mode 100644
index 000000000..110c8724b
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/vector/VectorService.java
@@ -0,0 +1,134 @@
+package io.milvus.v2.service.vector;
+
+import io.milvus.grpc.*;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.response.DescCollResponseWrapper;
+import io.milvus.v2.service.BaseService;
+import io.milvus.v2.service.collection.CollectionService;
+import io.milvus.v2.service.collection.request.DescribeCollectionReq;
+import io.milvus.v2.service.collection.response.DescribeCollectionResp;
+import io.milvus.v2.service.index.request.DescribeIndexReq;
+import io.milvus.v2.service.index.response.DescribeIndexResp;
+import io.milvus.v2.service.index.IndexService;
+import io.milvus.v2.service.vector.request.*;
+import io.milvus.v2.service.vector.response.QueryResp;
+import io.milvus.v2.service.vector.response.GetResp;
+import io.milvus.v2.service.vector.response.SearchResp;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class VectorService extends BaseService {
+ Logger logger = LoggerFactory.getLogger(VectorService.class);
+ public CollectionService collectionService = new CollectionService();
+ public IndexService indexService = new IndexService();
+
+ public R insert(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, InsertReq request){
+ String title = String.format("InsertRequest collectionName:%s", request.getCollectionName());
+ checkCollectionExist(blockingStub, request.getCollectionName());
+ DescribeCollectionRequest describeCollectionRequest = DescribeCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName()).build();
+ DescribeCollectionResponse descResp = blockingStub.describeCollection(describeCollectionRequest);
+
+ MutationResult response = blockingStub.insert(dataUtils.convertGrpcInsertRequest(request, new DescCollResponseWrapper(descResp)));
+ rpcUtils.handleResponse(title, response.getStatus());
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R upsert(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, UpsertReq request) {
+ String title = String.format("UpsertRequest collectionName:%s", request.getCollectionName());
+
+ checkCollectionExist(milvusServiceBlockingStub, request.getCollectionName());
+
+ DescribeCollectionRequest describeCollectionRequest = DescribeCollectionRequest.newBuilder()
+ .setCollectionName(request.getCollectionName()).build();
+ DescribeCollectionResponse descResp = milvusServiceBlockingStub.describeCollection(describeCollectionRequest);
+
+ MutationResult response = milvusServiceBlockingStub.upsert(dataUtils.convertGrpcUpsertRequest(request, new DescCollResponseWrapper(descResp)));
+ rpcUtils.handleResponse(title, response.getStatus());
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R query(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, QueryReq request) {
+ String title = String.format("QueryRequest collectionName:%s", request.getCollectionName());
+ checkCollectionExist(milvusServiceBlockingStub, request.getCollectionName());
+ R descR = collectionService.describeCollection(milvusServiceBlockingStub, DescribeCollectionReq.builder().collectionName(request.getCollectionName()).build());
+ if(request.getOutputFields() == null){
+ request.setOutputFields(descR.getData().getFieldNames());
+ }
+ QueryResults response = milvusServiceBlockingStub.query(vectorUtils.ConvertToGrpcQueryRequest(request));
+ rpcUtils.handleResponse(title, response.getStatus());
+
+ QueryResp res = QueryResp.builder()
+ .queryResults(convertUtils.getEntities(response))
+ .build();
+ return R.success(res);
+
+ }
+
+ public R search(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, SearchReq request) {
+ String title = String.format("SearchRequest collectionName:%s", request.getCollectionName());
+
+ checkCollectionExist(milvusServiceBlockingStub, request.getCollectionName());
+ R descR = collectionService.describeCollection(milvusServiceBlockingStub, DescribeCollectionReq.builder().collectionName(request.getCollectionName()).build());
+ if (request.getVectorFieldName() == null) {
+ request.setVectorFieldName(descR.getData().getVectorFieldName().get(0));
+ }
+ if(request.getOutFields() == null){
+ request.setOutFields(descR.getData().getFieldNames());
+ }
+ DescribeIndexReq describeIndexReq = DescribeIndexReq.builder()
+ .collectionName(request.getCollectionName())
+ .fieldName(request.getVectorFieldName())
+ .build();
+ R respR = indexService.describeIndex(milvusServiceBlockingStub, describeIndexReq);
+
+ SearchRequest searchRequest = vectorUtils.ConvertToGrpcSearchRequest(respR.getData().getMetricType(), request);
+
+ SearchResults response = milvusServiceBlockingStub.search(searchRequest);
+ rpcUtils.handleResponse(title, response.getStatus());
+
+ SearchResp searchResp = SearchResp.builder()
+ .searchResults(convertUtils.getEntities(response))
+ .build();
+ return R.success(searchResp);
+ }
+
+ public R delete(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, DeleteReq request) {
+ String title = String.format("DeleteRequest collectionName:%s", request.getCollectionName());
+ checkCollectionExist(milvusServiceBlockingStub, request.getCollectionName());
+ R respR = collectionService.describeCollection(milvusServiceBlockingStub, DescribeCollectionReq.builder().collectionName(request.getCollectionName()).build());
+ if(request.getExpr() == null){
+ request.setExpr(vectorUtils.getExprById(respR.getData().getPrimaryFieldName(), request.getIds()));
+ }
+ DeleteRequest deleteRequest = DeleteRequest.newBuilder()
+ .setCollectionName(request.getCollectionName())
+ .setPartitionName(request.getPartitionName())
+ .setExpr(request.getExpr())
+ .build();
+ MutationResult response = milvusServiceBlockingStub.delete(deleteRequest);
+ rpcUtils.handleResponse(title, response.getStatus());
+ return R.success(new RpcStatus(RpcStatus.SUCCESS_MSG));
+ }
+
+ public R get(MilvusServiceGrpc.MilvusServiceBlockingStub milvusServiceBlockingStub, GetReq request) {
+ String title = String.format("GetRequest collectionName:%s", request.getCollectionName());
+ checkCollectionExist(milvusServiceBlockingStub, request.getCollectionName());
+ DescribeCollectionReq describeCollectionReq = DescribeCollectionReq.builder()
+ .collectionName(request.getCollectionName())
+ .build();
+ R resp = collectionService.describeCollection(milvusServiceBlockingStub, describeCollectionReq);
+
+ String expr = vectorUtils.getExprById(resp.getData().getPrimaryFieldName(), request.getIds());
+ QueryReq queryReq = QueryReq.builder()
+ .collectionName(request.getCollectionName())
+ .expr(expr)
+ .build();
+ R queryResp = query(milvusServiceBlockingStub, queryReq);
+
+ GetResp getResp = GetResp.builder()
+ .getResults(queryResp.getData().getQueryResults())
+ .build();
+ return R.success(getResp);
+ }
+}
diff --git a/src/main/java/io/milvus/v2/service/vector/request/DeleteReq.java b/src/main/java/io/milvus/v2/service/vector/request/DeleteReq.java
new file mode 100644
index 000000000..c898f8c50
--- /dev/null
+++ b/src/main/java/io/milvus/v2/service/vector/request/DeleteReq.java
@@ -0,0 +1,17 @@
+package io.milvus.v2.service.vector.request;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+public class DeleteReq {
+ private String collectionName;
+ @Builder.Default
+ private String partitionName = "";
+ private String expr;
+ private List