package io.qdrant.client;

import com.google.common.base.Preconditions;

import com.google.common.collect.ImmutableList;

import com.google.common.collect.Lists;

import com.google.common.util.concurrent.FutureCallback;

import com.google.common.util.concurrent.Futures;

import com.google.common.util.concurrent.ListenableFuture;

import com.google.common.util.concurrent.MoreExecutors;

import io.qdrant.client.grpc.Collections.AliasDescription;

import io.qdrant.client.grpc.Collections.AliasOperations;

import io.qdrant.client.grpc.Collections.ChangeAliases;

import io.qdrant.client.grpc.Collections.CollectionClusterInfoRequest;

import io.qdrant.client.grpc.Collections.CollectionClusterInfoResponse;

import io.qdrant.client.grpc.Collections.CollectionDescription;

import io.qdrant.client.grpc.Collections.CollectionExistsRequest;

import io.qdrant.client.grpc.Collections.CollectionExistsResponse;

import io.qdrant.client.grpc.Collections.CollectionInfo;

import io.qdrant.client.grpc.Collections.CollectionOperationResponse;

import io.qdrant.client.grpc.Collections.CreateAlias;

import io.qdrant.client.grpc.Collections.CreateCollection;

import io.qdrant.client.grpc.Collections.CreateShardKeyRequest;

import io.qdrant.client.grpc.Collections.CreateShardKeyResponse;

import io.qdrant.client.grpc.Collections.DeleteAlias;

import io.qdrant.client.grpc.Collections.DeleteCollection;

import io.qdrant.client.grpc.Collections.DeleteShardKeyRequest;

import io.qdrant.client.grpc.Collections.DeleteShardKeyResponse;

import io.qdrant.client.grpc.Collections.GetCollectionInfoRequest;

import io.qdrant.client.grpc.Collections.GetCollectionInfoResponse;

import io.qdrant.client.grpc.Collections.ListAliasesRequest;

import io.qdrant.client.grpc.Collections.ListAliasesResponse;

import io.qdrant.client.grpc.Collections.ListCollectionAliasesRequest;

import io.qdrant.client.grpc.Collections.ListCollectionsRequest;

import io.qdrant.client.grpc.Collections.ListCollectionsResponse;

import io.qdrant.client.grpc.Collections.ListShardKeysRequest;

import io.qdrant.client.grpc.Collections.ListShardKeysResponse;

import io.qdrant.client.grpc.Collections.PayloadIndexParams;

import io.qdrant.client.grpc.Collections.PayloadSchemaType;

import io.qdrant.client.grpc.Collections.RenameAlias;

import io.qdrant.client.grpc.Collections.ShardKey;

import io.qdrant.client.grpc.Collections.ShardKeyDescription;

import io.qdrant.client.grpc.Collections.UpdateCollection;

import io.qdrant.client.grpc.Collections.UpdateCollectionClusterSetupRequest;

import io.qdrant.client.grpc.Collections.UpdateCollectionClusterSetupResponse;

import io.qdrant.client.grpc.Collections.VectorParams;

import io.qdrant.client.grpc.Collections.VectorParamsMap;

import io.qdrant.client.grpc.Collections.VectorsConfig;

import io.qdrant.client.grpc.CollectionsGrpc;

import io.qdrant.client.grpc.Common.Filter;

import io.qdrant.client.grpc.Common.PointId;

import io.qdrant.client.grpc.JsonWithInt.Value;

import io.qdrant.client.grpc.Points;

import io.qdrant.client.grpc.Points.BatchResult;

import io.qdrant.client.grpc.Points.ClearPayloadPoints;

import io.qdrant.client.grpc.Points.CountPoints;

import io.qdrant.client.grpc.Points.CountResponse;

import io.qdrant.client.grpc.Points.CreateFieldIndexCollection;

import io.qdrant.client.grpc.Points.CreateVectorNameRequest;

import io.qdrant.client.grpc.Points.DeleteFieldIndexCollection;

import io.qdrant.client.grpc.Points.DeletePayloadPoints;

