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 Feldescolor
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 einemcolor
-Wert vonred
manuellpartition A
und Entitäten mit einemcolor
-Wert vonblue
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.