Modifier le schéma d'une collection

Lorsqu’une collection passe de la phase de développement à la phase de production, son schéma évolue souvent. Vous pouvez ajouter des champs scalaires tels que « source_uri » ou « review_status » pour le filtrage et la logique d’application, ajouter un nouveau champ vectoriel pour les représentations générées par votre application, ajouter une fonction BM25 et son champ vectoriel creux généré pour la recherche lexicale sur le texte existant, ou supprimer des champs et des fonctions qui ne sont plus utilisés. La fonction « Modifier le schéma de la collection » vous permet d’effectuer sur place les modifications prises en charge des champs et des fonctions, au lieu de recréer la collection.

Limites

Ajouter des champs définis par l’utilisateur

• Les champs définis par l’utilisateur ajoutés doivent pouvoir prendre la valeur null. Définissez l’ nullable=True lors de l’appel de add_collection_field(). Pour les entités existantes, le champ ajouté est de type NULL, sauf si vous ajoutez un champ scalaire avec un default_value.

• L’ajout de champs scalaires définis par l’utilisateur est pris en charge dans Milvus 2.6.x et versions ultérieures. L’ajout de champs vectoriels définis par l’utilisateur est pris en charge dans Milvus 2.6.18 et versions ultérieures.

• L'ajout de champs StructArray est pris en charge à partir de Milvus 3.0.0. Les champs StructArray ajoutés doivent être de type « nullable ».

• Les noms de champs doivent être uniques parmi les champs de la collection.

Ajouter une fonction et son champ vectoriel généré

• Chaque mise à jour de schéma ne peut ajouter qu’une seule fonction et un seul champ vectoriel généré.

• La fonction prise en charge détermine le type du champ vectoriel généré : « BM25 » génère un champ « SPARSE_FLOAT_VECTOR », et « MINHASH » génère un champ « BINARY_VECTOR ».

• Le champ vectoriel généré doit être un nouveau champ. Il ne peut pas pointer vers un champ qui existe déjà dans le schéma de la collection.

• Le champ vectoriel généré ne peut pas être de type « nullable ».

• Les champs d’entrée utilisés par la fonction doivent déjà exister dans la collection.

• Lors de l’ajout d’une fonction BM25 ou MinHash à une collection existante, l’entrée de la fonction doit être un champ de type « VARCHAR ». Une entrée de type « TEXT » n’est pas prise en charge dans ce workflow, car Milvus ne peut pas remplir a posteriori la sortie générée pour les entités existantes à partir de ce type d’entrée.

Supprimer des champs définis par l’utilisateur

• Vous ne pouvez pas supprimer le champ de clé primaire, le champ de clé de partition, le champ de clé de clustering ni le dernier champ vectoriel d’une collection.

• Vous pouvez supprimer un champ « ARRAY<STRUCT> » dans son intégralité, mais vous ne pouvez pas supprimer un sous-champ individuel au sein d’un champ « ARRAY<STRUCT> ».

• Vous ne pouvez pas supprimer directement un champ utilisé comme champ d’entrée d’une fonction ou généré en tant que champ de sortie d’une fonction. Pour supprimer un champ de sortie d’une fonction, supprimez la fonction qui le génère.

Supprimer une fonction et son champ vectoriel généré

• Dans ce workflow de modification de schéma, la suppression d’une fonction entraîne la suppression de la fonction, de son champ vectoriel généré et de l’index associé. Les champs d’entrée de la fonction restent dans le schéma de la collection.

• La suppression d’une fonction est refusée si la suppression de son champ vectoriel généré laisse la collection sans aucun champ vectoriel.

Ajouter des champs et des fonctions à une collection existante

Choisissez le workflow en fonction du type d’élément que vous ajoutez : un champ défini par l’utilisateur ou une fonction générant un champ vectoriel :

• Ajoutez des champs scalaires définis par l’utilisateur lorsque vous avez besoin de nouvelles métadonnées pour le filtrage, le résultat d’une requête ou la logique d’application.

• Ajoutez des champs StructArray lorsque vous avez besoin d’un champ de type tableau dont les éléments partagent le même schéma Struct.

• Ajoutez des champs vectoriels définis par l’utilisateur lorsque votre application génère des représentations et écrit des valeurs vectorielles dans Milvus.

• Ajoutez une fonction et le champ vectoriel qu’elle génère lorsque Milvus doit générer des valeurs vectorielles à partir de champs existants, tels que des vecteurs creux BM25 ou des signatures MinHash issues de texte.

