Déchiquetage JSONCompatible with Milvus 2.6.2+

Le déchiquetage JSON accélère les requêtes JSON en convertissant le stockage traditionnel basé sur les lignes en un stockage optimisé en colonnes. Tout en conservant la flexibilité de JSON pour la modélisation des données, Milvus effectue une optimisation en colonne en coulisse qui améliore considérablement l'accès et l'efficacité des requêtes.

Le déchiquetage JSON est efficace pour la plupart des scénarios de requête JSON. Les avantages en termes de performances sont plus prononcés dans les cas suivants

• Documents JSON plus volumineux et plus complexes - Gains de performance plus importants à mesure que la taille du document augmente

• Charges de travail lourdes en lecture - Filtrage, tri ou recherche fréquents sur les clés JSON

• Modèles de requêtes mixtes - Les requêtes portant sur différentes clés JSON bénéficient de l'approche de stockage hybride.

Comment cela fonctionne-t-il ?

Le processus de déchiquetage JSON se déroule en trois phases distinctes afin d'optimiser les données pour une récupération rapide.

Phase 1 : Ingestion et classification des clés

Au fur et à mesure que de nouveaux documents JSON sont écrits, Milvus les échantillonne et les analyse en continu afin d'établir des statistiques pour chaque clé JSON. Cette analyse comprend le taux d'occurrence de la clé et la stabilité du type (si son type de données est cohérent entre les documents).

Sur la base de ces statistiques, les clés JSON sont classées dans les catégories suivantes pour un stockage optimal.

Catégories de clés JSON

Type de clé	Description des clés
Clés typées	Clés qui existent dans la plupart des documents et qui ont toujours le même type de données (par exemple, tous les entiers ou toutes les chaînes).
Clés dynamiques	Clés qui apparaissent fréquemment mais dont le type de données est mixte (par exemple, tantôt une chaîne de caractères, tantôt un nombre entier).
Clés partagées	Clés peu fréquentes ou imbriquées dont la fréquence est inférieure à un seuil configurable.

Exemple de classification

Considérons l'échantillon de données JSON contenant les clés JSON suivantes :

{"a": 10, "b": "str1", "f": 1}
{"a": 20, "b": "str2", "f": 2}  
{"a": 30, "b": "str3", "f": 3}
{"a": 40, "b": 1, "f": 4}       // b becomes mixed type
{"a": 50, "b": 2, "e": "rare"}  // e appears infrequently

Sur la base de ces données, les clés seraient classées comme suit :

• Clés typées: a et f (toujours un nombre entier)

• Clésdynamiques: b (chaîne mixte/nombre entier)

• Cléspartagées: e (clé peu fréquente)

Phase 2 : Optimisation du stockage

La classification de la phase 1 dicte la disposition du stockage. Milvus utilise un format en colonnes optimisé pour les requêtes.

Flux de déchiquetage Json

• Colonnes déchiquetées: Pour les clés typées et dynamiques, les données sont écrites dans des colonnes dédiées. Ce stockage en colonnes permet des analyses rapides et directes lors des requêtes, car Milvus peut lire uniquement les données requises pour une clé donnée sans traiter l'ensemble du document.

• Colonne partagée: Toutes les clés partagées sont stockées ensemble dans une seule colonne JSON binaire compacte. Un index inversé des clés partagées est construit sur cette colonne. Cet index est essentiel pour accélérer les requêtes sur les clés à faible fréquence en permettant à Milvus d'élaguer rapidement les données, en réduisant efficacement l'espace de recherche aux seules lignes qui contiennent la clé spécifiée.

Phase 3 : Exécution des requêtes

La phase finale exploite la disposition optimisée du stockage pour sélectionner intelligemment le chemin le plus rapide pour chaque prédicat de requête.

• Chemin rapide: Les requêtes portant sur des clés typées/dynamiques (par exemple, json['a'] < 100) accèdent directement aux colonnes dédiées.

• Chemin optimisé: Les requêtes sur des clés partagées (par exemple, json['e'] = 'rare') utilisent un index inversé pour localiser rapidement les documents pertinents.

Activer le déchiquetage JSON

Pour activer cette fonctionnalité, définissez common.enabledJSONShredding comme true dans votre fichier de configuration milvus.yaml. Les nouvelles données déclencheront automatiquement le processus de déchiquetage.

# milvus.yaml
...
common:
  enabledJSONShredding: true # Indicates whether to enable JSON key stats build and load processes
...

Une fois activé, Milvus commencera à analyser et à restructurer vos données JSON dès leur ingestion, sans autre intervention manuelle.

Réglage des paramètres

Pour la plupart des utilisateurs, une fois le déchiquetage JSON activé, les paramètres par défaut des autres paramètres sont suffisants. Toutefois, vous pouvez affiner le comportement du déchiquetage JSON à l'aide de ces paramètres à l'adresse milvus.yaml.

