io.milvus.client

## Class AbstractMilvusGrpcClient

- java.lang.Object
- - io.milvus.client.AbstractMilvusGrpcClient

- All Implemented Interfaces:
    MilvusClient
  Direct Known Subclasses:
    MilvusServiceClient

      public abstract class AbstractMilvusGrpcClient
      extends java.lang.Object
      implements MilvusClient

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractMilvusGrpcClient()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `R<RpcStatus>` | `addUserToRole(AddUserToRoleParam requestParam)` The user will get permissions that the role are allowed to perform operations.
    `R<RpcStatus>` | `alterAlias(@NonNull AlterAliasParam requestParam)` Alters alias from a collection to another.
    `R<RpcStatus>` | `alterCollection(AlterCollectionParam requestParam)` Alter collection with key-value properties.
    `R<RpcStatus>` | `alterDatabase(AlterDatabaseParam requestParam)` Alter database with key value pair.
    `R<RpcStatus>` | `alterIndex(AlterIndexParam requestParam)` Alter index with key value properties.
    `R<io.milvus.grpc.ImportResponse>` | `bulkInsert(BulkInsertParam requestParam)` Import data from external files, currently support JSON format
    `R<io.milvus.grpc.CheckHealthResponse>` | `checkHealth()` Check server health
    `R<RpcStatus>` | `createAlias(@NonNull CreateAliasParam requestParam)` Creates an alias for a collection.
    `R<RpcStatus>` | `createCollection(@NonNull CreateCollectionParam requestParam)` Creates a collection in Milvus.
    `R<RpcStatus>` | `createCollection(CreateSimpleCollectionParam requestParam)` Creates a collection in Milvus.
    `R<RpcStatus>` | `createCredential(CreateCredentialParam requestParam)` Create credential using the given user and password.
    `R<RpcStatus>` | `createDatabase(CreateDatabaseParam requestParam)` Creates a database in Milvus.
    `R<RpcStatus>` | `createIndex(@NonNull CreateIndexParam requestParam)` Creates an index on a vector field in the specified collection.
    `R<RpcStatus>` | `createPartition(@NonNull CreatePartitionParam requestParam)` Creates a partition in the specified collection.
    `R<RpcStatus>` | `createResourceGroup(CreateResourceGroupParam requestParam)` Create a resource group.
    `R<RpcStatus>` | `createRole(CreateRoleParam requestParam)` It will success if the role isn't existed, otherwise fail.
    `R<DeleteResponse>` | `delete(DeleteIdsParam requestParam)` Deletes entity(s) based on the value of primary key.
    `R<io.milvus.grpc.MutationResult>` | `delete(@NonNull DeleteParam requestParam)` Deletes entity(s) based on primary key(s) filtered by boolean expression.
    `R<RpcStatus>` | `deleteCredential(DeleteCredentialParam requestParam)` Delete credential corresponding to the user.
    `R<io.milvus.grpc.DescribeCollectionResponse>` | `describeCollection(@NonNull DescribeCollectionParam requestParam)` Shows the details of a collection, e.g.
    `R<io.milvus.grpc.DescribeDatabaseResponse>` | `describeDatabase(DescribeDatabaseParam requestParam)` Show detail of database base, such as replica number and resource groups.
    `R<io.milvus.grpc.DescribeIndexResponse>` | `describeIndex(@NonNull DescribeIndexParam requestParam)` Shows the information of the specified index.
    `R<io.milvus.grpc.DescribeResourceGroupResponse>` | `describeResourceGroup(DescribeResourceGroupParam requestParam)` Describe a resource group.
    `R<RpcStatus>` | `dropAlias(@NonNull DropAliasParam requestParam)` Drops an alias for the specified collection.
    `R<RpcStatus>` | `dropCollection(@NonNull DropCollectionParam requestParam)` Drops a collection.
    `R<RpcStatus>` | `dropDatabase(DropDatabaseParam requestParam)` Drops a database.
    `R<RpcStatus>` | `dropIndex(@NonNull DropIndexParam requestParam)` Drops the index on a vector field in the specified collection.
    `R<RpcStatus>` | `dropPartition(@NonNull DropPartitionParam requestParam)` Drops a partition.
    `R<RpcStatus>` | `dropResourceGroup(DropResourceGroupParam requestParam)` Drop a resource group.
    `R<RpcStatus>` | `dropRole(DropRoleParam requestParam)` It will success if the role is existed, otherwise fail.
    `R<io.milvus.grpc.FlushResponse>` | `flush(@NonNull FlushParam requestParam)` Flush insert buffer into storage.
    `R<io.milvus.grpc.FlushAllResponse>` | `flushAll(boolean syncFlushAll, long syncFlushAllWaitingInterval, long syncFlushAllTimeout)` Flush all collections.
    `R<GetResponse>` | `get(GetIdsParam requestParam)` Get entity(s) based on the value of primary key.
    `R<io.milvus.grpc.GetImportStateResponse>` | `getBulkInsertState(GetBulkInsertStateParam requestParam)` Get state of bulk insert task
    `R<io.milvus.grpc.GetCollectionStatisticsResponse>` | `getCollectionStatistics(@NonNull GetCollectionStatisticsParam requestParam)` Shows the statistics information of a collection.
    `R<io.milvus.grpc.GetCompactionStateResponse>` | `getCompactionState(GetCompactionStateParam requestParam)` Gets the compaction state by id.
    `R<io.milvus.grpc.GetCompactionPlansResponse>` | `getCompactionStateWithPlans(GetCompactionPlansParam requestParam)` Gets compaction state with its plan.
    `R<io.milvus.grpc.GetFlushAllStateResponse>` | `getFlushAllState(GetFlushAllStateParam requestParam)` Get flush state of all segments.
    `R<io.milvus.grpc.GetFlushStateResponse>` | `getFlushState(@NonNull GetFlushStateParam requestParam)` Get flush state of specified collection.
    `R<io.milvus.grpc.GetIndexBuildProgressResponse>` | `getIndexBuildProgress(@NonNull GetIndexBuildProgressParam requestParam)` Deprecated.
    `R<io.milvus.grpc.GetIndexStateResponse>` | `getIndexState(@NonNull GetIndexStateParam requestParam)` Deprecated.
    `R<io.milvus.grpc.GetLoadingProgressResponse>` | `getLoadingProgress(GetLoadingProgressParam requestParam)` Get collection loading progress
    `R<io.milvus.grpc.GetLoadStateResponse>` | `getLoadState(GetLoadStateParam requestParam)` Get collection loading state
    `R<io.milvus.grpc.GetMetricsResponse>` | `getMetrics(@NonNull GetMetricsParam requestParam)` Gets the runtime metrics information of Milvus, returns the result in .json format.
    `R<io.milvus.grpc.GetPartitionStatisticsResponse>` | `getPartitionStatistics(@NonNull GetPartitionStatisticsParam requestParam)` Shows the statistics information of a partition.
    `R<io.milvus.grpc.GetPersistentSegmentInfoResponse>` | `getPersistentSegmentInfo(@NonNull GetPersistentSegmentInfoParam requestParam)` Gets the information of persistent segments from data node, including row count, persistence state(growing or flushed), etc.
    `R<io.milvus.grpc.GetQuerySegmentInfoResponse>` | `getQuerySegmentInfo(@NonNull GetQuerySegmentInfoParam requestParam)` Gets the query information of segments in a collection from query node, including row count, memory usage size, index name, etc.
    `R<io.milvus.grpc.GetReplicasResponse>` | `getReplicas(GetReplicasParam requestParam)` Returns the collection's replica information
    `R<io.milvus.grpc.GetVersionResponse>` | `getVersion()` Get server version
    `R<RpcStatus>` | `grantRolePrivilege(GrantRolePrivilegeParam requestParam)` Grant Role Privilege.
    `R<java.lang.Boolean>` | `hasCollection(@NonNull HasCollectionParam requestParam)` Checks if a collection exists.
    `R<java.lang.Boolean>` | `hasPartition(@NonNull HasPartitionParam requestParam)` Checks if a partition exists in the specified collection.
    `R<io.milvus.grpc.SearchResults>` | `hybridSearch(HybridSearchParam requestParam)` Conducts multi vector similarity search with a ranker for rearrangement.
    `com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.SearchResults>>` | `hybridSearchAsync(HybridSearchParam requestParam)` Conducts multi vector similarity search asynchronously with a ranker for rearrangement.
    `R<io.milvus.grpc.MutationResult>` | `insert(@NonNull InsertParam requestParam)` Inserts entities into a specified collection .
    `R<InsertResponse>` | `insert(InsertRowsParam requestParam)` Inserts rows data into a specified collection .
    `com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.MutationResult>>` | `insertAsync(InsertParam requestParam)` Inserts entities into a specified collection asynchronously.
    `R<io.milvus.grpc.ListAliasesResponse>` | `listAliases(ListAliasesParam requestParam)` List all alias for a collection.
    `R<io.milvus.grpc.ListImportTasksResponse>` | `listBulkInsertTasks(ListBulkInsertTasksParam requestParam)` List bulk insert tasks
    `R<ListCollectionsResponse>` | `listCollections(ListCollectionsParam requestParam)` Lists all collections
    `R<io.milvus.grpc.ListCredUsersResponse>` | `listCredUsers(ListCredUsersParam requestParam)` List all user names.
    `R<io.milvus.grpc.ListDatabasesResponse>` | `listDatabases()` List databases.
    `R<io.milvus.grpc.ListResourceGroupsResponse>` | `listResourceGroups(ListResourceGroupsParam requestParam)` List resource groups.
    `R<RpcStatus>` | `loadBalance(LoadBalanceParam requestParam)` Moves segment from a query node to another to keep the load balanced.
    `R<RpcStatus>` | `loadCollection(@NonNull LoadCollectionParam requestParam)` Loads a collection to memory before search or query.
    `R<RpcStatus>` | `loadPartitions(@NonNull LoadPartitionsParam requestParam)` Loads a partition into memory.
    `R<io.milvus.grpc.ManualCompactionResponse>` | `manualCompact(ManualCompactParam requestParam)` Performs a manual compaction.
    `R<io.milvus.grpc.QueryResults>` | `query(@NonNull QueryParam requestParam)` Queries entity(s) based on scalar field(s) filtered by boolean expression.
    `R<QueryResponse>` | `query(QuerySimpleParam requestParam)` Queries entity(s) based on scalar field(s) filtered by boolean expression.
    `com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.QueryResults>>` | `queryAsync(QueryParam requestParam)` Queries entity(s) asynchronously based on scalar field(s) filtered by boolean expression.
    `R<QueryIterator>` | `queryIterator(QueryIteratorParam requestParam)` Get queryIterator based on scalar field(s) filtered by boolean expression.
    `R<RpcStatus>` | `releaseCollection(@NonNull ReleaseCollectionParam requestParam)` Releases a collection from memory to reduce memory usage.
    `R<RpcStatus>` | `releasePartitions(@NonNull ReleasePartitionsParam requestParam)` Releases a partition from memory.
    `R<RpcStatus>` | `removeUserFromRole(RemoveUserFromRoleParam requestParam)` The user will remove permissions that the role are allowed to perform operations.
    `R<RpcStatus>` | `renameCollection(RenameCollectionParam requestParam)` rename a collection
    `R<RpcStatus>` | `revokeRolePrivilege(RevokeRolePrivilegeParam requestParam)` Revoke Role Privilege.
    `R<io.milvus.grpc.SearchResults>` | `search(@NonNull SearchParam requestParam)` Conducts ANN search on a vector field.
    `R<SearchResponse>` | `search(SearchSimpleParam requestParam)` Conducts ANN search on a vector field.
    `com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.SearchResults>>` | `searchAsync(SearchParam requestParam)` Conducts ANN search on a vector field asynchronously.
    `R<SearchIterator>` | `searchIterator(SearchIteratorParam requestParam)` Get searchIterator based on a vector field.
    `R<io.milvus.grpc.SelectGrantResponse>` | `selectGrantForRole(SelectGrantForRoleParam requestParam)` List a grant info for the role and the specific object
    `R<io.milvus.grpc.SelectGrantResponse>` | `selectGrantForRoleAndObject(SelectGrantForRoleAndObjectParam requestParam)` List a grant info for the role
    `R<io.milvus.grpc.SelectRoleResponse>` | `selectRole(SelectRoleParam requestParam)` Get all users who are added to the role.
    `R<io.milvus.grpc.SelectUserResponse>` | `selectUser(SelectUserParam requestParam)` Get all roles the user has.
    `R<io.milvus.grpc.ShowCollectionsResponse>` | `showCollections(@NonNull ShowCollectionsParam requestParam)` Lists all collections or gets collection loading status.
    `R<io.milvus.grpc.ShowPartitionsResponse>` | `showPartitions(@NonNull ShowPartitionsParam requestParam)` Shows all partitions in the specified collection.
    `R<RpcStatus>` | `transferNode(TransferNodeParam requestParam)` Transfer a query node from source resource group to target resource_group.
    `R<RpcStatus>` | `transferReplica(TransferReplicaParam requestParam)` Transfer a replica from source resource group to target resource_group.
    `R<RpcStatus>` | `updateCredential(UpdateCredentialParam requestParam)` Update credential using the given user and password.
    `R<RpcStatus>` | `updateResourceGroups(UpdateResourceGroupsParam requestParam)` Update resource groups.
    `R<io.milvus.grpc.MutationResult>` | `upsert(UpsertParam requestParam)` Insert new entities into a specified collection, replace them if the entities already exist.
    `com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.MutationResult>>` | `upsertAsync(UpsertParam requestParam)` Insert new entities into a specified collection asynchronously, replace them if the entities already exist.

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface io.milvus.client.MilvusClient

      `close, close, setLogLevel, withRetry, withRetry, withRetryInterval, withTimeout`