Dans tous les cas, le nom du nouveau champ ne doit pas déjà exister dans la collection, et le nombre total de champs ne peut pas dépasser la limite de Milvus en matière de nombre de champs. Pour plus de détails, consultez la section « Limites de Milvus ».

Ajouter des champs scalaires définis par l’utilisateurCompatible with Milvus 2.6.x

Utilisez la commande « add_collection_field() » pour ajouter un champ scalaire défini par l’utilisateur à une collection existante.

Cette opération diffère du stockage de clés arbitraires dans le champ dynamique : une fois la mise à jour du schéma disponible, le nouveau champ scalaire fait partie intégrante du schéma de la collection. Vous pouvez y insérer ou y mettre à jour des valeurs, créer des index le cas échéant, l’utiliser dans des requêtes et des filtres de recherche, et le renvoyer dans le résultat d’une requête ou d’une recherche.

Comme les entités existantes ont été insérées avant la création du nouveau champ, tout champ scalaire défini par l’utilisateur ajouté doit être de type « nullable » :

• Si vous ajoutez un champ scalaire avec ` nullable=True ` et sans ` default_value`, les entités existantes renvoient ` NULL ` pour le nouveau champ.

• Si vous ajoutez un champ scalaire avec ` nullable=True ` et ` default_value`, les entités existantes renvoient la valeur par défaut au lieu de ` NULL`.

Les expressions de filtrage scalaires ne correspondent pas aux valeurs scalaires de type « NULL ». Pour plus de détails, reportez-vous à la section Champs pouvant prendre la valeur null.

Exemple : Ajouter un champ scalaire pouvant prendre la valeur null

L'exemple suivant ajoute un champ scalaire pouvant prendre la valeur null source à une collection existante nommée product_catalog.

from pymilvus import DataType, MilvusClient

client = MilvusClient(uri="http://localhost:19530")

client.add_collection_field(
    collection_name="product_catalog",
    field_name="source",
    data_type=DataType.VARCHAR,
    max_length=128,
    nullable=True,
)

Une fois le champ ajouté, les entités qui existaient déjà dans la collection renvoient « NULL » pour « source ». Les nouvelles entités peuvent définir « source » lors de l’insertion ou de la mise à jour.

Exemple : ajouter un champ scalaire avec une valeur par défaut

Si les entités existantes doivent renvoyer une valeur concrète au lieu de NULL, spécifiez default_value lors de l’ajout d’un champ scalaire. L’exemple suivant ajoute un champ review_status et utilise "unreviewed" comme valeur par défaut.

from pymilvus import DataType, MilvusClient

client = MilvusClient(uri="http://localhost:19530")

client.add_collection_field(
    collection_name="product_catalog",
    field_name="review_status",
    data_type=DataType.VARCHAR,
    max_length=32,
    nullable=True,
    default_value="unreviewed",
)

Une fois le champ ajouté, les entités qui existaient déjà dans la collection renvoient "unreviewed" pour review_status. Les nouvelles entités peuvent définir une valeur différente ou utiliser la valeur par défaut lorsqu’aucune valeur n’est fournie.

Ajouter des champs StructArrayCompatible with Milvus 3.0.0

Utilisez add_collection_struct_field() pour ajouter un champ StructArray qui accepte des tableaux d’éléments Struct. Pour ajouter un champ StructArray, procédez comme suit :

1. Créez un schéma Struct contenant les sous-champs nécessaires des types de données pris en charge. Pour connaître les types de données applicables, consultez la section « Limites de StructArray ».

2. Faites référence au schéma Struct créé ci-dessus et définissez la capacité maximale du champ dans « add_collection_struct_field() ».

3. Définissez ` nullable=True ` dans la requête.

Exemple : ajouter un champ StructArray pouvant prendre la valeur null

from pymilvus import DataType, MilvusClient

client = MilvusClient(uri="http://localhost:19530")

# Create a Struct schema.
struct_schema = client.create_struct_field_schema()

# Add scalar fields to the Struct.
struct_schema.add_field("text", DataType.VARCHAR, max_length=65535)
struct_schema.add_field("chapter", DataType.VARCHAR, max_length=512)

# Add vector fields to the Struct with mmap enabled.
struct_schema.add_field("text_vector", DataType.FLOAT_VECTOR, mmap_enabled=True, dim=5)
struct_schema.add_field("chapter_vector", DataType.FLOAT_VECTOR, mmap_enabled=True, dim=5)

