Gérer les partitions
Ce guide vous explique comment créer et gérer des partitions dans une collection.
Vue d'ensemble
Dans Milvus, une partition représente une sous-division d'une collection. Cette fonctionnalité permet de diviser le stockage physique d'une collection en plusieurs parties, ce qui contribue à améliorer les performances des requêtes en se concentrant sur un sous-ensemble de données plus petit plutôt que sur l'ensemble de la collection.
Lors de la création d'une collection, au moins une partition par défaut nommée _default est automatiquement créée. Vous pouvez créer un maximum de 1 024 partitions dans une collection.
notes
Milvus introduit une fonctionnalité appelée Clé de partition, qui exploite les partitions sous-jacentes pour stocker des entités sur la base des valeurs hachées d'un champ spécifique. Cette fonctionnalité facilite la mise en œuvre de la multi-location, améliorant ainsi les performances de recherche. Pour plus d'informations, lisez Utiliser la clé de partition.
Si la fonction Clé de partition est activée dans une collection, Milvus prend en charge la gestion de toutes les partitions, vous déchargeant ainsi de cette responsabilité.
Préparations
L'extrait de code ci-dessous reprend le code existant pour établir une connexion avec Milvus et créer une collection dans un mode de configuration rapide, indiquant que la collection est chargée lors de la création.
Pour les préparations, utilisez MilvusClient
pour se connecter à Milvus et create_collection()
pour créer une collection en mode d'installation rapide.
Pour les préparations, utilisez MilvusClientV2
pour se connecter à Milvus et createCollection()
pour créer une collection en mode installation rapide.
Pour les préparations, utilisez MilvusClient
pour se connecter à Milvus et createCollection()
pour créer une collection en mode installation rapide.
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,
});
Remarques
Dans l'extrait de code ci-dessus, l'index de la collection a été créé en même temps que la collection, ce qui indique que la collection est chargée lors de la création.
Lister les partitions
Une fois qu'une collection est prête, vous pouvez dresser la liste de ses partitions.
Pour lister les partitions, utilisez list_partitions()
.
Pour lister les partitions, utilisez listPartitions()
.
Pour répertorier les partitions, utilisez 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' ]
//
Le résultat de l'extrait de code ci-dessus comprend les noms des partitions de la collection spécifiée.
notes
Si vous avez défini un champ comme clé de partition dans une collection, Milvus crée au moins 64 partitions avec la collection. Lors de l'énumération des partitions, les résultats peuvent différer de la sortie des extraits de code ci-dessus.
Pour plus de détails, reportez-vous à la section Utiliser une clé de partition.
Créer des partitions
Vous pouvez ajouter des partitions à la collection. Une collection peut comporter jusqu'à 1 024 partitions.
Pour créer des partitions, utilisez create_partition()
.
Pour créer des partitions, utilisez createPartition()
.
Pour créer des partitions, utilisez 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' ]
//
L'extrait de code ci-dessus crée une partition dans une collection et répertorie les partitions de la collection.
notes
Si vous avez défini un champ comme clé de partition dans une collection, Milvus se charge de gérer les partitions dans la collection. Par conséquent, vous pouvez rencontrer des erreurs d'invite lorsque vous tentez de créer des partitions.
Pour plus de détails, voir Utiliser la clé de partition.
Vérification de l'existence d'une partition spécifique
Vous pouvez également vérifier l'existence d'une partition spécifique.
Pour vérifier l'existence d'une partition spécifique, utilisez has_partition()
.
Pour vérifier l'existence d'une partition spécifique, utilisez hasPartition()
.
Pour vérifier l'existence d'une partition spécifique, utilisez 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
//
L'extrait de code ci-dessus vérifie si la collection possède une partition nommée partitionA
et partitionC
.
Charger et libérer des partitions
Vous pouvez charger et libérer des partitions spécifiques pour les rendre disponibles ou non pour les recherches et les requêtes.
Obtenir l'état de chargement
Pour vérifier l'état de chargement d'une collection et de ses partitions, utilisez la commande get_load_state()
.
Pour vérifier l'état de charge d'une collection et de ses partitions, utilisez la commande getLoadState()
.
Pour vérifier l'état de charge d'une collection et de ses partitions, utilisez la commande 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
//
L'état de chargement possible peut être l'un des suivants
Chargé
Une collection est marquée comme
Loaded
si au moins une de ses partitions a été chargée.Non chargé
Une collection est marquée comme
NotLoad
si aucune de ses partitions n'a été chargée.Chargement
Une collection est marquée comme étant en cours de chargement si au moins une de ses partitions est en cours de chargement.
Charger les partitions
Pour charger toutes les partitions d'une collection, il suffit d'appeler load_collection()
. Pour charger des partitions spécifiques d'une collection, utilisez load_partitions()
.
Pour charger toutes les partitions d'une collection, il suffit d'appeler loadCollection()
. Pour charger des partitions spécifiques d'une collection, utilisez loadPartitions()
.
Pour charger toutes les partitions d'une collection, il suffit d'appeler loadCollection()
. Pour charger des partitions spécifiques d'une collection, utilisez 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
//
Pour charger plusieurs partitions à la fois, procédez comme suit :
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
//
Pour charger des champs spécifiques dans une ou plusieurs partitions, procédez comme suit :
client.load_partitions(
collection_name="quick_setup",
partition_names=["partitionA"],
load_fields=["id", "vector"],
skip_load_dynamic_field=True
)
Notez que seuls les champs répertoriés dans load_fields
peuvent être utilisés comme conditions de filtrage et champs de sortie dans les recherches et les requêtes. Vous devez toujours inclure la clé primaire dans la liste. Les noms de champs exclus du chargement ne seront pas disponibles pour le filtrage ou la sortie.
Vous pouvez utiliser skip_load_dynamic_field=True
pour ne pas charger le champ dynamique. Milvus traite le champ dynamique comme un champ unique, de sorte que toutes les clés du champ dynamique seront incluses ou exclues ensemble.
Libération des partitions
Pour libérer toutes les partitions d'une collection, il suffit d'appeler release_collection()
. Pour libérer des partitions spécifiques d'une collection, utilisez release_partitions()
.
Pour libérer toutes les partitions d'une collection, il suffit d'appeler releaseCollection()
. Pour libérer des partitions spécifiques d'une collection, utilisez releasePartitions()
.
Pour libérer toutes les partitions d'une collection, il suffit d'appeler releaseCollection()
. Pour libérer des partitions spécifiques d'une collection, utilisez 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
//
Pour libérer plusieurs partitions à la fois, procédez comme suit :
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>"
# }
Abandonner des partitions
Une fois que vous avez libéré une partition, vous pouvez la supprimer si elle n'est plus nécessaire.
Pour supprimer une partition, utilisez drop_partition()
.
Pour supprimer une partition, utilisez dropPartition()
.
Pour déposer une partition, utilisez 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'
// }
//
Remarques
Avant d'abandonner une partition, vous devez la libérer de la mémoire.
FAQ
Combien de données peuvent être stockées dans une partition ?
Il est recommandé de stocker moins de 1B de données dans une partition.
Quel est le nombre maximum de partitions pouvant être créées ?
Par défaut, Milvus permet de créer un maximum de 1 024 partitions. Vous pouvez ajuster le nombre maximum de partitions en configurant
rootCoord.maxPartitionNum
. Pour plus de détails, voir Configurations du système.Comment puis-je faire la différence entre les partitions et les clés de partition ?
Les partitions sont des unités de stockage physiques, tandis que les clés de partition sont des concepts logiques qui affectent automatiquement les données à des partitions spécifiques en fonction d'une colonne désignée.
Par exemple, dans Milvus, si vous avez une collection dont la clé de partition est définie comme le champ
color
, le système affecte automatiquement les données aux partitions en fonction des valeurs hachées du champcolor
pour chaque entité. Ce processus automatisé libère l'utilisateur de la responsabilité de spécifier manuellement la partition lors de l'insertion ou de la recherche de données.En revanche, lorsque vous créez manuellement des partitions, vous devez affecter des données à chaque partition en fonction des critères de la clé de partition. Si vous avez une collection avec un champ
color
, vous devez affecter manuellement les entités dont la valeurcolor
estred
àpartition A
, et les entités dont la valeurcolor
estblue
àpartition B
. Cette gestion manuelle demande plus d'efforts.En résumé, les partitions et les clés de partition sont utilisées pour optimiser le calcul des données et améliorer l'efficacité des requêtes. Il est essentiel de reconnaître que l'activation d'une clé de partition signifie l'abandon du contrôle de la gestion manuelle de l'insertion et du chargement des données de partition, car ces processus sont entièrement automatisés et gérés par Milvus.