import io.qdrant.client.grpc.Points.DeletePointVectors;

import io.qdrant.client.grpc.Points.DeletePoints;

import io.qdrant.client.grpc.Points.DeleteVectorNameRequest;

import io.qdrant.client.grpc.Points.DiscoverBatchPoints;

import io.qdrant.client.grpc.Points.DiscoverBatchResponse;

import io.qdrant.client.grpc.Points.DiscoverPoints;

import io.qdrant.client.grpc.Points.DiscoverResponse;

import io.qdrant.client.grpc.Points.FieldType;

import io.qdrant.client.grpc.Points.GetPoints;

import io.qdrant.client.grpc.Points.GetResponse;

import io.qdrant.client.grpc.Points.PointGroup;

import io.qdrant.client.grpc.Points.PointStruct;

import io.qdrant.client.grpc.Points.PointVectors;

import io.qdrant.client.grpc.Points.PointsIdsList;

import io.qdrant.client.grpc.Points.PointsOperationResponse;

import io.qdrant.client.grpc.Points.PointsSelector;

import io.qdrant.client.grpc.Points.PointsUpdateOperation;

import io.qdrant.client.grpc.Points.QueryBatchPoints;

import io.qdrant.client.grpc.Points.QueryBatchResponse;

import io.qdrant.client.grpc.Points.QueryGroupsResponse;

import io.qdrant.client.grpc.Points.QueryPointGroups;

import io.qdrant.client.grpc.Points.QueryPoints;

import io.qdrant.client.grpc.Points.QueryResponse;

import io.qdrant.client.grpc.Points.ReadConsistency;

import io.qdrant.client.grpc.Points.RecommendBatchPoints;

import io.qdrant.client.grpc.Points.RecommendBatchResponse;

import io.qdrant.client.grpc.Points.RecommendGroupsResponse;

import io.qdrant.client.grpc.Points.RecommendPointGroups;

import io.qdrant.client.grpc.Points.RecommendPoints;

import io.qdrant.client.grpc.Points.RecommendResponse;

import io.qdrant.client.grpc.Points.RetrievedPoint;

import io.qdrant.client.grpc.Points.ScoredPoint;

import io.qdrant.client.grpc.Points.ScrollPoints;

import io.qdrant.client.grpc.Points.ScrollResponse;

import io.qdrant.client.grpc.Points.SearchBatchPoints;

import io.qdrant.client.grpc.Points.SearchBatchResponse;

import io.qdrant.client.grpc.Points.SearchGroupsResponse;

import io.qdrant.client.grpc.Points.SearchPointGroups;

import io.qdrant.client.grpc.Points.SearchPoints;

import io.qdrant.client.grpc.Points.SearchResponse;

import io.qdrant.client.grpc.Points.SetPayloadPoints;

import io.qdrant.client.grpc.Points.UpdateBatchPoints;

import io.qdrant.client.grpc.Points.UpdateBatchResponse;

import io.qdrant.client.grpc.Points.UpdatePointVectors;

import io.qdrant.client.grpc.Points.UpdateResult;

import io.qdrant.client.grpc.Points.UpsertPoints;

import io.qdrant.client.grpc.Points.VectorsSelector;

import io.qdrant.client.grpc.Points.WithPayloadSelector;

import io.qdrant.client.grpc.Points.WithVectorsSelector;

import io.qdrant.client.grpc.Points.WriteOrdering;

import io.qdrant.client.grpc.Points.WriteOrderingType;

import io.qdrant.client.grpc.PointsGrpc;

import io.qdrant.client.grpc.QdrantGrpc.QdrantFutureStub;

import io.qdrant.client.grpc.QdrantOuterClass.HealthCheckReply;

import io.qdrant.client.grpc.QdrantOuterClass.HealthCheckRequest;

import io.qdrant.client.grpc.SnapshotsGrpc;

import io.qdrant.client.grpc.SnapshotsService.CreateFullSnapshotRequest;