client.add_collection_struct_field(
    collection_name="books",
    field_name="chunks",
    struct_schema=struct_schema,
    max_capacity=1024,
    nullable=True,
)

Une fois le champ StructArray ajouté, les entités déjà présentes dans la collection renvoient la valeur « NULL » pour l’ chunks, quel que soit le champ concerné. Lorsque vous insérez une nouvelle entité, assurez-vous que tous les sous-champs sont soit définis sur « NULL », soit contiennent des valeurs valides. L’insertion d’une entité dont certains sous-champs sont définis sur « NULL » et d’autres sur des valeurs valides entraîne des erreurs.

Ajouter des champs vectoriels définis par l’utilisateurCompatible with Milvus 2.6.18+

Utilisez add_collection_field() pour ajouter un champ vectoriel défini par l’utilisateur lorsque votre application génère des représentations et écrit des valeurs vectorielles dans Milvus.

Chaque champ vectoriel défini par l’utilisateur ajouté doit être nullable. Les entités existantes disposent d’une valeur par défaut ( NULL ) pour le nouveau champ vectoriel jusqu’à ce que vous écriviez des valeurs vectorielles via un workflow d’upsert ou de backfill. Les nouvelles entités peuvent inclure le champ vectoriel lors de l’insertion. La recherche vectorielle ignore les entités dont la valeur vectorielle est « NULL ». Pour plus de détails, reportez-vous à la section Champs nullables.

Exemple : ajouter un champ vectoriel pouvant prendre la valeur null

L’exemple suivant ajoute un champ vectoriel dense pouvant prendre la valeur null, nommé embedding_v2, à une collection existante. Définissez dim sur la dimensionnalité des représentations générées par votre application.

from pymilvus import DataType, MilvusClient

client = MilvusClient(uri="http://localhost:19530")

client.add_collection_field(
    collection_name="product_catalog",
    field_name="embedding_v2",
    data_type=DataType.FLOAT_VECTOR,
    dim=768,
    nullable=True,
)

Une fois le champ ajouté, créez un index sur le nouveau champ vectoriel avant d’effectuer une recherche dessus :

index_params = client.prepare_index_params()

index_params.add_index(
    field_name="embedding_v2",
    index_type="AUTOINDEX",
    metric_type="COSINE",
)

client.create_index(
    collection_name="product_catalog",
    index_params=index_params,
)

Les entités existantes ont la valeur « NULL » pour « embedding_v2 » et sont ignorées lorsque vous effectuez une recherche sur ce champ. Pour rendre les entités existantes consultables via « embedding_v2 », écrivez des valeurs vectorielles non NULL via un workflow d’upsert ou de backfill. Les nouvelles entités peuvent inclure « embedding_v2 » lors de l’insertion.

Ajouter une fonction et son champ vectoriel généréCompatible with Milvus 3.0.x

Utilisez ce workflow lorsque Milvus doit générer un nouveau champ vectoriel à partir de données déjà stockées dans une collection existante. L’opération ajoute trois éléments de schéma associés :

• Une définition de fonction qui lit à partir d’un ou plusieurs champs d’entrée existants.

• Un nouveau champ vectoriel qui stocke la sortie de la fonction.

• Une définition d’index liée au nouveau champ vectoriel.

Par exemple, une fonction BM25 lit un champ existant « VARCHAR » et génère un champ « SPARSE_FLOAT_VECTOR » destiné à la recherche lexicale. Une fonction MinHash génère un champ « BINARY_VECTOR » destiné à la détection des quasi-duplicatas. Ce workflow n’ajoute ni ne remplace le champ d’entrée de la fonction.

L’ajout d’une fonction et de son champ vectoriel généré à une collection existante nécessite également la compaction de la version du schéma et la compaction de la version de stockage. Milvus rejette la requête si l’un de ces paramètres est désactivé. Ces prérequis supplémentaires s’appliquent uniquement lors de la modification d’une collection existante ; la définition de la fonction dans le schéma initial de la collection n’utilise pas ce workflow de remplissage des données existantes.

La fonction prise en charge détermine le type de champ vectoriel généré :

Fonction	Type de champ vectoriel généré	Champ d’entrée type	Cas d’utilisation typique
BM25	SPARSE_FLOAT_VECTOR	Un champ « VARCHAR » avec l'analyseur activé	Recherche lexicale et pertinence des mots-clés
MINHASH	BINARY_VECTOR	Un champ « VARCHAR »	Détection des quasi-duplicatas

Pour plus de détails sur le fonctionnement de chaque fonction, reportez-vous aux sections « Fonction BM25 » et « Fonction MinHash ».

