Gérer les partitions

Une partition est un sous-ensemble d'une collection. Chaque partition partage la même structure de données que sa collection parente, mais ne contient qu'un sous-ensemble des données de cette collection. Cette page vous aide à comprendre comment gérer les partitions.

Présentation

Lors de la création d’une collection, Milvus crée également une partition nommée _default au sein de celle-ci. Si vous ne prévoyez pas d’ajouter d’autres partitions, toutes les entités insérées dans la collection sont placées dans la partition par défaut, et toutes les recherches et requêtes sont également effectuées au sein de cette partition.

Vous pouvez ajouter d’autres partitions et y insérer des entités en fonction de certains critères. Vous pouvez ensuite limiter vos recherches et requêtes à certaines partitions, ce qui améliore les performances de recherche.

Une collection peut comporter au maximum 1 024 partitions.

La fonctionnalité « Partition Key » est une optimisation de la recherche basée sur les partitions ; elle permet à Milvus de répartir les entités dans différentes partitions en fonction des valeurs d’un champ scalaire spécifique. Cette fonctionnalité facilite la mise en œuvre d’une multi-location orientée partition et améliore les performances de recherche.

Cette fonctionnalité ne sera pas abordée sur cette page. Pour en savoir plus, consultez la section « Utilisation de la clé de partition ».

Liste des partitions

Lors de la création d’une collection, Milvus crée également une partition nommée _default dans celle-ci. Vous pouvez lister les partitions d’une collection comme suit.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

res = client.list_partitions(
    collection_name="my_collection"
)

print(res)

# Output
#
# ["_default"]
import io.milvus.v2.service.partition.request.ListPartitionsReq;
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;

import java.util.*;

String CLUSTER_ENDPOINT = "http://localhost:19530";
String TOKEN = "root:Milvus";

// 1. Connect to Milvus
ConnectConfig connectConfig = ConnectConfig.builder()
        .uri(CLUSTER_ENDPOINT)
        .token(TOKEN)
        .build();

MilvusClientV2 client = new MilvusClientV2(connectConfig);

ListPartitionsReq listPartitionsReq = ListPartitionsReq.builder()
        .collectionName("my_collection")
        .build();

List<String> partitionNames = client.listPartitions(listPartitionsReq);
System.out.println(partitionNames);

