milvus-logo
LFAI
Home
  • Benutzerhandbuch

Verwalten von Partitionen

In diesem Handbuch erfahren Sie, wie Sie Partitionen in einer Sammlung erstellen und verwalten können.

Übersicht

Eine Partition in Milvus stellt eine Unterteilung einer Sammlung dar. Diese Funktionalität ermöglicht es, den physischen Speicher einer Sammlung in mehrere Teile zu unterteilen, was zu einer verbesserten Abfrageleistung beiträgt, indem der Fokus auf eine kleinere Teilmenge von Daten anstatt auf die gesamte Sammlung eingegrenzt wird.

Bei der Erstellung einer Sammlung wird automatisch mindestens eine Standardpartition namens _default erstellt. Sie können maximal 1.024 Partitionen innerhalb einer Sammlung erstellen.

Hinweise

Milvus führt eine Funktion namens Partitionsschlüssel ein, die die zugrunde liegenden Partitionen nutzt, um Entitäten auf der Grundlage der Hash-Werte eines bestimmten Feldes zu speichern. Diese Funktion erleichtert die Implementierung von Multi-Tenancy und verbessert die Suchleistung. Für Details, lesen Sie Partitionsschlüssel verwenden.

Wenn die Funktion Partitionsschlüssel in einer Sammlung aktiviert ist, kümmert sich Milvus um die Verwaltung aller Partitionen und entlastet Sie von dieser Verantwortung.

Vorbereitungen

Der nachstehende Codeausschnitt verwendet den vorhandenen Code weiter, um eine Verbindung zu Milvus herzustellen und eine Sammlung im Schnelleinrichtungsmodus zu erstellen, wobei angegeben wird, dass die Sammlung bei der Erstellung geladen wird.

Für die Vorbereitungen verwenden Sie MilvusClient um eine Verbindung zu Milvus herzustellen und create_collection() um eine Sammlung im Schnellstartmodus zu erstellen.

Für Vorbereitungen verwenden Sie MilvusClientV2 um eine Verbindung zu Milvus herzustellen und createCollection() um eine Sammlung im Schnelleinstellungsmodus anzulegen.

Für Vorbereitungen, verwenden Sie MilvusClient um eine Verbindung zu Milvus herzustellen und createCollection() um eine Sammlung im Schnelleinrichtungsmodus zu erstellen.

from pymilvus import MilvusClient, DataType

# 1. Set up a Milvus client
client = MilvusClient(
    uri="http://localhost:19530"
)