Paramètre Nom	Description du paramètre	Valeur par défaut	Conseils de réglage
common.enabledJSONShredding	Contrôle si les processus de construction et de chargement du déchiquetage JSON sont activés.	faux	Doit être défini sur true pour activer la fonctionnalité.
common.usingjsonShreddingForQuery	Contrôle si Milvus utilise des données déchiquetées pour l'accélération.	true	Défini sur false comme mesure de récupération en cas d'échec des requêtes, pour revenir au chemin de requête d'origine.
queryNode.mmap.jsonShredding	Détermine si Milvus utilise mmap lors du chargement des données déchiquetées. Pour plus de détails, voir Utiliser mmap.	true (vrai)	Ce paramètre est généralement optimisé pour les performances. Ne l'ajustez que si vous avez des besoins ou des contraintes spécifiques en matière de gestion de la mémoire sur votre système.
dataCoord.jsonShreddingMaxColumns	Nombre maximal de clés JSON qui seront stockées dans les colonnes déchiquetées. Si le nombre de clés apparaissant fréquemment dépasse cette limite, Milvus donnera la priorité aux clés les plus fréquentes pour le déchiquetage, et les clés restantes seront stockées dans la colonne partagée.	1024	Cette limite est suffisante pour la plupart des scénarios. Pour les JSON comportant des milliers de clés fréquentes, il peut être nécessaire d'augmenter cette limite, mais surveillez l'utilisation de l'espace de stockage.
dataCoord.jsonShreddingRatioThreshold	Le taux d'occurrence minimum qu'une clé JSON doit avoir pour être considérée comme déchiquetée dans une colonne déchiquetée. Une clé est considérée comme apparaissant fréquemment si son ratio est supérieur à ce seuil.	0.3	Augmenter (par exemple, à 0,5) si le nombre de clés répondant aux critères de destruction dépasse la limite de dataCoord.jsonShreddingMaxColumns. Le seuil est alors plus strict, ce qui réduit le nombre de clés pouvant être déchiquetées. Diminuez le seuil (par exemple, à 0,1) si vous souhaitez détruire davantage de clés qui apparaissent moins fréquemment que le seuil par défaut de 30 %.

Critères de performance

Nos tests démontrent des améliorations significatives des performances pour différents types de clés JSON et modèles de requêtes.

Environnement de test et méthodologie

• Matériel: cluster 1 core/8GB

• Jeu de données: 1 million de documents provenant de JSONBench

• Taille moyenne des documents: 478,89 octets

• Durée du test: 100 secondes pour mesurer le QPS et la latence

Résultats : clés typées

Ce test a mesuré les performances lors de l'interrogation d'une clé présente dans la plupart des documents.

Expression de la requête	Valeur de la clé Type	QPS (sans déchiquetage)	QPS (avec déchiquetage)	Augmentation des performances
json['time_us'] > 0	Entier	8.69	287.50	33x
json['kind'] == 'commit'	Chaîne de caractères	8.42	126.1	14.9x

Résultats : clés partagées

Ce test s'est concentré sur l'interrogation de clés peu nombreuses et imbriquées appartenant à la catégorie "partagée".

Expression de la requête	Type de valeur de clé	QPS (sans déchiquetage)	QPS (avec déchiquetage)	Amélioration des performances
json['identity']['seq'] > 0	Entier imbriqué	4.33	385	88.9x
json['identity']['did'] == 'xxxxx'	Chaîne imbriquée	7.6	352	46.3x

Informations clés

• Lesrequêtes clés partagées présentent les améliorations les plus spectaculaires (jusqu'à 89 fois plus rapides).

• Lesrequêtes à clé typée offrent des gains de performance constants de 15 à 30 fois.

• Tous les types de requêtes bénéficient de JSON Shredding sans régression des performances.

FAQ : COMMENT VÉRIFIER SI LE DÉCHIQUETAGE JSON EST EFFICACE ?

• Comment puis-je vérifier que le déchiquetage JSON fonctionne correctement ?

  1. Tout d'abord, vérifiez si les données ont été construites en utilisant la commande show segment --format table dans l'outil Birdwatcher. Si c'est le cas, la sortie contiendra shredding_data/ et shared_key_index/ dans le champ Json Key Stats.

     Sortie de Birdwatcher

  2. Ensuite, vérifiez que les données ont été chargées en exécutant show loaded-json-stats sur le nœud de requête. La sortie affichera des détails sur les données déchiquetées chargées pour chaque nœud de requête.

• Que faire en cas d'erreur ?

  Si le processus de construction ou de chargement échoue, vous pouvez rapidement désactiver la fonctionnalité en configurant common.enabledJSONShredding=false. Pour effacer toutes les tâches restantes, utilisez la commande remove stats-task <task_id> dans Birdwatcher. Si une requête échoue, paramétrez common.usingjsonShreddingForQuery=false pour revenir au chemin de requête original, en contournant les données déchiquetées.

• Comment choisir entre le déchiquetage et l'indexation JSON ?

  • Ledéchiquetage JSON est idéal pour les clés qui apparaissent fréquemment dans vos documents, en particulier pour les structures JSON complexes. Il combine les avantages du stockage en colonnes et de l'indexation inversée, ce qui le rend bien adapté aux scénarios de lecture intensive dans lesquels vous interrogez de nombreuses clés différentes. Cependant, il n'est pas recommandé pour les très petits documents JSON, car le gain de performance est minime. Plus la proportion de la valeur de la clé par rapport à la taille totale du document JSON est faible, plus le déchiquetage permet d'optimiser les performances.

  • L'indexation JSON est plus adaptée à l'optimisation ciblée de requêtes spécifiques basées sur des clés et présente des frais généraux de stockage moins élevés. Il convient aux structures JSON les plus simples. Notez que le déchiquetage JSON ne couvre pas les requêtes sur les clés à l'intérieur des tableaux, vous avez donc besoin d'un index JSON pour accélérer ces requêtes.

  Pour plus de détails, reportez-vous à la section Vue d'ensemble des champs JSON.