import io.qdrant.client.grpc.SnapshotsService.CreateSnapshotRequest;

import io.qdrant.client.grpc.SnapshotsService.CreateSnapshotResponse;

import io.qdrant.client.grpc.SnapshotsService.DeleteFullSnapshotRequest;

import io.qdrant.client.grpc.SnapshotsService.DeleteSnapshotRequest;

import io.qdrant.client.grpc.SnapshotsService.DeleteSnapshotResponse;

import io.qdrant.client.grpc.SnapshotsService.ListFullSnapshotsRequest;

import io.qdrant.client.grpc.SnapshotsService.ListSnapshotsRequest;

import io.qdrant.client.grpc.SnapshotsService.ListSnapshotsResponse;

import io.qdrant.client.grpc.SnapshotsService.SnapshotDescription;

import java.time.Duration;

import java.util.List;

import java.util.Map;

import java.util.concurrent.TimeUnit;

import java.util.stream.Collectors;

import javax.annotation.Nullable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/** Client for the Qdrant vector database. */

public class QdrantClient implements AutoCloseable {

private static final Logger logger = LoggerFactory.getLogger(QdrantClient.class);

private final QdrantGrpcClient grpcClient;

/**

* Creates a new instance of {@link QdrantClient}

*

* @param grpcClient The low-level gRPC client to use.

*/

public QdrantClient(QdrantGrpcClient grpcClient) {

this.grpcClient = grpcClient;

}

/**

* Gets the low-level gRPC client. This is exposed to

*

* <ul>

* <li>Allow access to the underlying gRPC channel

* <li>Allow access to the gRPC client to make requests using the low-level gRPC client in cases

* where functionality may not yet be exposed by the higher level client.

* </ul>

*

* @return The low-level gRPC client

*/

public QdrantGrpcClient grpcClient() {

return grpcClient;

}

/**

* Gets detailed information about the qdrant cluster.

*

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<HealthCheckReply> healthCheckAsync() {

return healthCheckAsync(null);

}

/**

* Gets detailed information about the qdrant cluster.

*

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<HealthCheckReply> healthCheckAsync(@Nullable Duration timeout) {

QdrantFutureStub qdrant =

timeout != null

? this.grpcClient.qdrant().withDeadlineAfter(timeout.toMillis(), TimeUnit.MILLISECONDS)

: this.grpcClient.qdrant();

return qdrant.healthCheck(HealthCheckRequest.getDefaultInstance());

}

// region Collections

/**

* Creates a new collection with the given parameters

*

* @param collectionName The name of the collection.

* @param vectorParams The vector parameters

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> createCollectionAsync(

String collectionName, VectorParams vectorParams) {

return createCollectionAsync(collectionName, vectorParams, null);

}

/**

* Creates a new collection with the given parameters

*

* @param collectionName The name of the collection.

* @param vectorParams The vector parameters

* @param timeout The timeout for the call

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> createCollectionAsync(

String collectionName, VectorParams vectorParams, @Nullable Duration timeout) {

return createCollectionAsync(

CreateCollection.newBuilder()

.setCollectionName(collectionName)

.setVectorsConfig(VectorsConfig.newBuilder().setParams(vectorParams).build())

.build(),

timeout);

}

/**

* Creates a new collection with the given parameters

*

* @param collectionName The name of the collection.

* @param namedVectorParams The named vector parameters

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> createCollectionAsync(

String collectionName, Map<String, VectorParams> namedVectorParams) {

return createCollectionAsync(collectionName, namedVectorParams, null);

}

/**

* Creates a new collection with the given parameters

*

* @param collectionName The name of the collection.

* @param namedVectorParams The named vector parameters

* @param timeout The timeout for the call

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> createCollectionAsync(

String collectionName,

Map<String, VectorParams> namedVectorParams,

@Nullable Duration timeout) {

return createCollectionAsync(

CreateCollection.newBuilder()

.setCollectionName(collectionName)

.setVectorsConfig(

VectorsConfig.newBuilder()

.setParamsMap(VectorParamsMap.newBuilder().putAllMap(namedVectorParams).build())

.build())

.build(),

timeout);

}

/**

* Creates a new collection with the given parameters

*

* @param createCollection The collection creation parameters

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> createCollectionAsync(

CreateCollection createCollection) {

return createCollectionAsync(createCollection, null);

}

/**

* Creates a new collection with the given parameters

*

* @param createCollection The collection creation parameters

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> createCollectionAsync(

CreateCollection createCollection, @Nullable Duration timeout) {

String collectionName = createCollection.getCollectionName();

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

logger.debug("Create collection '{}'", collectionName);

ListenableFuture<CollectionOperationResponse> future =

getCollections(timeout).create(createCollection);

addLogFailureCallback(future, "Create collection");

return Futures.transform(

future,

response -> {

if (!response.getResult()) {

logger.error("Collection '{}' could not be created", collectionName);

throw new QdrantException("Collection '" + collectionName + "' could not be created");

}

return response;

},

MoreExecutors.directExecutor());

}

/**

* Deletes a collection if one exists, and creates a new collection with the given parameters.

*

* @param collectionName The name of the collection.

* @param vectorParams The vector parameters

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> recreateCollectionAsync(

String collectionName, VectorParams vectorParams) {

return recreateCollectionAsync(collectionName, vectorParams, null);

}

/**

* Deletes a collection if one exists, and creates a new collection with the given parameters.

*

* @param collectionName The name of the collection.

* @param vectorParams The vector parameters

* @param timeout The timeout for the call

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> recreateCollectionAsync(

String collectionName, VectorParams vectorParams, @Nullable Duration timeout) {

return recreateCollectionAsync(

CreateCollection.newBuilder()

.setCollectionName(collectionName)

.setVectorsConfig(VectorsConfig.newBuilder().setParams(vectorParams).build())

.build(),

timeout);

}

/**

* Deletes a collection if one exists, and creates a new collection with the given parameters.

*

* @param collectionName The name of the collection.

* @param namedVectorParams The named vector parameters

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> recreateCollectionAsync(

String collectionName, Map<String, VectorParams> namedVectorParams) {

return recreateCollectionAsync(collectionName, namedVectorParams, null);

}

/**

* Deletes a collection if one exists, and creates a new collection with the given parameters.

*

* @param collectionName The name of the collection.

* @param namedVectorParams The named vector parameters

* @param timeout The timeout for the call

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> recreateCollectionAsync(

String collectionName,

Map<String, VectorParams> namedVectorParams,

@Nullable Duration timeout) {

return recreateCollectionAsync(

CreateCollection.newBuilder()

.setCollectionName(collectionName)

.setVectorsConfig(

VectorsConfig.newBuilder()

.setParamsMap(VectorParamsMap.newBuilder().putAllMap(namedVectorParams).build())

.build())

.build(),

timeout);

}

/**

* Deletes a collection if one exists, and creates a new collection with the given parameters.

*

* @param createCollection The collection creation parameters

* @return a new instance of {@link CollectionOperationResponse}

*/

public ListenableFuture<CollectionOperationResponse> recreateCollectionAsync(

CreateCollection createCollection) {

return recreateCollectionAsync(createCollection, null);

}

/**

* Deletes a collection if one exists, and creates a new collection with the given parameters.

*

* @param createCollection The collection creation parameters

* @param timeout The timeout for the call.

* @return a new instance of {@link CollectionOperationResponse}

*/

public ListenableFuture<CollectionOperationResponse> recreateCollectionAsync(

CreateCollection createCollection, @Nullable Duration timeout) {

return Futures.transformAsync(

deleteCollectionAsync(createCollection.getCollectionName(), timeout),

input -> createCollectionAsync(createCollection, timeout),

MoreExecutors.directExecutor());

}

/**

* Gets detailed information about an existing collection.

*

* @param collectionName The name of the collection.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionInfo> getCollectionInfoAsync(String collectionName) {

return getCollectionInfoAsync(collectionName, null);

}

/**

* Gets detailed information about an existing collection.

*

* @param collectionName The name of the collection.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionInfo> getCollectionInfoAsync(

String collectionName, @Nullable Duration timeout) {

logger.debug("Get collection info for '{}'", collectionName);

GetCollectionInfoRequest request =

GetCollectionInfoRequest.newBuilder().setCollectionName(collectionName).build();

ListenableFuture<GetCollectionInfoResponse> future = getCollections(timeout).get(request);

addLogFailureCallback(future, "Get collection info");

return Futures.transform(

future, GetCollectionInfoResponse::getResult, MoreExecutors.directExecutor());

}

/**

* Gets detailed information about a collection's cluster setup.

*

* @param collectionName The name of the collection.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionClusterInfoResponse> getCollectionClusterInfoAsync(

String collectionName) {

return getCollectionClusterInfoAsync(collectionName, null);

}

/**

* Gets detailed information about a collection's cluster setup.

*

* @param collectionName The name of the collection.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionClusterInfoResponse> getCollectionClusterInfoAsync(

String collectionName, @Nullable Duration timeout) {

logger.debug("Get collection cluster info for '{}'", collectionName);

CollectionClusterInfoRequest request =

CollectionClusterInfoRequest.newBuilder().setCollectionName(collectionName).build();

ListenableFuture<CollectionClusterInfoResponse> future =

getCollections(timeout).collectionClusterInfo(request);

addLogFailureCallback(future, "Get collection cluster info");

return future;

}

/**

* Deletes a collection and all its associated data.

*

* @param collectionName The name of the collection

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> deleteCollectionAsync(

String collectionName) {

return deleteCollectionAsync(collectionName, null);

}

/**

* Deletes a collection and all its associated data.

*

* @param collectionName The name of the collection

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> deleteCollectionAsync(

String collectionName, @Nullable Duration timeout) {

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

logger.debug("Delete collection '{}'", collectionName);

DeleteCollection deleteCollection =

DeleteCollection.newBuilder().setCollectionName(collectionName).build();

ListenableFuture<CollectionOperationResponse> future =

getCollections(timeout).delete(deleteCollection);

addLogFailureCallback(future, "Delete collection");

return Futures.transform(

future,

response -> {

if (!response.getResult()) {

logger.error("Collection '{}' could not be deleted", collectionName);

throw new QdrantException("Collection '" + collectionName + "' could not be deleted");

}

return response;

},

MoreExecutors.directExecutor());

}

/**

* Gets the names of all existing collections

*

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<List<String>> listCollectionsAsync() {

return listCollectionsAsync(null);

}

/**

* Gets the names of all existing collections

*

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<List<String>> listCollectionsAsync(@Nullable Duration timeout) {

logger.debug("List collections");

ListenableFuture<ListCollectionsResponse> future =

getCollections(timeout).list(ListCollectionsRequest.getDefaultInstance());

addLogFailureCallback(future, "List collection");

return Futures.transform(

future,

response ->

response.getCollectionsList().stream()

.map(CollectionDescription::getName)

.collect(Collectors.toList()),

MoreExecutors.directExecutor());

}

/**

* Update parameters of the collection

*

* @param updateCollection The update parameters.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> updateCollectionAsync(

UpdateCollection updateCollection) {

return updateCollectionAsync(updateCollection, null);

}

/**

* Update parameters of the collection

*

* @param updateCollection The update parameters.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> updateCollectionAsync(

UpdateCollection updateCollection, @Nullable Duration timeout) {

String collectionName = updateCollection.getCollectionName();

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

logger.debug("Update collection '{}'", collectionName);

ListenableFuture<CollectionOperationResponse> future =

getCollections(timeout).update(updateCollection);

addLogFailureCallback(future, "Update collection");

return Futures.transform(

future,

response -> {

if (!response.getResult()) {

logger.error("Collection '{}' could not be updated", collectionName);

throw new QdrantException("Collection '" + collectionName + "' could not be updated");

}

return response;

},

MoreExecutors.directExecutor());

}

/**

* Update cluster setup for a collection

*

* @param updateCollectionClusterSetup The update parameters.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<UpdateCollectionClusterSetupResponse> updateCollectionClusterSetupAsync(

UpdateCollectionClusterSetupRequest updateCollectionClusterSetup) {

return updateCollectionClusterSetupAsync(updateCollectionClusterSetup, null);

}

/**

* Update cluster setup for a collection

*

* @param updateCollectionClusterSetup The update parameters.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<UpdateCollectionClusterSetupResponse> updateCollectionClusterSetupAsync(

UpdateCollectionClusterSetupRequest updateCollectionClusterSetup,

@Nullable Duration timeout) {

String collectionName = updateCollectionClusterSetup.getCollectionName();

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

logger.debug("Update collection cluster setup'{}'", collectionName);

ListenableFuture<UpdateCollectionClusterSetupResponse> future =

getCollections(timeout).updateCollectionClusterSetup(updateCollectionClusterSetup);

addLogFailureCallback(future, "Update collection");

return Futures.transform(

future,

response -> {

if (!response.getResult()) {

logger.error("Cluster setup of collection '{}' could not be updated", collectionName);

throw new QdrantException(

"Cluster setup of collection '" + collectionName + "' could not be updated");

}

return response;

},

MoreExecutors.directExecutor());

}

/**

* Check if a collection exists

*

* @param collectionName The name of the collection.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<Boolean> collectionExistsAsync(String collectionName) {

return collectionExistsAsync(collectionName, null);

}

/**

* Check if a collection exists

*

* @param collectionName The name of the collection.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<Boolean> collectionExistsAsync(

String collectionName, @Nullable Duration timeout) {

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

logger.debug("Collection exists '{}'", collectionName);

ListenableFuture<CollectionExistsResponse> future =

getCollections(timeout)

.collectionExists(

CollectionExistsRequest.newBuilder().setCollectionName(collectionName).build());

addLogFailureCallback(future, "Collection exists");

return Futures.transform(

future, response -> response.getResult().getExists(), MoreExecutors.directExecutor());

}

// endregion

// region Alias Management

/**

* Creates an alias for a given collection.

*

* @param aliasName The alias to be created.

* @param collectionName The collection for which the alias is to be created.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> createAliasAsync(

String aliasName, String collectionName) {

return createAliasAsync(aliasName, collectionName, null);

}

/**

* Creates an alias for a given collection.

*

* @param aliasName The alias to be created.

* @param collectionName The collection for which the alias is to be created.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> createAliasAsync(

String aliasName, String collectionName, @Nullable Duration timeout) {

return updateAliasesAsync(

ImmutableList.of(

AliasOperations.newBuilder()

.setCreateAlias(

CreateAlias.newBuilder()

.setAliasName(aliasName)

.setCollectionName(collectionName)

.build())

.build()),

timeout);

}

/**

* Renames an existing alias.

*

* @param oldAliasName The old alias name.

* @param newAliasName The new alias name.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> renameAliasAsync(

String oldAliasName, String newAliasName) {

return renameAliasAsync(oldAliasName, newAliasName, null);

}

/**

* Renames an existing alias.

*

* @param oldAliasName The old alias name.

* @param newAliasName The new alias name.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> renameAliasAsync(

String oldAliasName, String newAliasName, @Nullable Duration timeout) {

return updateAliasesAsync(

ImmutableList.of(

AliasOperations.newBuilder()

.setRenameAlias(

RenameAlias.newBuilder()

.setOldAliasName(oldAliasName)

.setNewAliasName(newAliasName)

.build())

.build()),

timeout);

}

/**

* Deletes an alias.

*

* @param aliasName The alias to be deleted.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> deleteAliasAsync(String aliasName) {

return deleteAliasAsync(aliasName, null);

}

/**

* Deletes an alias.

*

* @param aliasName The alias to be deleted.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> deleteAliasAsync(

String aliasName, @Nullable Duration timeout) {

return updateAliasesAsync(

ImmutableList.of(

AliasOperations.newBuilder()

.setDeleteAlias(DeleteAlias.newBuilder().setAliasName(aliasName).build())

.build()),

timeout);

}

/**

* Update the aliases of existing collections.

*

* @param aliasOperations The list of operations to perform.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> updateAliasesAsync(

List<AliasOperations> aliasOperations) {

return updateAliasesAsync(aliasOperations, null);

}

/**

* Update the aliases of existing collections.

*

* @param aliasOperations The list of operations to perform.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CollectionOperationResponse> updateAliasesAsync(

List<AliasOperations> aliasOperations, @Nullable Duration timeout) {

ChangeAliases request = ChangeAliases.newBuilder().addAllActions(aliasOperations).build();

if (logger.isDebugEnabled()) {

for (AliasOperations aliasOperation : aliasOperations) {

switch (aliasOperation.getActionCase()) {

case CREATE_ALIAS:

CreateAlias createAlias = aliasOperation.getCreateAlias();

logger.debug(

"Create alias '{}' for collection '{}'",

createAlias.getAliasName(),

createAlias.getCollectionName());

break;

case RENAME_ALIAS:

RenameAlias renameAlias = aliasOperation.getRenameAlias();

logger.debug(

"Rename alias '{}' to '{}'",

renameAlias.getOldAliasName(),

renameAlias.getNewAliasName());

break;

case DELETE_ALIAS:

DeleteAlias deleteAlias = aliasOperation.getDeleteAlias();

logger.debug("Delete alias '{}'", deleteAlias.getAliasName());

break;

case ACTION_NOT_SET:

break;

}

}

}

ListenableFuture<CollectionOperationResponse> future =

getCollections(timeout).updateAliases(request);

addLogFailureCallback(future, "Update aliases");

return Futures.transform(

future,

response -> {

if (!response.getResult()) {

logger.error("Alias update operation could not be performed");

throw new QdrantException("Alias update could not be performed");

}

return response;

},

MoreExecutors.directExecutor());

}

/**

* Gets a list of all aliases for a collection.

*

* @param collectionName The name of the collection.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<List<String>> listCollectionAliasesAsync(String collectionName) {

return listCollectionAliasesAsync(collectionName, null);

}

/**

* Gets a list of all aliases for a collection.

*

* @param collectionName The name of the collection.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<List<String>> listCollectionAliasesAsync(

String collectionName, @Nullable Duration timeout) {

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

logger.debug("List aliases for collection '{}'", collectionName);

ListCollectionAliasesRequest request =

ListCollectionAliasesRequest.newBuilder().setCollectionName(collectionName).build();

ListenableFuture<ListAliasesResponse> future =

getCollections(timeout).listCollectionAliases(request);

addLogFailureCallback(future, "List collection aliases");

return Futures.transform(

future,

response ->

response.getAliasesList().stream()

.map(AliasDescription::getAliasName)

.collect(Collectors.toList()),

MoreExecutors.directExecutor());

}

/**

* Gets a list of all aliases for all existing collections.

*

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<List<AliasDescription>> listAliasesAsync() {

return listAliasesAsync(null);

}

/**

* Gets a list of all aliases for all existing collections.

*

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<List<AliasDescription>> listAliasesAsync(@Nullable Duration timeout) {

logger.debug("List all aliases");

ListenableFuture<ListAliasesResponse> future =

getCollections(timeout).listAliases(ListAliasesRequest.getDefaultInstance());

addLogFailureCallback(future, "List aliases");

return Futures.transform(

future, ListAliasesResponse::getAliasesList, MoreExecutors.directExecutor());

}

// endregion

// region ShardKey Management

/**

* Creates a shard key for a collection.

*

* @param createShardKey The request object for the operation.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CreateShardKeyResponse> createShardKeyAsync(

CreateShardKeyRequest createShardKey) {

return createShardKeyAsync(createShardKey, null);

}

/**

* Creates a shard key for a collection.

*

* @param createShardKey The request object for the operation.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<CreateShardKeyResponse> createShardKeyAsync(

CreateShardKeyRequest createShardKey, @Nullable Duration timeout) {

String collectionName = createShardKey.getCollectionName();

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

ShardKey shardKey = createShardKey.getRequest().getShardKey();

logger.debug("Create shard key '{}' for '{}'", shardKey, collectionName);

ListenableFuture<CreateShardKeyResponse> future =

getCollections(timeout).createShardKey(createShardKey);

addLogFailureCallback(future, "Create shard key");

return Futures.transform(

future,

response -> {

if (!response.getResult()) {

logger.error("Shard key could not be created for '{}'", collectionName);

throw new QdrantException(

"Shard key " + shardKey + " could not be created for " + collectionName);

}

return response;

},

MoreExecutors.directExecutor());

}

/**

* Deletes a shard key for a collection.

*

* @param deleteShardKey The request object for the operation.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<DeleteShardKeyResponse> deleteShardKeyAsync(

DeleteShardKeyRequest deleteShardKey) {

return deleteShardKeyAsync(deleteShardKey, null);

}

/**

* Deletes a shard key for a collection.

*

* @param deleteShardKey The request object for the operation.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<DeleteShardKeyResponse> deleteShardKeyAsync(

DeleteShardKeyRequest deleteShardKey, @Nullable Duration timeout) {

String collectionName = deleteShardKey.getCollectionName();

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

ShardKey shardKey = deleteShardKey.getRequest().getShardKey();

logger.debug("Delete shard key '{}' for '{}'", shardKey, collectionName);

ListenableFuture<DeleteShardKeyResponse> future =

getCollections(timeout).deleteShardKey(deleteShardKey);

addLogFailureCallback(future, "Delete shard key");

return Futures.transform(

future,

response -> {

if (!response.getResult()) {

logger.error("Shard key '{}' could not be deleted for '{}'", shardKey, collectionName);

throw new QdrantException(

"Shard key " + shardKey + " could not be created for " + collectionName);

}

return response;

},

MoreExecutors.directExecutor());

}

/**

* List the shard keys of a collection.

*

* @param collectionName The name of the collection to list shard keys for.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<List<ShardKeyDescription>> listShardKeysAsync(String collectionName) {

return listShardKeysAsync(collectionName, null);

}

/**

* List the shard keys of a collection.

*

* @param collectionName The name of the collection to list shard keys for.

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<List<ShardKeyDescription>> listShardKeysAsync(

String collectionName, @Nullable Duration timeout) {

Preconditions.checkArgument(!collectionName.isEmpty(), "Collection name must not be empty");

logger.debug("List shard keys for '{}'", collectionName);

ListenableFuture<ListShardKeysResponse> future =

getCollections(timeout)

.listShardKeys(

ListShardKeysRequest.newBuilder().setCollectionName(collectionName).build());

addLogFailureCallback(future, "List Shard Keys");

return Futures.transform(

future, response -> response.getShardKeysList(), MoreExecutors.directExecutor());

}

// endregion

// region Point Management

/**

* Perform insert and updates on points. If a point with a given ID already exists, it will be

* overwritten.

*

* @param collectionName The name of the collection.

* @param points The points to be upserted

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<UpdateResult> upsertAsync(

String collectionName, List<PointStruct> points) {

return upsertAsync(collectionName, points, null);

}

/**

* Perform insert and updates on points. If a point with a given ID already exists, it will be

* overwritten. The call waits for the changes to be applied.

*

* @param collectionName The name of the collection.

* @param points The points to be upserted

* @param timeout The timeout for the call.

* @return a new instance of {@link ListenableFuture}

*/

public ListenableFuture<UpdateResult> upsertAsync(

String collectionName, List<PointStruct> points, @Nullable Duration timeout) {

return upsertAsync(

UpsertPoints.newBuilder()

.setCollectionName(collectionName)

.addAllPoints(points)

.setWait(true)

.build(),

timeout);

}