Sobre Milvus
Começar a trabalhar
Conceitos
Guia do utilizador
Modelos
Importação de dados
Migração de Milvus
Guia de Administração
Ferramentas
Integrações
Tutoriais
FAQs
API Reference

Gerir partições

Uma partição é um subconjunto de uma coleção. Cada partição partilha a mesma estrutura de dados com a sua coleção principal, mas contém apenas um subconjunto dos dados da coleção. Esta página ajuda-o a compreender como gerir partições.

Visão geral

Ao criar uma coleção, o Milvus cria também uma partição com o nome _default na coleção. Se não adicionar outras partições, todas as entidades inseridas na coleção vão para a partição predefinida, e todas as pesquisas e consultas são também efectuadas na partição predefinida.

Pode adicionar mais partições e inserir entidades nas mesmas com base em determinados critérios. Em seguida, pode restringir as suas pesquisas e consultas a determinadas partições, melhorando o desempenho da pesquisa.

Uma coleção pode ter um máximo de 1024 partições.

A funcionalidade Chave de partição é uma otimização de pesquisa baseada em partições e permite ao Milvus distribuir entidades em diferentes partições com base nos valores de um campo escalar específico. Esta funcionalidade ajuda a implementar o multi-tenancy orientado para a partição e melhora o desempenho da pesquisa.

Esta funcionalidade não será abordada nesta página. Para saber mais, consulte Usar chave de partição.

Listar partições

Ao criar uma coleção, o Milvus também cria uma partição com o nome _default na coleção. Você pode listar as partições em uma coleção da seguinte forma.

Python Java Node.js Go cURL

from pymilvus import MilvusClient

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

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

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 server
ConnectConfig connectConfig = ConnectConfig.builder()
        .uri(CLUSTER_ENDPOINT)
        .token(TOKEN)
        .build();

MilvusClientV2 client = new MilvusClientV2(connectConfig);

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

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

// Output:
// [_default]

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: "quick_setup"
})

console.log(res);

// Output
// ["_default"]

import (
    "context"
    
    client "github.com/milvus-io/milvus/client/v2/milvucclient"
)

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

milvusAddr := "127.0.0.1:19530"
token := "root:Milvus"

cli, err := client.New(ctx, &client.ClientConfig{
    Address: milvusAddr,
    APIKey:  token,
})
if err != nil {
    // handle error
}

defer cli.Close(ctx)

partitionNames, err := cli.ListPartitions(ctx, client.NewListPartitionOption("quick_setup"))
if err != nil {
    // handle error
}

fmt.Println(partitionNames)

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" \
-d '{
    "collectionName": "quick_setup"
}'

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

Criar partição

É possível adicionar mais partições à coleção e inserir entidades nessas partições com base em determinados critérios.

Python Java Node.js Ir cURL

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

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

print(res)

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

import io.milvus.v2.service.partition.request.CreatePartitionReq;

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

client.createPartition(createPartitionReq);

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

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

// Output:
// [_default, partitionA]

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

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

console.log(res)

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

import (
    "fmt"
    
    client "github.com/milvus-io/milvus/client/v2/milvusclient"
)

err = cli.CreatePartition(ctx, client.NewCreatePartitionOption("quick_setup", "partitionA"))
if err != nil {
    // handle error
}

partitionNames, err := cli.ListPartitions(ctx, client.NewListPartitionOption("quick_setup"))
if err != nil {
    // handle error
}

fmt.Println(partitionNames)
// Output
// ["_default", "partitionA"]

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" \
-d '{
    "collectionName": "quick_setup",
    "partitionName": "partitionA"
}'

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

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

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

Verificar se há uma partição específica

Os trechos de código a seguir demonstram como verificar se uma partição existe em uma coleção específica.

Python Java Node.js Go cURL

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

print(res)

# Output
#
# True

import io.milvus.v2.service.partition.request.HasPartitionReq;

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

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

// Output:
// true

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

console.log(res.value)

// Output
// true

import (
    "fmt"
    
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

result, err := cli.HasPartition(ctx, milvusclient.NewHasPartitionOption("quick_setup", "partitionA"))
if err != nil {
    // handle error
}

fmt.Println(result)

// Output:
// true

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" \
-d '{
    "collectionName": "quick_setup",
    "partitionName": "partitionA"
}'

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

Carregar e liberar partições

Você pode carregar ou liberar separadamente uma ou algumas partições.

Carregar partições

Você pode carregar separadamente partições específicas em uma coleção. Vale a pena notar que o estado de carregamento de uma coleção permanece descarregado se houver uma partição descarregada na coleção.

Python Java Node.js Go cURL

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

res = client.get_load_state(
    collection_name="quick_setup",
    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("quick_setup")
        .partitionNames(Collections.singletonList("partitionA"))
        .build();

client.loadPartitions(loadPartitionsReq);

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

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

// True

await client.loadPartitions({
    collection_name: "quick_setup",
    partition_names: ["partitionA"]
})

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

console.log(res)

// Output
// 
// LoadStateLoaded
//

// Go 缺失

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" \
-d '{
    "collectionName": "quick_setup",
    "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" \
-d '{
    "collectionName": "quick_setup",
    "partitionNames": ["partitionA"]
}'

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

Liberar partições

Você também pode liberar partições específicas.

Python Java Node.js Go cURL

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

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

print(res)

# Output
#
# {
#     "state": "<LoadState: NotLoaded>"
# }

import io.milvus.v2.service.partition.request.ReleasePartitionsReq;

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

client.releasePartitions(releasePartitionsReq);

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

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

// False

await client.releasePartitions({
    collection_name: "quick_setup",
    partition_names: ["partitionA"]
})

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

console.log(res)

// Output
// 
// LoadStateNotLoaded
//

// Go 缺失

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" \
-d '{
    "collectionName": "quick_setup",
    "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" \
-d '{
    "collectionName": "quick_setup",
    "partitionNames": ["partitionA"]
}'

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

Operações de dados em partições

Inserir e excluir entidades

É possível realizar operações de inserção, upsert e exclusão em operações específicas. Para obter detalhes, consulte

Inserir entidades na partição
Inserir entidades na partição
Excluir entidades da partição

Pesquisa e consulta

É possível realizar pesquisas e consultas em partições específicas. Para obter detalhes, consulte

Realizar pesquisas ANN dentro de partições
Realizar filtragem de metadados em partições

Eliminar partição

É possível eliminar partições que já não são necessárias. Antes de eliminar uma partição, certifique-se de que a partição foi libertada.

Python Java Node.js Go cURL

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

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

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

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("quick_setup")
        .partitionNames(Collections.singletonList("partitionA"))
        .build();

client.releasePartitions(releasePartitionsReq);

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

client.dropPartition(dropPartitionReq);

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

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

// Output:
// [_default]

await client.releasePartitions({
    collection_name: "quick_setup",
    partition_names: ["partitionA"]
})

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

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

console.log(res)

// Output
// ["_default"]

// Go 缺失

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" \
-d '{
    "collectionName": "quick_setup",
    "partitionNames": ["partitionA"]
}'

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

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

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

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

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

Traduzido por DeepLogo

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started

Feedback

Esta página foi útil?