Le champ vectoriel généré ne doit pas exister déjà dans la collection et ne peut pas être de type « nullable ». Le champ d’entrée de la fonction doit déjà exister.

Exemple : ajouter une fonction BM25 et son champ vectoriel clairsemé généré

L’exemple suivant ajoute une fonction BM25 nommée « text_bm25 » et son champ vectoriel clairsemé généré, nommé « text_sparse », à une collection existante. La collection doit déjà comporter un champ « VARCHAR » nommé « text » avec l’analyseur activé.

from pymilvus import DataType, Function, FunctionType, MilvusClient

client = MilvusClient(uri="http://localhost:19530")

sparse_field = client.create_field_schema(
    name="text_sparse",
    data_type=DataType.SPARSE_FLOAT_VECTOR,
    desc="BM25-generated sparse vector field",
)

bm25_function = Function(
    name="text_bm25",
    input_field_names=["text"],
    output_field_names=["text_sparse"],
    function_type=FunctionType.BM25,
)

index_params = client.prepare_index_params()

index_params.add_index(
    field_name="text_sparse",
    index_type="SPARSE_INVERTED_INDEX",
    metric_type="BM25",
    params={
        "inverted_index_algo": "DAAT_MAXSCORE",
        "bm25_k1": 1.2,
        "bm25_b": 0.75,
    },
)

client.add_function_field(
    collection_name="product_catalog",
    field_schema=sparse_field,
    func=bm25_function,
    index_params=index_params,
)

L’objet « index_params » doit contenir exactement une définition d’index pour le nouveau champ de sortie de la fonction. Milvus ajoute la fonction, son champ vectoriel généré et la définition d’index liée au cours de la même modification de schéma. N’appelez pas « create_index() » séparément après « add_function_field() ».

D’un point de vue conceptuel, cette opération ajoute les définitions suivantes de la fonction, du champ de sortie généré et de l’index lié :

New Function:
  name: "text_bm25"
  type: BM25
  input_field_names: ["text"]
  output_field_names: ["text_sparse"]

New generated output field:
  name: "text_sparse"
  data_type: SPARSE_FLOAT_VECTOR
  nullable: false

Bound index:
  field_name: "text_sparse"
  index_type: SPARSE_INVERTED_INDEX
  metric_type: BM25

Une fois la requête réussie, ` describe_collection() ` renvoie à la fois la nouvelle fonction ` text_bm25 ` et son champ vectoriel généré ` text_sparse ` dans le schéma de la collection. Milvus génère la sortie de la fonction pour les nouvelles entités au fur et à mesure de leur écriture. Pour les entités existantes, Milvus remplit le champ vectoriel généré de manière asynchrone via une compaction en arrière-plan. La visibilité du schéma confirme que la mise à jour du schéma a réussi, mais n’indique pas que le remplissage a été effectué pour chaque entité existante. Pour le workflow complet de recherche BM25, reportez-vous à la section « Recherche en texte intégral ».

Milvus prend également en charge les fonctions MinHash et les champs vectoriels binaires qu’elles génèrent pour la détection des quasi-duplicatas. Une fonction MinHash utilise l’ FunctionType.MINHASH e et écrit dans un nouveau champ de sortie « BINARY_VECTOR ». Pour plus de détails sur la configuration, reportez-vous à la section « Fonction MinHash ».

Supprimer des champs et des fonctions d’une collection existante

Vous pouvez supprimer directement les champs définis par l’utilisateur lorsqu’ils ne font plus partie de votre modèle de collection. Pour supprimer une fonction et le champ vectoriel qu’elle génère, supprimez la fonction ; Milvus supprime alors le champ généré et son index au cours de la même modification de schéma.

Supprimer des champs définis par l’utilisateurCompatible with Milvus 3.0.x

Utilisez la commande « drop_collection_field() » pour supprimer un champ scalaire, vectoriel ou StructArray défini par l’utilisateur qui ne fait plus partie de votre modèle de collection.

La suppression d’un champ modifie d’abord le schéma de la collection et la visibilité du champ :

• Une fois l’opération « drop_collection_field() » réussie, le schéma de la collection est mis à jour : la commande « describe_collection() » ne renvoie plus le champ supprimé, et les requêtes ou recherches ne peuvent plus renvoyer ce champ dans « output_fields » ni l’utiliser dans des expressions.

• Les index créés sur le champ supprimé sont nettoyés dans le cadre de la mise à jour du schéma.

