Package io.milvus.client

Interface MilvusClient

    • Method Detail

      • withTimeout

        MilvusClient withTimeout​(long timeout,
                         java.util.concurrent.TimeUnit timeoutUnit)
        Timeout setting for rpc call.
        Parameters:
        timeout - set time waiting for a rpc call.
        timeoutUnit - time unit

      • withRetry

        MilvusClient withRetry​(int retryTimes)
        Number of retry attempts.
        Parameters:
        retryTimes - number of retry attempts.

      • withRetryInterval

        MilvusClient withRetryInterval​(long interval,
                               java.util.concurrent.TimeUnit timeUnit)
        Time interval between retry attempts. Default value is 500ms.
        Parameters:
        interval - time interval between retry attempts.
        timeUnit - time unit

      • close

        default void close()
        Disconnects from a Milvus server with timeout of 1 minute

      • close

        void close​(long maxWaitSeconds)
    throws java.lang.InterruptedException
        Disconnects from a Milvus server with configurable timeout.
        Parameters:
        maxWaitSeconds - timeout unit: second
        Throws:
        java.lang.InterruptedException

      • hasCollection

        R<java.lang.Boolean> hasCollection​(HasCollectionParam requestParam)
        Checks if a collection exists.
        Parameters:
        requestParam - HasCollectionParam
        Returns:
        {status:result code, data: boolean, whether if has collection or not}

      • dropDatabase

        R<RpcStatus> dropDatabase​(DropDatabaseParam requestParam)
        Drops a database. Note that this method drops all data in the database.
        Parameters:
        requestParam - DropDatabaseParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • listDatabases

        R<io.milvus.grpc.ListDatabasesResponse> listDatabases()
        List databases. Note that this method list all database in the cluster.
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • dropCollection

        R<RpcStatus> dropCollection​(DropCollectionParam requestParam)
        Drops a collection. Note that this method drops all data in the collection.
        Parameters:
        requestParam - DropCollectionParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • loadCollection

        R<RpcStatus> loadCollection​(LoadCollectionParam requestParam)
        Loads a collection to memory before search or query.
        Parameters:
        requestParam - LoadCollectionParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • releaseCollection

        R<RpcStatus> releaseCollection​(ReleaseCollectionParam requestParam)
        Releases a collection from memory to reduce memory usage. Note that you cannot search while the corresponding collection is released from memory.
        Parameters:
        requestParam - ReleaseCollectionParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • describeCollection

        R<io.milvus.grpc.DescribeCollectionResponse> describeCollection​(DescribeCollectionParam requestParam)
        Shows the details of a collection, e.g. name, schema.
        Parameters:
        requestParam - DescribeCollectionParam
        Returns:
        {status:result code, data:DescribeCollectionResponse{schema,collectionID}}

      • getCollectionStatistics

        R<io.milvus.grpc.GetCollectionStatisticsResponse> getCollectionStatistics​(GetCollectionStatisticsParam requestParam)
        Shows the statistics information of a collection.
        Parameters:
        requestParam - GetCollectionStatisticsParam
        Returns:
        {status:result code, data: GetCollectionStatisticsResponse{status,stats}}

      • showCollections

        R<io.milvus.grpc.ShowCollectionsResponse> showCollections​(ShowCollectionsParam requestParam)
        Lists all collections or gets collection loading status.
        Parameters:
        requestParam - ShowCollectionsParam
        Returns:
        {status:result code, data: ShowCollectionsResponse{status,collection_names,collection_ids,created_timestamps,created_utc_timestamps}}

      • alterCollection

        R<RpcStatus> alterCollection​(AlterCollectionParam requestParam)
        Alter collection. Currently, only support setting collection TTL with key `collection.ttl.seconds`
        Parameters:
        requestParam - AlterCollectionParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • flush

        R<io.milvus.grpc.FlushResponse> flush​(FlushParam requestParam)
        Flushes inserted data in buffer into storage.
        Parameters:
        requestParam - FlushParam
        Returns:
        {status:result code,data: FlushResponse{flush segment ids}}

      • flushAll

        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.
        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

        R<RpcStatus> createPartition​(CreatePartitionParam requestParam)
        Creates a partition in the specified collection.
        Parameters:
        requestParam - CreatePartitionParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • dropPartition

        R<RpcStatus> dropPartition​(DropPartitionParam requestParam)
        Drops a partition. Note that this method drops all data in this partition and the _default partition cannot be dropped.
        Parameters:
        requestParam - DropPartitionParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • hasPartition

        R<java.lang.Boolean> hasPartition​(HasPartitionParam requestParam)
        Checks if a partition exists in the specified collection.
        Parameters:
        requestParam - HasPartitionParam
        Returns:
        {status:result code, data: boolean, whether if has collection or not}

      • getPartitionStatistics

        R<io.milvus.grpc.GetPartitionStatisticsResponse> getPartitionStatistics​(GetPartitionStatisticsParam requestParam)
        Shows the statistics information of a partition.
        Parameters:
        requestParam - GetPartitionStatisticsParam
        Returns:
        {status:result code,data:GetPartitionStatisticsResponse{status,stats}}

      • showPartitions

        R<io.milvus.grpc.ShowPartitionsResponse> showPartitions​(ShowPartitionsParam requestParam)
        Shows all partitions in the specified collection.
        Parameters:
        requestParam - ShowPartitionsParam
        Returns:
        {status:result code, data:ShowPartitionsResponse{partition_names,partitionIDs,created_timestamps,created_utc_timestamps}}

      • createAlias

        R<RpcStatus> createAlias​(CreateAliasParam requestParam)
        Creates an alias for a collection. Alias can be used in search or query to replace the collection name
        Parameters:
        requestParam - CreateAliasParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • dropAlias

        R<RpcStatus> dropAlias​(DropAliasParam requestParam)
        Drops an alias for the specified collection.
        Parameters:
        requestParam - DropAliasParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • alterAlias

        R<RpcStatus> alterAlias​(AlterAliasParam requestParam)
        Alters alias from a collection to another.
        Parameters:
        requestParam - AlterAliasParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • createIndex

        R<RpcStatus> createIndex​(CreateIndexParam requestParam)
        Creates an index on a vector field in the specified collection. Note that index building is an async progress.
        Parameters:
        requestParam - CreateIndexParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • dropIndex

        R<RpcStatus> dropIndex​(DropIndexParam requestParam)
        Drops the index on a vector field in the specified collection.
        Parameters:
        requestParam - DropIndexParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • describeIndex

        R<io.milvus.grpc.DescribeIndexResponse> describeIndex​(DescribeIndexParam requestParam)
        Shows the information of the specified index. Current release of Milvus only supports showing latest built index.
        Parameters:
        requestParam - DescribeIndexParam
        Returns:
        {status:result code, data:DescribeIndexResponse{status,index_descriptions}}

      • getIndexState

        R<io.milvus.grpc.GetIndexStateResponse> getIndexState​(GetIndexStateParam requestParam)
        Shows the index building state(in-progress/finished/failed), and the reason for failure (if any).
        Parameters:
        requestParam - GetIndexStateParam
        Returns:
        {status:result code, data:GetIndexStateResponse{status,state}}

      • getIndexBuildProgress

        R<io.milvus.grpc.GetIndexBuildProgressResponse> getIndexBuildProgress​(GetIndexBuildProgressParam requestParam)
        Shows the index building progress, such as how many rows are indexed.
        Parameters:
        requestParam - GetIndexBuildProgressParam
        Returns:
        {status:result code, data:GetIndexBuildProgressResponse{status,indexed_rows}}

      • insert

        R<io.milvus.grpc.MutationResult> insert​(InsertParam requestParam)
        Inserts entities into a specified collection . Note that you don't need to input primary key field if auto_id is enabled.
        Parameters:
        requestParam - InsertParam
        Returns:
        {status:result code, data: MutationResult{insert results}}

      • insertAsync

        com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.MutationResult>> insertAsync​(InsertParam requestParam)
        Inserts entities into a specified collection asynchronously. Note that you don't need to input primary key field if auto_id is enabled.
        Parameters:
        requestParam - InsertParam
        Returns:
        a ListenableFuture object which holds the object {status:result code, data: MutationResult{insert results}}

      • upsert

        R<io.milvus.grpc.MutationResult> upsert​(UpsertParam requestParam)
        Insert new entities into a specified collection, replace them if the entities already exist.
        Parameters:
        requestParam - UpsertParam
        Returns:
        {status:result code, data: MutationResult{insert results}}

      • upsertAsync

        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.
        Parameters:
        requestParam - UpsertParam
        Returns:
        a ListenableFuture object which holds the object {status:result code, data: MutationResult{insert results}}

      • delete

        R<io.milvus.grpc.MutationResult> delete​(DeleteParam requestParam)
        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, ...]"
        Parameters:
        requestParam - DeleteParam
        Returns:
        {status:result code, data: MutationResult{delete results}}

      • search

        R<io.milvus.grpc.SearchResults> search​(SearchParam requestParam)
        Conducts ANN search on a vector field. Use expression to do filtering before search.
        Parameters:
        requestParam - SearchParam
        Returns:
        {status:result code, data: SearchResults{topK results}}

      • searchAsync

        com.google.common.util.concurrent.ListenableFuture<R<io.milvus.grpc.SearchResults>> searchAsync​(SearchParam requestParam)
        Conducts ANN search on a vector field asynchronously. Use expression to do filtering before search.
        Parameters:
        requestParam - SearchParam
        Returns:
        a ListenableFuture object which holds the object {status:result code, data: SearchResults{topK results}}

      • query

        R<io.milvus.grpc.QueryResults> query​(QueryParam requestParam)
        Queries entity(s) based on scalar field(s) filtered by boolean expression. Note that the order of the returned entities cannot be guaranteed.
        Parameters:
        requestParam - QueryParam
        Returns:
        {status:result code,data: QueryResults{filter results}}

      • queryAsync

        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. Note that the order of the returned entities cannot be guaranteed.
        Parameters:
        requestParam - QueryParam
        Returns:
        {status:result code,data: QueryResults{filter results}}

      • getMetrics

        R<io.milvus.grpc.GetMetricsResponse> getMetrics​(GetMetricsParam requestParam)
        Gets the runtime metrics information of Milvus, returns the result in .json format.
        Parameters:
        requestParam - GetMetricsParam
        Returns:
        {status:result code, data:GetMetricsResponse{status,metrics}}

      • getFlushState

        R<io.milvus.grpc.GetFlushStateResponse> getFlushState​(GetFlushStateParam requestParam)
        Get flush state of specified segments.
        Parameters:
        requestParam - GetFlushStateParam
        Returns:
        {status:result code, data:GetMetricsResponse{status,metrics}}

      • getFlushAllState

        R<io.milvus.grpc.GetFlushAllStateResponse> getFlushAllState​(GetFlushAllStateParam requestParam)
        Get flush state of all segments.
        Parameters:
        requestParam - GetFlushAllStateParam
        Returns:
        {status:result code, data:GetMetricsResponse{status,metrics}}

      • getPersistentSegmentInfo

        R<io.milvus.grpc.GetPersistentSegmentInfoResponse> getPersistentSegmentInfo​(GetPersistentSegmentInfoParam requestParam)
        Gets the information of persistent segments from data node, including row count, persistence state(growing or flushed), etc.
        Parameters:
        requestParam - GetPersistentSegmentInfoParam
        Returns:
        {status:result code, data:GetPersistentSegmentInfoResponse{status,info}}

      • getQuerySegmentInfo

        R<io.milvus.grpc.GetQuerySegmentInfoResponse> getQuerySegmentInfo​(GetQuerySegmentInfoParam requestParam)
        Gets the query information of segments in a collection from query node, including row count, memory usage size, index name, etc.
        Parameters:
        requestParam - GetQuerySegmentInfoParam
        Returns:
        {status:result code, data:GetQuerySegmentInfoResponse{status,info}}

      • getReplicas

        R<io.milvus.grpc.GetReplicasResponse> getReplicas​(GetReplicasParam requestParam)
        Returns the collection's replica information
        Parameters:
        requestParam - GetReplicasParam
        Returns:
        {status:result code, data:GetReplicasResponse{status,info}}

      • loadBalance

        R<RpcStatus> loadBalance​(LoadBalanceParam requestParam)
        Moves segment from a query node to another to keep the load balanced.
        Parameters:
        requestParam - LoadBalanceParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • getCompactionState

        R<io.milvus.grpc.GetCompactionStateResponse> getCompactionState​(GetCompactionStateParam requestParam)
        Gets the compaction state by id.
        Parameters:
        requestParam - GetCompactionStateParam
        Returns:
        {status:result code, data:GetCompactionStateResponse{status,info}}

      • manualCompact

        R<io.milvus.grpc.ManualCompactionResponse> manualCompact​(ManualCompactParam requestParam)
        Performs a manual compaction.
        Parameters:
        requestParam - ManualCompactParam
        Returns:
        {status:result code, data:ManualCompactionResponse{status,info}}

      • getCompactionStateWithPlans

        R<io.milvus.grpc.GetCompactionPlansResponse> getCompactionStateWithPlans​(GetCompactionPlansParam requestParam)
        Gets compaction state with its plan.
        Parameters:
        requestParam - GetCompactionPlansParam
        Returns:
        {status:result code, data:GetCompactionPlansResponse{status,info}}

      • updateCredential

        R<RpcStatus> updateCredential​(UpdateCredentialParam requestParam)
        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.
        Parameters:
        requestParam - UpdateCredentialParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • listCredUsers

        R<io.milvus.grpc.ListCredUsersResponse> listCredUsers​(ListCredUsersParam requestParam)
        List all user names.
        Parameters:
        requestParam - ListCredUsersParam
        Returns:
        {status:result code, data:ListCredUsersResponse{status,info}}

      • createRole

        R<RpcStatus> createRole​(CreateRoleParam requestParam)
        It will success if the role isn't existed, otherwise fail.
        Parameters:
        requestParam - CreateRoleParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • dropRole

        R<RpcStatus> dropRole​(DropRoleParam requestParam)
        It will success if the role is existed, otherwise fail.
        Parameters:
        requestParam - DropRoleParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • addUserToRole

        R<RpcStatus> addUserToRole​(AddUserToRoleParam requestParam)
        The user will get permissions that the role are allowed to perform operations.
        Parameters:
        requestParam - AddUserToRoleParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • removeUserFromRole

        R<RpcStatus> removeUserFromRole​(RemoveUserFromRoleParam requestParam)
        The user will remove permissions that the role are allowed to perform operations.
        Parameters:
        requestParam - AddUserToRoleParam
        Returns:
        {status:result code, data:RpcStatus{msg: result message}}

      • selectRole

        R<io.milvus.grpc.SelectRoleResponse> selectRole​(SelectRoleParam requestParam)
        Get all users who are added to the role.
        Parameters:
        requestParam - SelectRoleParam
        Returns:
        {status:result code, data:SelectRoleResponse{status,info}}

      • selectUser

        R<io.milvus.grpc.SelectUserResponse> selectUser​(SelectUserParam requestParam)
        Get all roles the user has.
        Parameters:
        requestParam - SelectUserParam
        Returns:
        {status:result code, data:SelectUserResponse{status,info}}

      • selectGrantForRole

        R<io.milvus.grpc.SelectGrantResponse> selectGrantForRole​(SelectGrantForRoleParam requestParam)
        List a grant info for the role and the specific object
        Parameters:
        requestParam - SelectGrantForRoleParam
        Returns:
        {status:result code, data:SelectRoleResponse{status,info}}

      • bulkInsert

        R<io.milvus.grpc.ImportResponse> bulkInsert​(BulkInsertParam requestParam)
        Import data from external files, currently support JSON format
        Parameters:
        requestParam - BulkInsertParam
        Returns:
        {status:result code, data:ImportResponse{status,info}}

      • getBulkInsertState

        R<io.milvus.grpc.GetImportStateResponse> getBulkInsertState​(GetBulkInsertStateParam requestParam)
        Get state of bulk insert task
        Parameters:
        requestParam - GetBulkInsertStateParam
        Returns:
        {status:result code, data:GetImportStateResponse{status,info}}

      • listBulkInsertTasks

        R<io.milvus.grpc.ListImportTasksResponse> listBulkInsertTasks​(ListBulkInsertTasksParam requestParam)
        List bulk insert tasks
        Parameters:
        requestParam - ListBulkInsertTasksParam
        Returns:
        {status:result code, data:ListImportTasksResponse{status,info}}

      • checkHealth

        R<io.milvus.grpc.CheckHealthResponse> checkHealth()
        Check server health
        Returns:
        {status:result code, data:CheckHealthResponse{status,info}}

      • getVersion

        R<io.milvus.grpc.GetVersionResponse> getVersion()
        Get server version
        Returns:
        {status:result code, data:GetVersionResponse{status,info}}

      • getLoadingProgress

        R<io.milvus.grpc.GetLoadingProgressResponse> getLoadingProgress​(GetLoadingProgressParam requestParam)
        Get collection loading progress
        Parameters:
        requestParam - GetLoadingProgressParam
        Returns:
        {status:result code, data:GetLoadingProgressResponse{status}}

      • getLoadState

        R<io.milvus.grpc.GetLoadStateResponse> getLoadState​(GetLoadStateParam requestParam)
        Get collection loading state
        Parameters:
        requestParam - GetLoadStateParam
        Returns:
        {status:result code, data:GetLoadStateResponse{status}}

      • insert

        R<InsertResponse> insert​(InsertRowsParam requestParam)
        Inserts rows data into a specified collection . Note that you don't need to input primary key field if auto_id is enabled.
        Parameters:
        requestParam - InsertRowsParam
        Returns:
        {status:result code, data: MutationResult{insert results}}

      • delete

        R<DeleteResponse> delete​(DeleteIdsParam requestParam)
        Deletes entity(s) based on the value of primary key.
        Parameters:
        requestParam - DeleteIdsParam
        Returns:
        {status:result code, data: MutationResult{delete results}}

      • get

        R<GetResponse> get​(GetIdsParam requestParam)
        Get entity(s) based on the value of primary key.
        Parameters:
        requestParam - GetIdsParam
        Returns:
        {status:result code, data: QueryResults{query results}}

      • query

        R<QueryResponse> query​(QuerySimpleParam requestParam)
        Queries entity(s) based on scalar field(s) filtered by boolean expression. Note that the order of the returned entities cannot be guaranteed.
        Parameters:
        requestParam - QuerySimpleParam
        Returns:
        {status:result code,data: QueryResults{filter results}}

      • search

        R<SearchResponse> search​(SearchSimpleParam requestParam)
        Conducts ANN search on a vector field. Use expression to do filtering before search.
        Parameters:
        requestParam - SearchSimpleParam
        Returns:
        {status:result code, data: SearchResults{topK results}}