- - ### Constructor Detail

    - #### AbstractMilvusGrpcClient

          public AbstractMilvusGrpcClient()

  - ### Method Detail

    - #### hasCollection

          public R<java.lang.Boolean> hasCollection(@NonNull
                                                    @NonNull HasCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      Checks if a collection exists.
      Specified by:
        `hasCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `HasCollectionParam`
      Returns:
        {status:result code, data: boolean, whether if has collection or not}

    - #### createDatabase

          public R<RpcStatus> createDatabase(CreateDatabaseParam requestParam)

      Description copied from interface: `MilvusClient`
      Creates a database in Milvus.
      Specified by:
        `createDatabase` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreateDatabaseParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### listDatabases

          public R<io.milvus.grpc.ListDatabasesResponse> listDatabases()

      Description copied from interface: `MilvusClient`
      List databases. Note that this method list all database in the cluster.
      Specified by:
        `listDatabases` in interface `MilvusClient`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### dropDatabase

          public R<RpcStatus> dropDatabase(DropDatabaseParam requestParam)

      Description copied from interface: `MilvusClient`
      Drops a database. Note that this method drops all data in the database.
      Specified by:
        `dropDatabase` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DropDatabaseParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### alterDatabase

          public R<RpcStatus> alterDatabase(AlterDatabaseParam requestParam)

      Description copied from interface: `MilvusClient`
      Alter database with key value pair. (Available from Milvus v2.4.4)
      Specified by:
        `alterDatabase` in interface `MilvusClient`
      Parameters:
        `requestParam` - `AlterDatabaseParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### describeDatabase

          public R<io.milvus.grpc.DescribeDatabaseResponse> describeDatabase(DescribeDatabaseParam requestParam)

      Description copied from interface: `MilvusClient`
      Show detail of database base, such as replica number and resource groups. (Available from Milvus v2.4.4)
      Specified by:
        `describeDatabase` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DescribeDatabaseParam`
      Returns:
        {status:result code, data:DescribeDatabaseResponse{replica_number,resource_groups}}

    - #### createCollection

          public R<RpcStatus> createCollection(@NonNull
                                               @NonNull CreateCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      Creates a collection in Milvus.
      Specified by:
        `createCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreateCollectionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### dropCollection

          public R<RpcStatus> dropCollection(@NonNull
                                             @NonNull DropCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      Drops a collection. Note that this method drops all data in the collection.
      Specified by:
        `dropCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DropCollectionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### loadCollection

          public R<RpcStatus> loadCollection(@NonNull
                                             @NonNull LoadCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      Loads a collection to memory before search or query.
      Specified by:
        `loadCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `LoadCollectionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### releaseCollection

          public R<RpcStatus> releaseCollection(@NonNull
                                                @NonNull ReleaseCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      Releases a collection from memory to reduce memory usage. Note that you cannot search while the corresponding collection is released from memory.
      Specified by:
        `releaseCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ReleaseCollectionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### renameCollection

          public R<RpcStatus> renameCollection(RenameCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      rename a collection
      Specified by:
        `renameCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `RenameCollectionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### describeCollection

          public R<io.milvus.grpc.DescribeCollectionResponse> describeCollection(@NonNull
                                                                                 @NonNull DescribeCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      Shows the details of a collection, e.g. name, schema.
      Specified by:
        `describeCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DescribeCollectionParam`
      Returns:
        {status:result code, data:DescribeCollectionResponse{schema,collectionID}}

    - #### getCollectionStatistics

          public R<io.milvus.grpc.GetCollectionStatisticsResponse> getCollectionStatistics(@NonNull
                                                                                           @NonNull GetCollectionStatisticsParam requestParam)

      Description copied from interface: `MilvusClient`
      Shows the statistics information of a collection.
      Specified by:
        `getCollectionStatistics` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetCollectionStatisticsParam`
      Returns:
        {status:result code, data: GetCollectionStatisticsResponse{status,stats}}

    - #### showCollections

          public R<io.milvus.grpc.ShowCollectionsResponse> showCollections(@NonNull
                                                                           @NonNull ShowCollectionsParam requestParam)

      Description copied from interface: `MilvusClient`
      Lists all collections or gets collection loading status.
      Specified by:
        `showCollections` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ShowCollectionsParam`
      Returns:
        {status:result code, data: ShowCollectionsResponse{status,collection_names,collection_ids,created_timestamps,created_utc_timestamps}}

    - #### alterCollection

          public R<RpcStatus> alterCollection(AlterCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      Alter collection with key-value properties.
      Specified by:
        `alterCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `AlterCollectionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### flush

          public R<io.milvus.grpc.FlushResponse> flush(@NonNull
                                                       @NonNull FlushParam requestParam)

      Flush insert buffer into storage. To make sure the buffer persisted successfully, it calls GetFlushState() to check related segments state.
      Specified by:
        `flush` in interface `MilvusClient`
      Parameters:
        `requestParam` - `FlushParam`
      Returns:
        {status:result code,data: FlushResponse{flush segment ids}}

    - #### flushAll

          public R<io.milvus.grpc.FlushAllResponse> flushAll(boolean syncFlushAll,
                                                             long syncFlushAllWaitingInterval,
                                                             long syncFlushAllTimeout)

      Flush all collections. All insertions, deletions, and upserts before `flushAll` will be synced.
      Specified by:
        `flushAll` in interface `MilvusClient`
      Parameters:
        `syncFlushAll` - {flushAll synchronously or asynchronously}
        `syncFlushAllWaitingInterval` - {wait intervel when flushAll synchronously}
        `syncFlushAllTimeout` - {timeout when flushAll synchronously}
      Returns:
        {status:result code,data: FlushAllResponse{flushAllTs}}

    - #### createPartition

          public R<RpcStatus> createPartition(@NonNull
                                              @NonNull CreatePartitionParam requestParam)

      Description copied from interface: `MilvusClient`
      Creates a partition in the specified collection.
      Specified by:
        `createPartition` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreatePartitionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### dropPartition

          public R<RpcStatus> dropPartition(@NonNull
                                            @NonNull DropPartitionParam requestParam)

      Description copied from interface: `MilvusClient`
      Drops a partition. Note that this method drops all data in this partition and the _default partition cannot be dropped.
      Specified by:
        `dropPartition` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DropPartitionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### hasPartition

          public R<java.lang.Boolean> hasPartition(@NonNull
                                                   @NonNull HasPartitionParam requestParam)

      Description copied from interface: `MilvusClient`
      Checks if a partition exists in the specified collection.
      Specified by:
        `hasPartition` in interface `MilvusClient`
      Parameters:
        `requestParam` - `HasPartitionParam`
      Returns:
        {status:result code, data: boolean, whether if has collection or not}

    - #### loadPartitions

          public R<RpcStatus> loadPartitions(@NonNull
                                             @NonNull LoadPartitionsParam requestParam)

      Description copied from interface: `MilvusClient`
      Loads a partition into memory.
      Specified by:
        `loadPartitions` in interface `MilvusClient`
      Parameters:
        `requestParam` - `LoadPartitionsParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### releasePartitions

          public R<RpcStatus> releasePartitions(@NonNull
                                                @NonNull ReleasePartitionsParam requestParam)

      Description copied from interface: `MilvusClient`
      Releases a partition from memory.
      Specified by:
        `releasePartitions` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ReleasePartitionsParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### getPartitionStatistics

          public R<io.milvus.grpc.GetPartitionStatisticsResponse> getPartitionStatistics(@NonNull
                                                                                         @NonNull GetPartitionStatisticsParam requestParam)

      Description copied from interface: `MilvusClient`
      Shows the statistics information of a partition.
      Specified by:
        `getPartitionStatistics` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetPartitionStatisticsParam`
      Returns:
        {status:result code,data:GetPartitionStatisticsResponse{status,stats}}

    - #### showPartitions

          public R<io.milvus.grpc.ShowPartitionsResponse> showPartitions(@NonNull
                                                                         @NonNull ShowPartitionsParam requestParam)

      Description copied from interface: `MilvusClient`
      Shows all partitions in the specified collection.
      Specified by:
        `showPartitions` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ShowPartitionsParam`
      Returns:
        {status:result code, data:ShowPartitionsResponse{partition_names,partitionIDs,created_timestamps,created_utc_timestamps}}

    - #### createAlias

          public R<RpcStatus> createAlias(@NonNull
                                          @NonNull CreateAliasParam requestParam)

      Description copied from interface: `MilvusClient`
      Creates an alias for a collection. Alias can be used in search or query to replace the collection name
      Specified by:
        `createAlias` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreateAliasParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### dropAlias

          public R<RpcStatus> dropAlias(@NonNull
                                        @NonNull DropAliasParam requestParam)

      Description copied from interface: `MilvusClient`
      Drops an alias for the specified collection.
      Specified by:
        `dropAlias` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DropAliasParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### alterAlias

          public R<RpcStatus> alterAlias(@NonNull
                                         @NonNull AlterAliasParam requestParam)

      Description copied from interface: `MilvusClient`
      Alters alias from a collection to another.
      Specified by:
        `alterAlias` in interface `MilvusClient`
      Parameters:
        `requestParam` - `AlterAliasParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### listAliases

          public R<io.milvus.grpc.ListAliasesResponse> listAliases(ListAliasesParam requestParam)

      Description copied from interface: `MilvusClient`
      List all alias for a collection.
      Specified by:
        `listAliases` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ListAliasesParam`
      Returns:
        {status:result code, data:ListAliasesResponse{status, aliases}}

    - #### createIndex

          public R<RpcStatus> createIndex(@NonNull
                                          @NonNull CreateIndexParam requestParam)

      Description copied from interface: `MilvusClient`
      Creates an index on a vector field in the specified collection. Note that index building is an async progress.
      Specified by:
        `createIndex` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreateIndexParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### dropIndex

          public R<RpcStatus> dropIndex(@NonNull
                                        @NonNull DropIndexParam requestParam)

      Description copied from interface: `MilvusClient`
      Drops the index on a vector field in the specified collection.
      Specified by:
        `dropIndex` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DropIndexParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### describeIndex

          public R<io.milvus.grpc.DescribeIndexResponse> describeIndex(@NonNull
                                                                       @NonNull DescribeIndexParam requestParam)

      Description copied from interface: `MilvusClient`
      Shows the information of the specified index. Current release of Milvus only supports showing latest built index.
      Specified by:
        `describeIndex` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DescribeIndexParam`
      Returns:
        {status:result code, data:DescribeIndexResponse{status,index_descriptions}}

    - #### getIndexState

          @Deprecated
          public R<io.milvus.grpc.GetIndexStateResponse> getIndexState(@NonNull
                                                                                   @NonNull GetIndexStateParam requestParam)

      Deprecated.
      Description copied from interface: `MilvusClient`
      Shows the index building state(in-progress/finished/failed), and the reason for failure (if any).
      Specified by:
        `getIndexState` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetIndexStateParam`
      Returns:
        {status:result code, data:GetIndexStateResponse{status,state}}

    - #### getIndexBuildProgress

          @Deprecated
          public R<io.milvus.grpc.GetIndexBuildProgressResponse> getIndexBuildProgress(@NonNull
                                                                                                   @NonNull GetIndexBuildProgressParam requestParam)

      Deprecated.
      Description copied from interface: `MilvusClient`
      Shows the index building progress, such as how many rows are indexed.
      Specified by:
        `getIndexBuildProgress` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetIndexBuildProgressParam`
      Returns:
        {status:result code, data:GetIndexBuildProgressResponse{status,indexed_rows}}

    - #### alterIndex

          public R<RpcStatus> alterIndex(AlterIndexParam requestParam)

      Description copied from interface: `MilvusClient`
      Alter index with key value properties.
      Specified by:
        `alterIndex` in interface `MilvusClient`
      Parameters:
        `requestParam` - `AlterIndexParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### delete

          public R<io.milvus.grpc.MutationResult> delete(@NonNull
                                                         @NonNull DeleteParam requestParam)

      Description copied from interface: `MilvusClient`
      Deletes entity(s) based on primary key(s) filtered by boolean expression. Current release of Milvus only supports expression in the format "pk_field in [1, 2, ...]"
      Specified by:
        `delete` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DeleteParam`
      Returns:
        {status:result code, data: MutationResult{delete results}}

    - #### insert

          public R<io.milvus.grpc.MutationResult> insert(@NonNull
                                                         @NonNull InsertParam requestParam)

      Description copied from interface: `MilvusClient`
      Inserts entities into a specified collection . Note that you don't need to input primary key field if auto_id is enabled.
      Specified by:
        `insert` in interface `MilvusClient`
      Parameters:
        `requestParam` - `InsertParam`
      Returns:
        {status:result code, data: MutationResult{insert results}}

    - #### insertAsync

          public com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.MutationResult>> insertAsync(InsertParam requestParam)

      Description copied from interface: `MilvusClient`
      Inserts entities into a specified collection asynchronously. Note that you don't need to input primary key field if auto_id is enabled.
      Specified by:
        `insertAsync` in interface `MilvusClient`
      Parameters:
        `requestParam` - `InsertParam`
      Returns:
        a `ListenableFuture` object which holds the object {status:result code, data: MutationResult{insert results}}

    - #### upsert

          public R<io.milvus.grpc.MutationResult> upsert(UpsertParam requestParam)

      Description copied from interface: `MilvusClient`
      Insert new entities into a specified collection, replace them if the entities already exist.
      Specified by:
        `upsert` in interface `MilvusClient`
      Parameters:
        `requestParam` - `UpsertParam`
      Returns:
        {status:result code, data: MutationResult{insert results}}

    - #### upsertAsync

          public com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.MutationResult>> upsertAsync(UpsertParam requestParam)

      Description copied from interface: `MilvusClient`
      Insert new entities into a specified collection asynchronously, replace them if the entities already exist.
      Specified by:
        `upsertAsync` in interface `MilvusClient`
      Parameters:
        `requestParam` - `UpsertParam`
      Returns:
        a `ListenableFuture` object which holds the object {status:result code, data: MutationResult{insert results}}

    - #### search

          public R<io.milvus.grpc.SearchResults> search(@NonNull
                                                        @NonNull SearchParam requestParam)

      Description copied from interface: `MilvusClient`
      Conducts ANN search on a vector field. Use expression to do filtering before search.
      Specified by:
        `search` in interface `MilvusClient`
      Parameters:
        `requestParam` - `SearchParam`
      Returns:
        {status:result code, data: SearchResults{topK results}}

    - #### searchAsync

          public com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.SearchResults>> searchAsync(SearchParam requestParam)

      Description copied from interface: `MilvusClient`
      Conducts ANN search on a vector field asynchronously. Use expression to do filtering before search.
      Specified by:
        `searchAsync` in interface `MilvusClient`
      Parameters:
        `requestParam` - `SearchParam`
      Returns:
        a `ListenableFuture` object which holds the object {status:result code, data: SearchResults{topK results}}

    - #### hybridSearch

          public R<io.milvus.grpc.SearchResults> hybridSearch(HybridSearchParam requestParam)

      Description copied from interface: `MilvusClient`
      Conducts multi vector similarity search with a ranker for rearrangement.
      Specified by:
        `hybridSearch` in interface `MilvusClient`
      Parameters:
        `requestParam` - `HybridSearchParam`
      Returns:
        {status:result code, data: SearchResults{topK results}}

    - #### hybridSearchAsync

          public com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.SearchResults>> hybridSearchAsync(HybridSearchParam requestParam)

      Description copied from interface: `MilvusClient`
      Conducts multi vector similarity search asynchronously with a ranker for rearrangement.
      Specified by:
        `hybridSearchAsync` in interface `MilvusClient`
      Parameters:
        `requestParam` - `HybridSearchParam`
      Returns:
        a `ListenableFuture` object which holds the object {status:result code, data: SearchResults{topK results}}

    - #### query

          public R<io.milvus.grpc.QueryResults> query(@NonNull
                                                      @NonNull QueryParam requestParam)

      Description copied from interface: `MilvusClient`
      Queries entity(s) based on scalar field(s) filtered by boolean expression. Note that the order of the returned entities cannot be guaranteed.
      Specified by:
        `query` in interface `MilvusClient`
      Parameters:
        `requestParam` - `QueryParam`
      Returns:
        {status:result code,data: QueryResults{filter results}}

    - #### queryAsync

          public com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.QueryResults>> queryAsync(QueryParam requestParam)

      Description copied from interface: `MilvusClient`
      Queries entity(s) asynchronously based on scalar field(s) filtered by boolean expression. Note that the order of the returned entities cannot be guaranteed.
      Specified by:
        `queryAsync` in interface `MilvusClient`
      Parameters:
        `requestParam` - `QueryParam`
      Returns:
        {status:result code,data: QueryResults{filter results}}

    - #### getMetrics

          public R<io.milvus.grpc.GetMetricsResponse> getMetrics(@NonNull
                                                                 @NonNull GetMetricsParam requestParam)

      Description copied from interface: `MilvusClient`
      Gets the runtime metrics information of Milvus, returns the result in .json format.
      Specified by:
        `getMetrics` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetMetricsParam`
      Returns:
        {status:result code, data:GetMetricsResponse{status,metrics}}

    - #### getFlushState

          public R<io.milvus.grpc.GetFlushStateResponse> getFlushState(@NonNull
                                                                       @NonNull GetFlushStateParam requestParam)

      Description copied from interface: `MilvusClient`
      Get flush state of specified collection.
      Specified by:
        `getFlushState` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetFlushStateParam`
      Returns:
        {status:result code, data:GetMetricsResponse{status,metrics}}

    - #### getFlushAllState

          public R<io.milvus.grpc.GetFlushAllStateResponse> getFlushAllState(GetFlushAllStateParam requestParam)

      Description copied from interface: `MilvusClient`
      Get flush state of all segments.
      Specified by:
        `getFlushAllState` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetFlushAllStateParam`
      Returns:
        {status:result code, data:GetMetricsResponse{status,metrics}}

    - #### getPersistentSegmentInfo

          public R<io.milvus.grpc.GetPersistentSegmentInfoResponse> getPersistentSegmentInfo(@NonNull
                                                                                             @NonNull GetPersistentSegmentInfoParam requestParam)

      Description copied from interface: `MilvusClient`
      Gets the information of persistent segments from data node, including row count, persistence state(growing or flushed), etc.
      Specified by:
        `getPersistentSegmentInfo` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetPersistentSegmentInfoParam`
      Returns:
        {status:result code, data:GetPersistentSegmentInfoResponse{status,info}}

    - #### getQuerySegmentInfo

          public R<io.milvus.grpc.GetQuerySegmentInfoResponse> getQuerySegmentInfo(@NonNull
                                                                                   @NonNull GetQuerySegmentInfoParam requestParam)

      Description copied from interface: `MilvusClient`
      Gets the query information of segments in a collection from query node, including row count, memory usage size, index name, etc.
      Specified by:
        `getQuerySegmentInfo` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetQuerySegmentInfoParam`
      Returns:
        {status:result code, data:GetQuerySegmentInfoResponse{status,info}}

    - #### getReplicas

          public R<io.milvus.grpc.GetReplicasResponse> getReplicas(GetReplicasParam requestParam)

      Description copied from interface: `MilvusClient`
      Returns the collection's replica information
      Specified by:
        `getReplicas` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetReplicasParam`
      Returns:
        {status:result code, data:GetReplicasResponse{status,info}}

    - #### loadBalance

          public R<RpcStatus> loadBalance(LoadBalanceParam requestParam)

      Description copied from interface: `MilvusClient`
      Moves segment from a query node to another to keep the load balanced.
      Specified by:
        `loadBalance` in interface `MilvusClient`
      Parameters:
        `requestParam` - `LoadBalanceParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### getCompactionState

          public R<io.milvus.grpc.GetCompactionStateResponse> getCompactionState(GetCompactionStateParam requestParam)

      Description copied from interface: `MilvusClient`
      Gets the compaction state by id.
      Specified by:
        `getCompactionState` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetCompactionStateParam`
      Returns:
        {status:result code, data:GetCompactionStateResponse{status,info}}

    - #### manualCompact

          public R<io.milvus.grpc.ManualCompactionResponse> manualCompact(ManualCompactParam requestParam)

      Description copied from interface: `MilvusClient`
      Performs a manual compaction.
      Specified by:
        `manualCompact` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ManualCompactParam`
      Returns:
        {status:result code, data:ManualCompactionResponse{status,info}}

    - #### getCompactionStateWithPlans

          public R<io.milvus.grpc.GetCompactionPlansResponse> getCompactionStateWithPlans(GetCompactionPlansParam requestParam)

      Description copied from interface: `MilvusClient`
      Gets compaction state with its plan.
      Specified by:
        `getCompactionStateWithPlans` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetCompactionPlansParam`
      Returns:
        {status:result code, data:GetCompactionPlansResponse{status,info}}

    - #### createCredential

          public R<RpcStatus> createCredential(CreateCredentialParam requestParam)

      Description copied from interface: `MilvusClient`
      Create credential using the given user and password.
      Specified by:
        `createCredential` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreateCredentialParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### updateCredential

          public R<RpcStatus> updateCredential(UpdateCredentialParam requestParam)

      Description copied from interface: `MilvusClient`
      Update credential using the given user and password. You must provide the original password to check if the operation is valid. Note: after this operation, client won't change the related header of this connection. So if you update credential for this connection, the connection may be invalid.
      Specified by:
        `updateCredential` in interface `MilvusClient`
      Parameters:
        `requestParam` - `UpdateCredentialParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### deleteCredential

          public R<RpcStatus> deleteCredential(DeleteCredentialParam requestParam)

      Description copied from interface: `MilvusClient`
      Delete credential corresponding to the user.
      Specified by:
        `deleteCredential` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DeleteCredentialParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### listCredUsers

          public R<io.milvus.grpc.ListCredUsersResponse> listCredUsers(ListCredUsersParam requestParam)

      Description copied from interface: `MilvusClient`
      List all user names.
      Specified by:
        `listCredUsers` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ListCredUsersParam`
      Returns:
        {status:result code, data:ListCredUsersResponse{status,info}}

    - #### addUserToRole

          public R<RpcStatus> addUserToRole(AddUserToRoleParam requestParam)

      Description copied from interface: `MilvusClient`
      The user will get permissions that the role are allowed to perform operations.
      Specified by:
        `addUserToRole` in interface `MilvusClient`
      Parameters:
        `requestParam` - `AddUserToRoleParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### removeUserFromRole

          public R<RpcStatus> removeUserFromRole(RemoveUserFromRoleParam requestParam)

      Description copied from interface: `MilvusClient`
      The user will remove permissions that the role are allowed to perform operations.
      Specified by:
        `removeUserFromRole` in interface `MilvusClient`
      Parameters:
        `requestParam` - `AddUserToRoleParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### createRole

          public R<RpcStatus> createRole(CreateRoleParam requestParam)

      Description copied from interface: `MilvusClient`
      It will success if the role isn't existed, otherwise fail.
      Specified by:
        `createRole` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreateRoleParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### dropRole

          public R<RpcStatus> dropRole(DropRoleParam requestParam)

      Description copied from interface: `MilvusClient`
      It will success if the role is existed, otherwise fail.
      Specified by:
        `dropRole` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DropRoleParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### selectRole

          public R<io.milvus.grpc.SelectRoleResponse> selectRole(SelectRoleParam requestParam)

      Description copied from interface: `MilvusClient`
      Get all users who are added to the role.
      Specified by:
        `selectRole` in interface `MilvusClient`
      Parameters:
        `requestParam` - `SelectRoleParam`
      Returns:
        {status:result code, data:SelectRoleResponse{status,info}}

    - #### selectUser

          public R<io.milvus.grpc.SelectUserResponse> selectUser(SelectUserParam requestParam)

      Description copied from interface: `MilvusClient`
      Get all roles the user has.
      Specified by:
        `selectUser` in interface `MilvusClient`
      Parameters:
        `requestParam` - `SelectUserParam`
      Returns:
        {status:result code, data:SelectUserResponse{status,info}}

    - #### grantRolePrivilege

          public R<RpcStatus> grantRolePrivilege(GrantRolePrivilegeParam requestParam)

      Description copied from interface: `MilvusClient`
      Grant Role Privilege.
      Specified by:
        `grantRolePrivilege` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GrantRolePrivilegeParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### revokeRolePrivilege

          public R<RpcStatus> revokeRolePrivilege(RevokeRolePrivilegeParam requestParam)

      Description copied from interface: `MilvusClient`
      Revoke Role Privilege.
      Specified by:
        `revokeRolePrivilege` in interface `MilvusClient`
      Parameters:
        `requestParam` - `RevokeRolePrivilegeParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### selectGrantForRole

          public R<io.milvus.grpc.SelectGrantResponse> selectGrantForRole(SelectGrantForRoleParam requestParam)

      Description copied from interface: `MilvusClient`
      List a grant info for the role and the specific object
      Specified by:
        `selectGrantForRole` in interface `MilvusClient`
      Parameters:
        `requestParam` - `SelectGrantForRoleParam`
      Returns:
        {status:result code, data:SelectRoleResponse{status,info}}

    - #### selectGrantForRoleAndObject

          public R<io.milvus.grpc.SelectGrantResponse> selectGrantForRoleAndObject(SelectGrantForRoleAndObjectParam requestParam)

      Description copied from interface: `MilvusClient`
      List a grant info for the role
      Specified by:
        `selectGrantForRoleAndObject` in interface `MilvusClient`
      Parameters:
        `requestParam` - `SelectGrantForRoleAndObjectParam`
      Returns:
        {status:result code, data:SelectRoleResponse{status,info}}

    - #### bulkInsert

          public R<io.milvus.grpc.ImportResponse> bulkInsert(BulkInsertParam requestParam)

      Description copied from interface: `MilvusClient`
      Import data from external files, currently support JSON format
      Specified by:
        `bulkInsert` in interface `MilvusClient`
      Parameters:
        `requestParam` - `BulkInsertParam`
      Returns:
        {status:result code, data:ImportResponse{status,info}}

    - #### getBulkInsertState

          public R<io.milvus.grpc.GetImportStateResponse> getBulkInsertState(GetBulkInsertStateParam requestParam)

      Description copied from interface: `MilvusClient`
      Get state of bulk insert task
      Specified by:
        `getBulkInsertState` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetBulkInsertStateParam`
      Returns:
        {status:result code, data:GetImportStateResponse{status,info}}

    - #### listBulkInsertTasks

          public R<io.milvus.grpc.ListImportTasksResponse> listBulkInsertTasks(ListBulkInsertTasksParam requestParam)

      Description copied from interface: `MilvusClient`
      List bulk insert tasks
      Specified by:
        `listBulkInsertTasks` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ListBulkInsertTasksParam`
      Returns:
        {status:result code, data:ListImportTasksResponse{status,info}}

    - #### getLoadingProgress

          public R<io.milvus.grpc.GetLoadingProgressResponse> getLoadingProgress(GetLoadingProgressParam requestParam)

      Description copied from interface: `MilvusClient`
      Get collection loading progress
      Specified by:
        `getLoadingProgress` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetLoadingProgressParam`
      Returns:
        {status:result code, data:GetLoadingProgressResponse{status}}

    - #### getLoadState

          public R<io.milvus.grpc.GetLoadStateResponse> getLoadState(GetLoadStateParam requestParam)

      Description copied from interface: `MilvusClient`
      Get collection loading state
      Specified by:
        `getLoadState` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetLoadStateParam`
      Returns:
        {status:result code, data:GetLoadStateResponse{status}}

    - #### checkHealth

          public R<io.milvus.grpc.CheckHealthResponse> checkHealth()

      Description copied from interface: `MilvusClient`
      Check server health
      Specified by:
        `checkHealth` in interface `MilvusClient`
      Returns:
        {status:result code, data:CheckHealthResponse{status,info}}

    - #### getVersion

          public R<io.milvus.grpc.GetVersionResponse> getVersion()

      Description copied from interface: `MilvusClient`
      Get server version
      Specified by:
        `getVersion` in interface `MilvusClient`
      Returns:
        {status:result code, data:GetVersionResponse{status,info}}

    - #### createResourceGroup

          public R<RpcStatus> createResourceGroup(CreateResourceGroupParam requestParam)

      Description copied from interface: `MilvusClient`
      Create a resource group.
      Specified by:
        `createResourceGroup` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreateResourceGroupParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### dropResourceGroup

          public R<RpcStatus> dropResourceGroup(DropResourceGroupParam requestParam)

      Description copied from interface: `MilvusClient`
      Drop a resource group.
      Specified by:
        `dropResourceGroup` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DropResourceGroupParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### listResourceGroups

          public R<io.milvus.grpc.ListResourceGroupsResponse> listResourceGroups(ListResourceGroupsParam requestParam)

      Description copied from interface: `MilvusClient`
      List resource groups.
      Specified by:
        `listResourceGroups` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ListResourceGroupsParam`
      Returns:
        {status:result code, data:ListResourceGroupsResponse{status}}

    - #### describeResourceGroup

          public R<io.milvus.grpc.DescribeResourceGroupResponse> describeResourceGroup(DescribeResourceGroupParam requestParam)

      Description copied from interface: `MilvusClient`
      Describe a resource group.
      Specified by:
        `describeResourceGroup` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DescribeResourceGroupParam`
      Returns:
        {status:result code, data:DescribeResourceGroupResponse{status}}

    - #### transferNode

          public R<RpcStatus> transferNode(TransferNodeParam requestParam)

      Description copied from interface: `MilvusClient`
      Transfer a query node from source resource group to target resource_group.
      Specified by:
        `transferNode` in interface `MilvusClient`
      Parameters:
        `requestParam` - `TransferNodeParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### transferReplica

          public R<RpcStatus> transferReplica(TransferReplicaParam requestParam)

      Description copied from interface: `MilvusClient`
      Transfer a replica from source resource group to target resource_group.
      Specified by:
        `transferReplica` in interface `MilvusClient`
      Parameters:
        `requestParam` - `TransferReplicaParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### updateResourceGroups

          public R<RpcStatus> updateResourceGroups(UpdateResourceGroupsParam requestParam)

      Description copied from interface: `MilvusClient`
      Update resource groups.
      Specified by:
        `updateResourceGroups` in interface `MilvusClient`
      Parameters:
        `requestParam` - `UpdateResourceGroupsParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### createCollection

          public R<RpcStatus> createCollection(CreateSimpleCollectionParam requestParam)

      Description copied from interface: `MilvusClient`
      Creates a collection in Milvus.
      Specified by:
        `createCollection` in interface `MilvusClient`
      Parameters:
        `requestParam` - `CreateSimpleCollectionParam`
      Returns:
        {status:result code, data:RpcStatus{msg: result message}}

    - #### listCollections

          public R<ListCollectionsResponse> listCollections(ListCollectionsParam requestParam)

      Description copied from interface: `MilvusClient`
      Lists all collections
      Specified by:
        `listCollections` in interface `MilvusClient`
      Parameters:
        `requestParam` - `ListCollectionsParam`
      Returns:
        {status:result code, data: ListCollectionsResponse{collection_names}}

    - #### insert

          public R<InsertResponse> insert(InsertRowsParam requestParam)

      Description copied from interface: `MilvusClient`
      Inserts rows data into a specified collection . Note that you don't need to input primary key field if auto_id is enabled.
      Specified by:
        `insert` in interface `MilvusClient`
      Parameters:
        `requestParam` - `InsertRowsParam`
      Returns:
        {status:result code, data: MutationResult{insert results}}

    - #### delete

          public R<DeleteResponse> delete(DeleteIdsParam requestParam)

      Description copied from interface: `MilvusClient`
      Deletes entity(s) based on the value of primary key.
      Specified by:
        `delete` in interface `MilvusClient`
      Parameters:
        `requestParam` - `DeleteIdsParam`
      Returns:
        {status:result code, data: MutationResult{delete results}}

    - #### get

          public R<GetResponse> get(GetIdsParam requestParam)

      Description copied from interface: `MilvusClient`
      Get entity(s) based on the value of primary key.
      Specified by:
        `get` in interface `MilvusClient`
      Parameters:
        `requestParam` - `GetIdsParam`
      Returns:
        {status:result code, data: QueryResults{query results}}

    - #### query

          public R<QueryResponse> query(QuerySimpleParam requestParam)

      Description copied from interface: `MilvusClient`
      Queries entity(s) based on scalar field(s) filtered by boolean expression. Note that the order of the returned entities cannot be guaranteed.
      Specified by:
        `query` in interface `MilvusClient`
      Parameters:
        `requestParam` - `QuerySimpleParam`
      Returns:
        {status:result code,data: QueryResults{filter results}}

    - #### search

          public R<SearchResponse> search(SearchSimpleParam requestParam)

      Description copied from interface: `MilvusClient`
      Conducts ANN search on a vector field. Use expression to do filtering before search.
      Specified by:
        `search` in interface `MilvusClient`
      Parameters:
        `requestParam` - `SearchSimpleParam`
      Returns:
        {status:result code, data: SearchResults{topK results}}

    - #### queryIterator

          public R<QueryIterator> queryIterator(QueryIteratorParam requestParam)

      Description copied from interface: `MilvusClient`
      Get queryIterator based on scalar field(s) filtered by boolean expression. Note that the order of the returned entities cannot be guaranteed.
      Specified by:
        `queryIterator` in interface `MilvusClient`
      Parameters:
        `requestParam` - `QueryIteratorParam`
      Returns:
        {status:result code,data: QueryIterator}

    - #### searchIterator

          public R<SearchIterator> searchIterator(SearchIteratorParam requestParam)

      Description copied from interface: `MilvusClient`
      Get searchIterator based on a vector field. Use expression to do filtering before search.
      Specified by:
        `searchIterator` in interface `MilvusClient`
      Parameters:
        `requestParam` - `SearchIteratorParam`
      Returns:
        {status:result code, data: SearchIterator}