Gestire le partizioni
Una partizione è un sottoinsieme di un insieme. Ogni partizione condivide la stessa struttura di dati con la collezione madre, ma contiene solo un sottoinsieme dei dati della collezione. Questa pagina aiuta a capire come gestire le partizioni.
Panoramica
Quando si crea una raccolta, Milvus crea anche una partizione denominata _default nella raccolta. Se non si aggiungono altre partizioni, tutte le entità inserite nella raccolta vengono inserite nella partizione predefinita e anche tutte le ricerche e le interrogazioni vengono eseguite all'interno della partizione predefinita.
È possibile aggiungere altre partizioni e inserirvi entità in base a determinati criteri. In questo modo è possibile limitare le ricerche e le query all'interno di determinate partizioni, migliorando le prestazioni di ricerca.
Una raccolta può avere un massimo di 1.024 partizioni.
La funzione Chiave di partizione è un'ottimizzazione della ricerca basata sulle partizioni e consente a Milvus di distribuire le entità in diverse partizioni in base ai valori di un campo scalare specifico. Questa funzione aiuta a implementare la multi-tenancy orientata alle partizioni e migliora le prestazioni di ricerca.
Questa funzione non sarà trattata in questa pagina. Per saperne di più, fare riferimento a Utilizzare la chiave di partizione.
Elenco delle partizioni
Quando si crea una raccolta, Milvus crea anche una partizione denominata _default nella raccolta. È possibile elencare le partizioni di una collezione come segue.
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"
# ]
# }
Creare una partizione
È possibile aggiungere altre partizioni alla raccolta e inserire entità in queste partizioni in base a determinati criteri.
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"
# ]
# }
Controllare una partizione specifica
I seguenti frammenti di codice mostrano come verificare l'esistenza di una partizione in una collezione specifica.
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
# }
# }
Caricare e rilasciare partizioni
È possibile caricare o rilasciare separatamente una o più partizioni.
Caricare le partizioni
È possibile caricare separatamente partizioni specifiche in un insieme. Va notato che lo stato di caricamento di una collezione rimane scarico se nella collezione c'è una partizione non caricata.
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": ""
# }
# }
Rilasciare le partizioni
È anche possibile rilasciare partizioni specifiche.
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": ""
# }
# }
Operazioni sui dati all'interno delle partizioni
Inserire e cancellare entità
È possibile eseguire operazioni di inserimento, upsert e cancellazione in operazioni specifiche. Per i dettagli, fare riferimento a
Inserire entità nella partizione
Inserimento di entità nella partizione
Eliminazione di entità dalla partizione
Ricerca e interrogazione
È possibile effettuare ricerche e query all'interno di partizioni specifiche. Per ulteriori informazioni, consultare
Eseguire ricerche di RNA all'interno di partizioni
Eseguire il filtraggio dei metadati all'interno delle partizioni
Eliminazione di partizioni
È possibile eliminare le partizioni non più necessarie. Prima di abbandonare una partizione, assicurarsi che la partizione sia stata rilasciata.
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"
# ]
# }