// Output:
// [_default]
import (
    "context"
    
    "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

milvusAddr := "http://localhost:19530"

client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: milvusAddr,
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
defer client.Close(ctx)

partitionNames, err := client.ListPartitions(ctx, milvusclient.NewListPartitionOption("my_collection"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println(partitionNames)
use milvus::v2::prelude::*;

let client = ClientV2::new(
    &ConnectConfig::new()
        .uri("http://localhost:19530")
        .token("root:Milvus"),
)
.await?;

let partitions = client
    .list_partitions(
        ListPartitionsRequest::builder()
            .collection_name("my_collection")
            .build()?,
    )
    .await?;
println!("{:?}", partitions.partition_names());

// Output
//
// ["_default"]
#include <iostream>
#include "milvus/MilvusClientV2.h"

auto client = milvus::MilvusClientV2::Create();

milvus::ConnectParam connect_param{"http://localhost:19530", "root:Milvus"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

milvus::ListPartitionsResponse response;
status = client->ListPartitions(milvus::ListPartitionsRequest()
                                    .WithCollectionName("my_collection"),
                                response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

for (auto& info : response.PartitionInfos()) {
    std::cout << "\t" << info.Name() << std::endl;
}
import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

const address = "http://localhost:19530";
const token = "root:Milvus";
const client = new MilvusClient({address, token});

let res = await client.listPartitions({
    collection_name: "my_collection"
})

console.log(res);

// Output
// ["_default"]
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Partition;
using Milvus.Client.V2.Types;

using var client = new MilvusClientV2(new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
});
await client.ConnectAsync();

var res = await client.ListPartitionsAsync(new ListPartitionsReq
{
    CollectionName = "my_collection"
});
foreach (var name in res.PartitionNames)
{
    Console.WriteLine(name);
}
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/list" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection"
}'

# {
#     "code": 0,
#     "data": [
#         "_default"
#     ]
# }

Créer une partition

Vous pouvez ajouter d’autres partitions à la collection et y insérer des entités selon certains critères.

client.create_partition(
    collection_name="my_collection",
    partition_name="partitionA"
)

res = client.list_partitions(
    collection_name="my_collection"
)

print(res)

# Output
#
# ["_default", "partitionA"]
import io.milvus.v2.service.partition.request.CreatePartitionReq;

CreatePartitionReq createPartitionReq = CreatePartitionReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .build();

client.createPartition(createPartitionReq);

ListPartitionsReq listPartitionsReq = ListPartitionsReq.builder()
        .collectionName("my_collection")
        .build();

List<String> partitionNames = client.listPartitions(listPartitionsReq);
System.out.println(partitionNames);

// Output:
// [_default, partitionA]
import (
    "fmt"
    
    milvusclient "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

err = client.CreatePartition(ctx, milvusclient.NewCreatePartitionOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

partitionNames, err := client.ListPartitions(ctx, milvusclient.NewListPartitionOption("my_collection"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println(partitionNames)
// Output
// ["_default", "partitionA"]
use milvus::v2::prelude::*;

client
    .create_partition(
        CreatePartitionRequest::builder()
            .collection_name("my_collection")
            .partition_name("partitionA")
            .build()?,
    )
    .await?;

let partitions = client
    .list_partitions(
        ListPartitionsRequest::builder()
            .collection_name("my_collection")
            .build()?,
    )
    .await?;
println!("{:?}", partitions.partition_names());

// Output
//
// ["_default", "partitionA"]
auto status = client->CreatePartition(milvus::CreatePartitionRequest()
                                         .WithCollectionName("my_collection")
                                         .WithPartitionName("partitionA"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

milvus::ListPartitionsResponse response;
status = client->ListPartitions(milvus::ListPartitionsRequest().WithCollectionName("my_collection"), response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

for (auto& info : response.PartitionInfos()) {
    std::cout << "\t" << info.Name() << std::endl;
}
await client.createPartition({
    collection_name: "my_collection",
    partition_name: "partitionA"
})

res = await client.listPartitions({
    collection_name: "my_collection"
})

console.log(res)

// Output
// ["_default", "partitionA"]
using Milvus.Client.V2.Requests.Partition;

await client.CreatePartitionAsync(new CreatePartitionReq
{
    CollectionName = "my_collection",
    PartitionName = "partitionA"
});

var res = await client.ListPartitionsAsync(new ListPartitionsReq
{
    CollectionName = "my_collection"
});
foreach (var name in res.PartitionNames)
{
    Console.WriteLine(name);
}
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionName": "partitionA"
}'

# {
#     "code": 0,
#     "data": {}
# }

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/list" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection"
}'

# {
#     "code": 0,
#     "data": [
#         "_default",
#         "partitionA"
#     ]
# }

Vérifier l’existence d’une partition spécifique

Les extraits de code suivants montrent comment vérifier si une partition existe dans une collection spécifique.

res = client.has_partition(
    collection_name="my_collection",
    partition_name="partitionA"
)

print(res)

# Output
#
# True
import io.milvus.v2.service.partition.request.HasPartitionReq;

HasPartitionReq hasPartitionReq = HasPartitionReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .build();

Boolean hasPartitionRes = client.hasPartition(hasPartitionReq);
System.out.println(hasPartitionRes);

// Output:
// true
result, err := client.HasPartition(ctx, milvusclient.NewHasPartitionOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println(result)

// Output:
// true
use milvus::v2::prelude::*;

let has = client
    .has_partition(
        HasPartitionRequest::builder()
            .collection_name("my_collection")
            .partition_name("partitionA")
            .build()?,
    )
    .await?;
println!("{}", has.exists());

// Output
//
// true
milvus::HasPartitionResponse response;
auto status = client->HasPartition(milvus::HasPartitionRequest()
                                    .WithCollectionName("my_collection")
                                    .WithPartitionName("partitionA"),
                                   response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}
std::cout << response.Has() << std::endl;
res = await client.hasPartition({
    collection_name: "my_collection",
    partition_name: "partitionA"
})

console.log(res.value)

// Output
// true
using Milvus.Client.V2.Requests.Partition;

var hasResp = await client.HasPartitionAsync(new HasPartitionReq
{
    CollectionName = "my_collection",
    PartitionName = "partitionA"
});
Console.WriteLine(hasResp.Has);
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/has" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionName": "partitionA"
}'

# {
#     "code": 0,
#     "data": {
#        "has": true
#     }
# }

Charger et décharger des partitions

Vous pouvez charger ou décharger séparément une ou plusieurs partitions.

Charger des partitions

Vous pouvez charger séparément des partitions spécifiques d'une collection. Il est important de noter que le statut de chargement d'une collection reste « non chargée » s'il existe une partition non chargée dans cette collection.

client.load_partitions(
    collection_name="my_collection",
    partition_names=["partitionA"]
)

res = client.get_load_state(
    collection_name="my_collection",
    partition_name="partitionA"
)

print(res)
# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }
import io.milvus.v2.service.partition.request.LoadPartitionsReq;
import io.milvus.v2.service.collection.request.GetLoadStateReq;

LoadPartitionsReq loadPartitionsReq = LoadPartitionsReq.builder()
        .collectionName("my_collection")
        .partitionNames(Collections.singletonList("partitionA"))
        .build();

client.loadPartitions(loadPartitionsReq);

GetLoadStateReq getLoadStateReq = GetLoadStateReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .build();

Boolean getLoadStateRes = client.getLoadState(getLoadStateReq);
System.out.println(getLoadStateRes);

// True
task, err := client.LoadPartitions(ctx, milvusclient.NewLoadPartitionsOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

// sync wait collection to be loaded
err = task.Await(ctx)
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

state, err := client.GetLoadState(ctx, milvusclient.NewGetLoadStateOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println(state)
use milvus::v2::prelude::*;

client
    .load_partitions(
        LoadPartitionsRequest::builder()
            .collection_name("my_collection")
            .partition_names(["partitionA"])
            .build()?,
    )
    .await?;

let state = client
    .get_load_state(
        GetLoadStateRequest::builder()
            .collection_name("my_collection")
            .partition_names(["partitionA"])
            .build()?,
    )
    .await?;
println!("{:?}", state.state());

// Output
//
// Loaded
auto status = client->LoadPartitions(milvus::LoadPartitionsRequest()
                                        .WithCollectionName("my_collection")
                                        .AddPartitionName("partitionA"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

milvus::GetLoadStateResponse response;
status = client->GetLoadState(milvus::GetLoadStateRequest()
                                .WithCollectionName("my_collection")
                                .AddPartitionName("partitionA"),
                              response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}
std::cout << milvus::to_string(response.State()) << std::endl;
await client.loadPartitions({
    collection_name: "my_collection",
    partition_names: ["partitionA"]
})

res = await client.getLoadState({
    collection_name: "my_collection",
    partition_name: "partitionA"
})

console.log(res)

// Output
//
// LoadStateLoaded
//
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2.Requests.Partition;

await client.LoadPartitionsAsync(new LoadPartitionsReq
{
    CollectionName = "my_collection",
    PartitionNames = new[] { "partitionA" }
});

var loadStateResp = await client.GetLoadStateAsync(new GetLoadStateReq
{
    CollectionName = "my_collection",
    PartitionNames = new[] { "partitionA" }
});
Console.WriteLine(loadStateResp.State);
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/load" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionNames": ["partitionA"]
}'

# {
#     "code": 0,
#     "data": {}
# }

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/get_load_state" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionNames": ["partitionA"]
}'

# {
#     "code": 0,
#     "data": {
#         "loadProgress": 100,
#         "loadState": "LoadStateLoaded",
#         "message": ""
#     }
# }

Libérer des partitions

Vous pouvez également libérer des partitions spécifiques.

client.release_partitions(
    collection_name="my_collection",
    partition_names=["partitionA"]
)

res = client.get_load_state(
    collection_name="my_collection",
    partition_name="partitionA"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: NotLoaded>"
# }
import io.milvus.v2.service.partition.request.ReleasePartitionsReq;

ReleasePartitionsReq releasePartitionsReq = ReleasePartitionsReq.builder()
        .collectionName("my_collection")
        .partitionNames(Collections.singletonList("partitionA"))
        .build();

client.releasePartitions(releasePartitionsReq);

GetLoadStateReq getLoadStateReq = GetLoadStateReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .build();

Boolean getLoadStateRes = client.getLoadState(getLoadStateReq);
System.out.println(getLoadStateRes);

// False
err = client.ReleasePartitions(ctx, milvusclient.NewReleasePartitionsOptions("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

state, err := client.GetLoadState(ctx, milvusclient.NewGetLoadStateOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println(state)
use milvus::v2::prelude::*;

client
    .release_partitions(
        ReleasePartitionsRequest::builder()
            .collection_name("my_collection")
            .partition_names(["partitionA"])
            .build()?,
    )
    .await?;

let state = client
    .get_load_state(
        GetLoadStateRequest::builder()
            .collection_name("my_collection")
            .partition_names(["partitionA"])
            .build()?,
    )
    .await?;
println!("{:?}", state.state());

// Output
//
// NotLoad
auto status = client->ReleasePartitions(milvus::ReleasePartitionsRequest()
                                .WithCollectionName("my_collection")
                                .AddPartitionName("partitionA"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

milvus::GetLoadStateResponse response;
status = client->GetLoadState(milvus::GetLoadStateRequest()
                                .WithCollectionName("my_collection")
                                .AddPartitionName("partitionA"),
                              response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}
std::cout << milvus::to_string(response.State()) << std::endl;
await client.releasePartitions({
    collection_name: "my_collection",
    partition_names: ["partitionA"]
})

res = await client.getLoadState({
    collection_name: "my_collection",
    partition_name: "partitionA"
})

console.log(res)

// Output
// 
// LoadStateNotLoaded
// 
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2.Requests.Partition;

await client.ReleasePartitionsAsync(new ReleasePartitionsReq
{
    CollectionName = "my_collection",
    PartitionNames = new[] { "partitionA" }
});

var loadStateResp = await client.GetLoadStateAsync(new GetLoadStateReq
{
    CollectionName = "my_collection",
    PartitionNames = new[] { "partitionA" }
});
Console.WriteLine(loadStateResp.State);
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/release" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionNames": ["partitionA"]
}'

# {
#     "code": 0,
#     "data": {}
# }

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/get_load_state" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionNames": ["partitionA"]
}'

# {
#     "code": 0,
#     "data": {
#         "loadProgress": 0,
#         "loadState": "LoadStateNotLoaded",
#         "message": ""
#     }
# }

Opérations sur les données au sein des partitions

Insertion et suppression d’entités

Vous pouvez effectuer des opérations d'insertion, d'upsert et de suppression dans des partitions spécifiques. Pour plus de détails, consultez

Recherche et requêtes

Vous pouvez effectuer des recherches et des requêtes au sein de partitions spécifiques. Pour plus de détails, reportez-vous à

Supprimer une partition

Vous pouvez supprimer les partitions qui ne sont plus nécessaires. Avant de supprimer une partition, assurez-vous qu'elle a bien été libérée.

client.release_partitions(
    collection_name="my_collection",
    partition_names=["partitionA"]
)

client.drop_partition(
    collection_name="my_collection",
    partition_name="partitionA"
)

res = client.list_partitions(
    collection_name="my_collection"
)

print(res)

# ["_default"]
import io.milvus.v2.service.partition.request.DropPartitionReq;
import io.milvus.v2.service.partition.request.ReleasePartitionsReq;
import io.milvus.v2.service.partition.request.ListPartitionsReq;

ReleasePartitionsReq releasePartitionsReq = ReleasePartitionsReq.builder()
        .collectionName("my_collection")
        .partitionNames(Collections.singletonList("partitionA"))
        .build();

client.releasePartitions(releasePartitionsReq);

DropPartitionReq dropPartitionReq = DropPartitionReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .build();

client.dropPartition(dropPartitionReq);

ListPartitionsReq listPartitionsReq = ListPartitionsReq.builder()
        .collectionName("my_collection")
        .build();

List<String> partitionNames = client.listPartitions(listPartitionsReq);
System.out.println(partitionNames);

// Output:
// [_default]
err = client.ReleasePartitions(ctx, milvusclient.NewReleasePartitionsOptions("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

err = client.DropPartition(ctx, milvusclient.NewDropPartitionOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

partitionNames, err := client.ListPartitions(ctx, milvusclient.NewListPartitionOption("my_collection"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println(partitionNames)
use milvus::v2::prelude::*;

client
    .release_partitions(
        ReleasePartitionsRequest::builder()
            .collection_name("my_collection")
            .partition_names(["partitionA"])
            .build()?,
    )
    .await?;

client
    .drop_partition(
        DropPartitionRequest::builder()
            .collection_name("my_collection")
            .partition_name("partitionA")
            .build()?,
    )
    .await?;

let partitions = client
    .list_partitions(
        ListPartitionsRequest::builder()
            .collection_name("my_collection")
            .build()?,
    )
    .await?;
println!("{:?}", partitions.partition_names());

// Output
//
// ["_default"]
auto status = client->ReleasePartitions(milvus::ReleasePartitionsRequest()
                                            .WithCollectionName("my_collection")
                                            .AddPartitionName("partitionA"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

status = client->DropPartition(milvus::DropPartitionRequest()
                                .WithCollectionName("my_collection")
                                .WithPartitionName("partitionA"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

milvus::ListPartitionsResponse response;
status = client->ListPartitions(milvus::ListPartitionsRequest()
                                    .WithCollectionName("my_collection"),
                                response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

for (auto& info : response.PartitionInfos()) {
    std::cout << "\t" << info.Name() << std::endl;
}
await client.releasePartitions({
    collection_name: "my_collection",
    partition_names: ["partitionA"]
})

await client.dropPartition({
    collection_name: "my_collection",
    partition_name: "partitionA"
})

res = await client.listPartitions({
    collection_name: "my_collection"
})

console.log(res)

// Output
// ["_default"]
using Milvus.Client.V2.Requests.Partition;

await client.ReleasePartitionsAsync(new ReleasePartitionsReq
{
    CollectionName = "my_collection",
    PartitionNames = new[] { "partitionA" }
});

await client.DropPartitionAsync(new DropPartitionReq
{
    CollectionName = "my_collection",
    PartitionName = "partitionA"
});

var res = await client.ListPartitionsAsync(new ListPartitionsReq
{
    CollectionName = "my_collection"
});
foreach (var name in res.PartitionNames)
{
    Console.WriteLine(name);
}
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/release" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionNames": ["partitionA"]
}'

# {
#     "code": 0,
#     "data": {}
# }

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/drop" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionName": "partitionA"
}'

# {
#     "code": 0,
#     "data": {}
# }

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/list" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection"
}'

# {
#     "code": 0,
#     "data": [
#         "_default"
#     ]
# }