パーティションの管理

パーティションはコレクションのサブセットです。各パーティションは親コレクションと同じデータ構造を共有しますが、コレクション内のデータのサブセットのみを含みます。このページでは、パーティションの管理方法について説明します。

概要

コレクションを作成すると、Zilliz Cloud はそのコレクション内に _default という名前のパーティションも作成します。ほかのパーティションを追加しない場合、コレクションに挿入されたすべてのエンティティはデフォルトパーティションに格納され、すべての検索とクエリもデフォルトパーティション内で実行されます。

特定の基準に基づいて、さらにパーティションを追加し、それらにエンティティを挿入できます。その後、検索とクエリを特定のパーティション内に制限できるため、検索パフォーマンスが向上します。

1 つのコレクションに作成できるパーティションは最大 1,024 個です。

📘Notes

Partition Key 機能は、パーティションに基づく検索最適化であり、特定のスカラーフィールドの値に基づいて Zilliz Cloud がエンティティを異なるパーティションに分散できるようにします。この機能は、パーティション指向のマルチテナンシーを実装するのに役立ち、検索パフォーマンスを向上させます。

この機能については、このページでは説明しません。詳細については、パーティションキーの使用 を参照してください。

パーティションの一覧表示

コレクションを作成すると、Zilliz Cloud はそのコレクション内に _default という名前のパーティションも作成します。コレクション内のパーティションは、次のように一覧表示できます。

Python

python

from pymilvus import MilvusClient

client = MilvusClient(
    uri="YOUR_CLUSTER_ENDPOINT",
    token="YOUR_CLUSTER_TOKEN"
)

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

print(res)

# Output
#
# ["_default"]

Java

java

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 = "YOUR_CLUSTER_ENDPOINT";
String TOKEN = "YOUR_CLUSTER_TOKEN";

// 1. Connect to Zilliz Cloud
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]

Go

go

import (
    "context"
    
    "github.com/milvus-io/milvus/client/v3/milvusclient"
)

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

milvusAddr := "YOUR_CLUSTER_ENDPOINT"

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)

Rust

rust

use milvus::v2::prelude::*;

let client = ClientV2::new(
    &ConnectConfig::new()
        .uri("YOUR_CLUSTER_ENDPOINT")
        .token("YOUR_CLUSTER_TOKEN"),
)
.await?;

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

// Output
//
// ["_default"]

C++

cpp

#include <iostream>
#include "milvus/MilvusClientV2.h"

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

milvus::ConnectParam connect_param{"YOUR_CLUSTER_ENDPOINT", "YOUR_CLUSTER_TOKEN"};
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;
}

NodeJS

javascript

import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

const address = "YOUR_CLUSTER_ENDPOINT";
const token = "YOUR_CLUSTER_TOKEN";
const client = new MilvusClient({address, token});

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

console.log(res);

// Output
// ["_default"]

CSharp

csharp

using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Partition;
using Milvus.Client.V2.Types;

using var client = new MilvusClientV2(new ConnectConfig
{
    Uri = "YOUR_CLUSTER_ENDPOINT",
    ApiKey = "YOUR_CLUSTER_TOKEN"
});
await client.ConnectAsync();

var res = await client.ListPartitionsAsync(new ListPartitionsReq
{
    CollectionName = "my_collection"
});
foreach (var name in res.PartitionNames)
{
    Console.WriteLine(name);
}

cURL

bash

export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

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"
#     ]
# }

パーティションの作成

特定の基準に基づいて、コレクションにさらにパーティションを追加し、これらのパーティションにエンティティを挿入できます。

Python

python

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

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

print(res)

# Output
#
# ["_default", "partitionA"]

Java

java

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]

Go

go

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"]

Rust

rust

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"]

C++

cpp

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;
}

NodeJS

javascript

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

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

console.log(res)

// Output
// ["_default", "partitionA"]

CSharp

csharp

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);
}

cURL

bash

export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

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"
#     ]
# }

特定のパーティションの確認

次のコードスニペットは、特定のコレクションにパーティションが存在するかどうかを確認する方法を示しています。

Python

python

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

print(res)

# Output
#
# True

Java

java

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

Go

go

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

fmt.Println(result)

// Output:
// true

Rust

rust

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

C++

cpp

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;

NodeJS

javascript

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

console.log(res.value)

// Output
// true

CSharp

csharp

using Milvus.Client.V2.Requests.Partition;

var hasResp = await client.HasPartitionAsync(new HasPartitionReq
{
    CollectionName = "my_collection",
    PartitionName = "partitionA"
});
Console.WriteLine(hasResp.Has);

cURL

bash

export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

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
#     }
# }

パーティションのロードとリリース

1 つまたは特定のパーティションを個別にロードまたはリリースできます。

パーティションのロード

コレクション内の特定のパーティションを個別にロードできます。コレクション内にロードされていないパーティションがある場合、コレクションのロード状態は未ロードのままになることに注意してください。

Python

python

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>"
# }

Java

java

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

Go

go

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)

Rust

rust

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

C++

cpp

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;

NodeJS

javascript

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

CSharp

csharp

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);

cURL

bash

export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

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": ""
#     }
# }

パーティションのリリース

特定のパーティションをリリースすることもできます。

Python

python

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>"
# }

Java

java

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

Go

go

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)

Rust

rust

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

C++

cpp

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;

NodeJS

javascript

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

CSharp

csharp

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);

cURL

bash

export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

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": ""
#     }
# }

パーティション内のデータ操作

エンティティの挿入と削除

特定のパーティション内で挿入、アップサート、削除の各操作を実行できます。詳細については、次を参照してください。

• パーティションへのエンティティの挿入

• パーティションへのエンティティのアップサート

• パーティションからのエンティティの削除

検索とクエリ

特定のパーティション内で検索とクエリを実行できます。詳細については、次を参照してください。

• パーティション内での ANN 検索の実行

• パーティション内でのメタデータフィルタリングの実行

パーティションの削除

不要になったパーティションは削除できます。パーティションを削除する前に、そのパーティションがリリース済みであることを確認してください。

Python

python

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"]

Java

java

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]

Go

go

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)

Rust

rust

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"]

C++

cpp

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;
}

NodeJS

javascript

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"]

CSharp

csharp

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);
}

cURL

bash

export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

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"
#     ]
# }