Le nettoyage du stockage est géré séparément du nettoyage du schéma. Pour plus de détails, consultez la section « Quand l’espace de stockage est-il libéré après la suppression d’un champ ? ».

Exemple : suppression d’un champ scalaire défini par l’utilisateur

L'exemple suivant part du principe que « experiment_tag » est un champ scalaire défini par l'utilisateur dans « product_catalog », et le supprime de la collection.

from pymilvus import MilvusClient

client = MilvusClient(uri="http://localhost:19530")

client.drop_collection_field(
    collection_name="product_catalog",
    field_name="experiment_tag",
)

Après avoir supprimé un champ, vous pouvez appeler la méthode ` describe_collection() ` pour vérifier que le champ ne fait plus partie du schéma.

Exemple : Supprimer un champ StructArray

L'exemple suivant part du principe que ` chunks ` est un champ `StructArray` dans ` my_collection` et le supprime de la collection.

from pymilvus import MilvusClient

client = MilvusClient(uri="http://localhost:19530")

client.drop_collection_field(
    collection_name="my_collection",
    field_name="chunks",
)

Exemple : suppression d’un champ vectoriel défini par l’utilisateur

Vous pouvez supprimer un champ vectoriel à l’aide de la même méthode drop_collection_field(), mais la collection doit toujours contenir au moins un champ vectoriel après la suppression. Cela s’avère utile pour les collections qui contiennent temporairement plusieurs représentations vectorielles et qui s’uniformisent par la suite sur l’une d’entre elles.

L’exemple suivant part du principe que ` image_vector ` est un champ vectoriel défini par l’utilisateur dans ` hybrid_catalog`, et que la collection conserve encore un autre champ vectoriel, tel que ` text_vector`.

from pymilvus import MilvusClient

client = MilvusClient(uri="http://localhost:19530")

client.drop_collection_field(
    collection_name="hybrid_catalog",
    field_name="image_vector",
)

Si image_vector est le dernier champ vectoriel de la collection, l’opération de suppression est rejetée.

Supprimer une fonction et son champ vectoriel généréCompatible with Milvus 3.0.x

Utilisez cette opération lorsque vous n’avez plus besoin d’une fonction ou de son champ vectoriel généré, par exemple une fonction BM25 et son champ vectoriel creux généré.

Appelez drop_function_field() en indiquant le nom de la fonction. Milvus supprime la fonction, le champ vectoriel qu’elle génère et l’index associé, tout en conservant les champs d’entrée de la fonction.

Exemple : suppression d’une fonction BM25 et de son champ vectoriel creux généré

L’exemple suivant part du principe que ` text_bm25 ` est une fonction BM25 dans ` product_catalog ` et génère un champ de sortie vectoriel creux nommé ` text_sparse`.

from pymilvus import MilvusClient

client = MilvusClient(uri="http://localhost:19530")

client.drop_function_field(
    collection_name="product_catalog",
    function_name="text_bm25",
)

Une fois l’opération réussie, describe_collection() ne renvoie plus la fonction supprimée ni son champ vectoriel généré. Les champs d’entrée de la fonction restent dans le schéma.

Si la suppression du champ de sortie de la fonction devait laisser la collection sans aucun champ vectoriel, l’opération est rejetée.

FAQ

Quelle méthode dois-je utiliser pour ajouter un champ ou une fonction ?

Utilisez add_collection_field() pour ajouter un champ scalaire ou vectoriel défini par l’utilisateur.

Utilisez ` add_collection_struct_field() ` pour ajouter un champ `StructArray` lorsque vous avez besoin d’un champ de type tableau dont les éléments partagent le même schéma `Struct`.

Utilisez ` add_function_field() ` pour ajouter une fonction, son champ vectoriel généré et la définition d’index liée au cours de la même modification de schéma.

Pourquoi les champs définis par l’utilisateur ajoutés doivent-ils être nullables ?

Les entités existantes ont été insérées avant la création du nouveau champ ; elles ne disposent donc pas de valeurs pour ce champ. En définissant ` nullable=True `, Milvus représente la valeur manquante comme ` NULL ` jusqu’à ce que votre application écrive une valeur ou, pour les champs scalaires, jusqu’à ce qu’une valeur par défaut s’applique.

Cette règle s’applique aux champs scalaires définis par l’utilisateur et aux champs vectoriels définis par l’utilisateur ajoutés avec l’ add_collection_field(), ainsi qu’aux champs StructArray ajoutés avec l’ add_collection_struct_field(). Elle ne s’applique pas au champ vectoriel généré par une fonction, qui ne peut pas être nul.