# 2. Create a collection
client.create_collection(
    collection_name="quick_setup",
    dimension=5,
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

String CLUSTER_ENDPOINT = "http://localhost:19530";

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

MilvusClientV2 client = new MilvusClientV2(connectConfig);

// 2. Create a collection in quick setup mode
CreateCollectionReq quickSetupReq = CreateCollectionReq.builder()
    .collectionName("quick_setup")
    .dimension(5)
    .build();

client.createCollection(quickSetupReq);
const address = "http://localhost:19530"

// 1. Set up a Milvus Client
client = new MilvusClient({address});

// 2. Create a collection in quick setup mode
await client.createCollection({
    collection_name: "quick_setup",
    dimension: 5,
});  

Hinweise

Im obigen Codeschnipsel wurde der Index der Sammlung zusammen mit der Sammlung erstellt, was anzeigt, dass die Sammlung bei der Erstellung geladen wird.

Partitionen auflisten

Sobald eine Sammlung fertig ist, können Sie ihre Partitionen auflisten.

Um Partitionen aufzulisten, verwenden Sie list_partitions().

Um Partitionen aufzulisten, verwenden Sie listPartitions().

Um Partitionen aufzulisten, verwenden Sie listPartitions().

# 3. List partitions
res = client.list_partitions(collection_name="quick_setup")
print(res)

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

// 3. List all partitions in the collection
ListPartitionsReq listPartitionsReq = ListPartitionsReq.builder()
    .collectionName("quick_setup")
    .build();

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

System.out.println(partitionNames);

// Output:
// ["_default"]
// 3. List partitions
res = await client.listPartitions({
    collection_name: "quick_setup"
})

console.log(res.partition_names)

// Output
// 
// [ '_default' ]
// 

Die Ausgabe des obigen Codeschnipsels enthält die Namen der Partitionen innerhalb der angegebenen Sammlung.

Hinweise

Wenn Sie ein Feld als Partitionsschlüssel in einer Sammlung festgelegt haben, erstellt Milvus mindestens 64 Partitionen zusammen mit der Sammlung. Bei der Auflistung der Partitionen können die Ergebnisse von der Ausgabe der obigen Codeschnipsel abweichen.

Details finden Sie unter Partitionsschlüssel verwenden.

Partitionen erstellen

Sie können der Sammlung weitere Partitionen hinzufügen. Eine Sammlung kann bis zu 1.024 Partitionen haben.

Um Partitionen zu erstellen, verwenden Sie create_partition().

Um Partitionen zu erstellen, verwenden Sie createPartition().

Um Partitionen zu erstellen, verwenden Sie createPartition().

# 4. Create more partitions
client.create_partition(
    collection_name="quick_setup",
    partition_name="partitionA"
)

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

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

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

// 4. Create more partitions
CreatePartitionReq createPartitionReq = CreatePartitionReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionA")
    .build();

client.createPartition(createPartitionReq);

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

client.createPartition(createPartitionReq);

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

partitionNames = client.listPartitions(listPartitionsReq);

System.out.println(partitionNames);

// Output:
// [
//     "_default",
//     "partitionA",
//     "partitionB"
// ]
// 4. Create more partitions
await client.createPartition({
    collection_name: "quick_setup",
    partition_name: "partitionA"
})

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

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

console.log(res.partition_names)

// Output
// 
// [ '_default', 'partitionA', 'partitionB' ]
// 

Der obige Codeschnipsel erstellt eine Partition in einer Sammlung und listet die Partitionen der Sammlung auf.

Hinweise

Wenn Sie ein Feld als Partitionsschlüssel in einer Sammlung festgelegt haben, kümmert sich Milvus um die Verwaltung der Partitionen in der Sammlung. Daher kann es zu Fehlermeldungen kommen, wenn Sie versuchen, Partitionen zu erstellen.

Weitere Informationen finden Sie unter Partitionsschlüssel verwenden.

Nach einer bestimmten Partition suchen

Sie können auch prüfen, ob eine bestimmte Partition vorhanden ist.

Um nach einer bestimmten Partition zu suchen, verwenden Sie has_partition().

Um nach einer bestimmten Partition zu suchen, verwenden Sie hasPartition().

Um nach einer bestimmten Partition zu suchen, verwenden Sie hasPartition().

# 5. Check whether a partition exists
res = client.has_partition(
    collection_name="quick_setup",
    partition_name="partitionA"
)
print(res)

# Output
#
# True

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

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

// 5. Check whether a partition exists
HasPartitionReq hasPartitionReq = HasPartitionReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionA")
    .build();

boolean exists = client.hasPartition(hasPartitionReq);

System.out.println(exists);

// Output:
// true

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

exists = client.hasPartition(hasPartitionReq);

System.out.println(exists);

// Output:
// false
// 5. Check whether a partition exists
res = await client.hasPartition({
    collection_name: "quick_setup",
    partition_name: "partitionA"
})

console.log(res.value)

// Output
// 
// true
// 

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

console.log(res.value)

// Output
// 
// false
// 

Der obige Codeschnipsel prüft, ob die Sammlung eine Partition mit dem Namen partitionA und partitionC hat.

Partitionen laden und freigeben

Sie können bestimmte Partitionen laden und freigeben, um sie für Suchen und Abfragen verfügbar oder nicht verfügbar zu machen.

Ladestatus abrufen

Um den Ladestatus einer Sammlung und ihrer Partitionen zu überprüfen, verwenden Sie get_load_state().

Um den Ladestatus einer Sammlung und ihrer Partitionen zu prüfen, verwenden Sie getLoadState().

Um den Ladestatus einer Sammlung und ihrer Partitionen zu prüfen, verwenden Sie getLoadState().

# Release the collection
client.release_collection(collection_name="quick_setup")

# Check the load status
res = client.get_load_state(collection_name="quick_setup")
print(res)

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

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

print(res)

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

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

print(res)

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

import io.milvus.v2.service.collection.request.GetLoadStateReq;
import io.milvus.v2.service.collection.request.ReleaseCollectionReq;
import io.milvus.v2.service.partition.request.LoadPartitionsReq;
import io.milvus.v2.service.partition.request.ReleasePartitionsReq;

// 6. Load a partition independantly
// 6.1 Release the collection
ReleaseCollectionReq releaseCollectionReq = ReleaseCollectionReq.builder()
    .collectionName("quick_setup")
    .build();

client.releaseCollection(releaseCollectionReq);

// 6.2 Load partitionA
LoadPartitionsReq loadPartitionsReq = LoadPartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("partitionA"))
    .build();