Que deviennent les entités existantes après l’ajout d’un champ défini par l’utilisateur ?

Pour un champ scalaire défini par l’utilisateur, les entités existantes renvoient NULL, sauf si vous définissez un default_value. Si vous définissez un default_value, les entités existantes renvoient cette valeur par défaut.

Pour un champ vectoriel défini par l’utilisateur, les entités existantes ont la valeur « NULL » pour le nouveau champ vectoriel. La recherche vectorielle sur le champ ajouté ignore les entités dont la valeur vectorielle est « NULL ». Pour rendre les entités existantes consultables via le nouveau champ vectoriel, écrivez des valeurs vectorielles non nulles via un « upsert » ou un workflow de remplissage. Les nouvelles entités peuvent inclure le nouveau champ vectoriel lors de l’insertion.

Pour un champ StructArray, les entités existantes renvoient des valeurs « NULL » pour le nouveau champ StructArray dans tous ses sous-champs. Les nouvelles entités doivent fournir soit la valeur « NULL » pour tous les sous-champs, soit des valeurs valides pour tous les sous-champs.

Puis-je ajouter la recherche lexicale BM25 à une collection existante ?

Oui. Si la collection dispose déjà d’un champ « VARCHAR » avec l’analyseur activé, vous pouvez ajouter une fonction BM25 et son champ vectoriel clairsemé généré pour la recherche lexicale. Dans ce workflow, Milvus ajoute la fonction, le nouveau champ de sortie « SPARSE_FLOAT_VECTOR » et la définition d’index lié au sein d’une même modification de schéma. Vous ne pouvez pas utiliser un champ « TEXT » existant comme entrée BM25 dans ce workflow de modification de schéma. Pour utiliser une entrée « TEXT », définissez le champ et la fonction BM25 lors de la création de la collection.

Lorsque vous appelez ` add_function_field()`, fournissez un objet ` index_params ` contenant un index ` SPARSE_INVERTED_INDEX ` avec ` metric_type="BM25" ` pour le nouveau champ de sortie. Milvus lie la définition de l’index au champ généré dans le cadre de la même modification de schéma.

Comment supprimer une fonction et son champ vectoriel généré ?

Appelez la méthode drop_function_field() en lui passant le nom de la fonction. Dans ce workflow de modification de schéma, Milvus supprime simultanément la fonction, son champ vectoriel généré et l’index associé, tout en conservant les champs d’entrée de la fonction.

Dois-je attendre après avoir modifié le schéma d’une collection ?

En général, aucun délai d’attente manuel n’est nécessaire. Si votre opération suivante dépend du schéma mis à jour, vous pouvez d’abord appeler ` describe_collection() ` pour vérifier le schéma actuellement renvoyé par Milvus.

Dans un déploiement distribué, il peut y avoir un court délai de propagation pendant que les composants Milvus actualisent les métadonnées de la collection. Si une opération effectuée immédiatement après la modification du schéma échoue en raison d’une erreur liée au schéma, actualisez le schéma et réessayez l’opération.

Quand l’espace de stockage est-il libéré après la suppression d’un champ ?

La suppression d’un champ le retire du schéma actuel et de la visibilité normale des requêtes/recherches, mais les données historiques de ce champ ne sont pas immédiatement supprimées physiquement du stockage d’objets.

L’espace de stockage peut être libéré ultérieurement lors de la compaction. La compaction est un processus en arrière-plan qui réorganise les fichiers de données existants en de nouveaux fichiers plus compacts. Une fois un champ supprimé, les fichiers nouvellement compactés respectent le schéma actuel et omettent le champ supprimé. Milvus ne garantit pas une réduction immédiate ou dans un délai fixe de l’espace de stockage après la suppression d’un champ.

Que se passe-t-il si j’ajoute un champ scalaire portant le même nom qu’une clé de champ dynamique ?

Si les champs dynamiques sont activés, vous pouvez ajouter un champ scalaire portant le même nom qu’une clé de champ dynamique existante. Le nouveau champ scalaire masque la clé de champ dynamique dans le résultat normal de la requête, mais les données dynamiques d’origine sont conservées dans $meta.

Par exemple, si des entités existantes stockent une clé dynamique nommée source et que vous ajoutez par la suite un champ scalaire nommé source, le résultat normal de la requête source fait référence au champ scalaire. Pour accéder à la valeur dynamique d’origine, utilisez la syntaxe de chemin $meta, par exemple $meta["source"].