client.loadPartitions(loadPartitionsReq);

Thread.sleep(3000);

// 6.3 Check the load status of the collection and its partitions
GetLoadStateReq getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .build();

boolean state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// true

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

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// true

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

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// false
// 6. Load a partition indenpendantly
await client.releaseCollection({
    collection_name: "quick_setup"
})

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

console.log(res.state)

// Output
// 
// LoadStateNotLoad
// 

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

await sleep(3000)

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

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 

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

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 

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

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 

Der mögliche Ladestatus kann einer der folgenden sein

  • Geladen

    Eine Sammlung wird als Loaded markiert, wenn mindestens eine ihrer Partitionen geladen wurde.

  • NichtLaden

    Eine Sammlung wird als NotLoad markiert, wenn keine ihrer Partitionen geladen wurde.

  • Geladen

    Eine Sammlung ist als "Loading" gekennzeichnet, wenn mindestens eine ihrer Partitionen gerade geladen wird.

Partitionen laden

Um alle Partitionen einer Sammlung zu laden, können Sie einfach load_collection(). Um bestimmte Partitionen einer Sammlung zu laden, verwenden Sie load_partitions().

Um alle Partitionen einer Sammlung zu laden, können Sie einfach loadCollection(). Um bestimmte Partitionen einer Sammlung zu laden, verwenden Sie loadPartitions().

Um alle Partitionen einer Sammlung zu laden, können Sie einfach loadCollection(). Um bestimmte Partitionen einer Sammlung zu laden, verwenden Sie loadPartitions().

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

res = client.get_load_state(collection_name="quick_setup")
print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }
LoadPartitionsReq loadPartitionsReq = LoadPartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("partitionA"))
    .build();

client.loadPartitions(loadPartitionsReq);

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

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// 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.state)

// Output
// 
// LoadStateLoaded
//

Um mehrere Partitionen auf einmal zu laden, gehen Sie wie folgt vor:

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

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

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

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

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }
LoadPartitionsReq loadPartitionsReq = LoadPartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("partitionA", "partitionB"))
    .build();

client.loadPartitions(loadPartitionsReq);

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

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// true

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

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

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

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

console.log(res)

// Output
// 
// LoadStateLoaded
// 

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

console.log(res)

// Output
// 
// LoadStateLoaded
// 

Um bestimmte Felder in einer oder mehreren Partitionen zu laden, gehen Sie wie folgt vor:

client.load_partitions(
    collection_name="quick_setup",
    partition_names=["partitionA"],
    load_fields=["id", "vector"],
    skip_load_dynamic_field=True
)

Beachten Sie, dass nur die in load_fields aufgeführten Felder als Filterbedingungen und Ausgabefelder in Suchen und Abfragen verwendet werden können. Sie sollten immer den Primärschlüssel in die Liste aufnehmen. Die Feldnamen, die vom Laden ausgeschlossen sind, stehen nicht für die Filterung oder Ausgabe zur Verfügung.

Sie können skip_load_dynamic_field=True verwenden, um das Laden des dynamischen Feldes zu überspringen. Milvus behandelt das dynamische Feld als ein einziges Feld, so dass alle Schlüssel des dynamischen Feldes gemeinsam ein- oder ausgeschlossen werden.

Partitionen freigeben

Um alle Partitionen einer Sammlung freizugeben, können Sie einfach release_collection(). Um bestimmte Partitionen einer Sammlung freizugeben, verwenden Sie release_partitions().

Um alle Partitionen einer Sammlung freizugeben, können Sie einfach releaseCollection(). Um bestimmte Partitionen einer Sammlung freizugeben, verwenden Sie releasePartitions().

Um alle Partitionen einer Sammlung freizugeben, können Sie einfach releaseCollection(). Um bestimmte Partitionen einer Sammlung freizugeben, verwenden Sie releasePartitions().

# 7. Release a partition
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: NotLoad>"
# }

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

// 7. Release a partition
ReleasePartitionsReq releasePartitionsReq = ReleasePartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("partitionA"))
    .build();

client.releasePartitions(releasePartitionsReq);

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

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// false
// 7. Release a partition
await client.releasePartitions({
    collection_name: "quick_setup",
    partition_names: ["partitionA"]
})

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

console.log(res.state)

// Output
// 
// LoadStateNotLoad
// 

Um mehrere Partitionen auf einmal freizugeben, gehen Sie wie folgt vor:

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

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

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

Partitionen löschen

Sobald Sie eine Partition freigegeben haben, können Sie sie löschen, wenn sie nicht mehr benötigt wird.

Um eine Partition zu löschen, verwenden Sie drop_partition().

Um eine Partition zu löschen, verwenden Sie dropPartition().

Um eine Partition zu löschen, verwenden Sie dropPartition().

# 8. Drop a partition
client.drop_partition(
    collection_name="quick_setup",
    partition_name="partitionB"
)

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

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

ReleasePartitionsReq releasePartitionsReq = ReleasePartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("_default", "partitionA", "partitionB"))
    .build();

client.releasePartitions(releasePartitionsReq);

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

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// false

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

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

console.log(res)

// Output
// 
// {
//   status: {
//     error_code: 'Success',
//     reason: '',
//     code: 0,
//     retriable: false,
//     detail: ''
//   },
//   state: 'LoadStateNotLoad'
// }
// 

Hinweise

Bevor Sie eine Partition löschen, müssen Sie sie aus dem Speicher freigeben.

FAQ

  • Wie viele Daten können in einer Partition gespeichert werden?

    Es wird empfohlen, weniger als 1B an Daten in einer Partition zu speichern.

  • Wie viele Partitionen können maximal erstellt werden?

    Standardmäßig erlaubt Milvus die Erstellung von maximal 1.024 Partitionen. Sie können die maximale Anzahl der Partitionen anpassen, indem Sie rootCoord.maxPartitionNum konfigurieren. Einzelheiten hierzu finden Sie unter Systemkonfigurationen.

  • Wie kann ich zwischen Partitionen und Partitionsschlüsseln unterscheiden?

    Partitionen sind physische Speichereinheiten, während Partitionsschlüssel logische Konzepte sind, die Daten automatisch bestimmten Partitionen auf der Grundlage einer bestimmten Spalte zuweisen.

    Wenn Sie beispielsweise in Milvus eine Sammlung mit einem Partitionsschlüssel haben, der als Feld color definiert ist, ordnet das System die Daten automatisch den Partitionen zu, basierend auf den Hash-Werten des Feldes color für jede Entität. Dieser automatisierte Prozess entbindet den Benutzer von der Verantwortung, die Partition beim Einfügen oder Suchen von Daten manuell anzugeben.

    Bei der manuellen Erstellung von Partitionen hingegen müssen Sie die Daten jeder Partition auf der Grundlage der Kriterien des Partitionsschlüssels zuordnen. Wenn Sie eine Sammlung mit einem color -Feld haben, würden Sie Entitäten mit einem color -Wert von red manuell partition A und Entitäten mit einem color -Wert von blue partition B zuordnen. Diese manuelle Verwaltung erfordert mehr Aufwand.

    Zusammenfassend lässt sich sagen, dass sowohl Partitionen als auch Partitionsschlüssel verwendet werden, um die Datenberechnung zu optimieren und die Abfrageeffizienz zu erhöhen. Es ist wichtig zu erkennen, dass die Aktivierung eines Partitionsschlüssels bedeutet, die Kontrolle über die manuelle Verwaltung des Einfügens und Ladens von Partitionsdaten aufzugeben, da diese Prozesse vollständig automatisiert sind und von Milvus gehandhabt werden.

Übersetzt vonDeepLogo

Try Managed Milvus for Free

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

Get Started
Feedback

War diese Seite hilfreich?