PHP Master | Indexation de MongoDB, partie 1

Les plats clés

• L'indexation dans MongoDB peut considérablement améliorer les performances et le débit en réduisant le nombre de documents complets qui doivent être lus, améliorant ainsi les performances des applications.
• MongoDB prend en charge plusieurs types d'index, notamment l'index _ID par défaut, l'index secondaire, l'index des composés, l'index multikey et l'index de composé multikey. Chaque type sert un objectif spécifique et est utilisé pour différents types de requêtes.
• Plus d'un index peut être défini sur une collection, mais une requête ne peut utiliser qu'un seul index lors de son exécution. Le meilleur index est choisi lors de l'exécution par l'optimiseur de requête de MongoDB.
• Bien que l'indexation puisse améliorer considérablement les opérations de lecture, elle entraîne également ses propres coûts. Les opérations d'indexation occupent l'espace et provoquent des frais généraux supplémentaires sur chaque insert, mettez à jour et supprimez l'opération sur la collection. Par conséquent, l'indexation profite aux collections lourdes en lecture plus que les collections lourdes en écriture.

L'indexation est l'un des concepts les plus importants de travail avec MongoDB. Une bonne compréhension est essentielle car l'indexation peut augmenter considérablement les performances et le débit en réduisant le nombre de documents complets à lire, augmentant ainsi les performances de notre application. Parce que les index peuvent être un peu difficiles à comprendre, cette série en deux parties les examinera de plus près. Dans cet article, nous explorerons les cinq types d'index suivants:

1. Index _id par défaut
2. Index secondaire
3. Index des composés
4. Index Multikey
5. Index du composé multikey

Il existe également d'autres types à discuter, mais je les ai logiquement gardés pour la partie 2 pour fournir une compréhension claire et éviter toute confusion. Bien que plus d'un index puisse être défini sur une collection, une requête ne peut utiliser qu'un seul index lors de son exécution. La décision de choisir le meilleur index des options disponibles est prise lors de l'exécution par l'optimiseur de requête de MongoDB. Cet article suppose que vous avez une compréhension de base des concepts MongoDB (comme les collections, les documents, etc.) et effectuer des requêtes de base en utilisant PHP (comme trouver et insérer). Sinon, je vous suggère de lire nos articles débutants: Introduction à MongoDB et MongoDB Revisité. Pour la série, nous supposerons que nous avons une collection nommée Posts rempli de 500 documents ayant la structure suivante:

<span>{
</span>    <span>"_id": <span>ObjectId</span>("5146bb52d852470060001f4"),
</span>    <span>"comments": {
</span>        <span>"0": "This is the first comment",
</span>        <span>"1": "This is the second comment"
</span>    <span>},
</span>    <span>"post_likes": 40,
</span>    <span>"post_tags": {
</span>        <span>"0": "MongoDB",
</span>        <span>"1": "Tutorial",
</span>        <span>"2": "Indexing"
</span>    <span>},
</span>    <span>"post_text": "Hello Readers!! This is my post text",
</span>    <span>"post_type": "private",
</span>    <span>"user_name": "Mark Anthony"
</span><span>}</span>

Maintenant, explorons en détail divers types d'indexation.

Index _id par défaut

Par défaut, MongoDB crée un index par défaut sur le champ _ID pour chaque collection. Chaque document a un champ _ID unique comme clé primaire, un objetId de 12 octets. Lorsqu'il n'y a aucun autre index disponible, cela est utilisé par défaut pour toutes sortes de requêtes. Pour afficher les index d'une collection, ouvrez la coque MongoDB et procédez comme suit:

La méthode getIndexes () renvoie tous les index de notre collection. Comme vous pouvez le voir, nous avons l'index par défaut avec le nom _id_ . Le champ de clé indique que l'index est sur le champ _ID et que la valeur de 1 indique un ordre ascendant. Nous apprendrons la commande dans la section suivante.

Index secondaire

Pour les cas où nous voulons utiliser l'indexation sur des champs autres que le champ _ID, nous devons définir des index personnalisés. Supposons que nous souhaitions rechercher des publications basées sur le champ User_name. Dans ce cas, nous définirons un index personnalisé sur le champ User_name de la collection. Ces index personnalisés, autres que l'index par défaut, sont appelés index secondaires. Pour démontrer l'effet de l'indexation sur la base de données, analysons brièvement les performances de la requête sans indexer d'abord. Pour cela, nous allons exécuter une requête pour trouver tous les articles ayant un user_name avec "Jim Alexandar".

<span>{
</span>    <span>"_id": <span>ObjectId</span>("5146bb52d852470060001f4"),
</span>    <span>"comments": {
</span>        <span>"0": "This is the first comment",
</span>        <span>"1": "This is the second comment"
</span>    <span>},
</span>    <span>"post_likes": 40,
</span>    <span>"post_tags": {
</span>        <span>"0": "MongoDB",
</span>        <span>"1": "Tutorial",
</span>        <span>"2": "Indexing"
</span>    <span>},
</span>    <span>"post_text": "Hello Readers!! This is my post text",
</span>    <span>"post_type": "private",
</span>    <span>"user_name": "Mark Anthony"
</span><span>}</span>

Une méthode importante souvent utilisée avec l'indexation est d'expliquer () qui renvoie les informations pertinentes à l'indexation. La sortie de ce qui précède explique () est comme indiqué ci-dessous:

Certaines des clés importantes qui méritent d'être examinées sont:

1. Cursor - Indique l'index utilisé dans la requête. BasicCursor Indique que l'index _ID par défaut a été utilisé et MongoDB a dû rechercher toute la collection. En allant de l'avant, nous verrons que lorsque nous appliquerons l'indexation, btreecursor sera utilisé à la place de BasicCursor .
2. n - indique le nombre de documents renvoyés par la requête (un document dans ce cas).
3. NSCannedObjects - Indique le nombre de documents recherchés par la requête (dans ce cas, les 500 documents de la collection ont été recherchés). Cela peut être une opération avec de grandes frais généraux si le nombre de documents dans la collection est très grand.
4. nscanned - indique le nombre de documents analysés pendant l'opération de base de données.

Idéalement, n devrait être égal ou proche de NSCAnned, ce qui signifie qu'un nombre minimum de documents ont été recherchés. Maintenant, exécutons la même requête mais en utilisant un index secondaire. Pour créer l'index, exécutez ce qui suit dans le shell MongoDB:

Nous avons créé un index sur le champ User_name dans la collection de publications à l'aide de la méthode assureIndex (). Je suis sûr que vous avez nul la valeur de l'argument de l'ordre sur la méthode qui indique une commande ascendante (1) ou descendante (-1) pour la recherche. Pour mieux comprendre cela, notez que chaque document a un champ d'horodatage. Si nous voulons d'abord les messages les plus récents, nous utiliserions l'ordre descendant. Pour les messages les plus anciens en premier, nous choisissons l'ordre croissant. Après avoir créé l'index, les mêmes méthodes Find () et Explication () sont utilisées pour exécuter et analyser la requête comme précédemment. La sortie de est:

La sortie montre que la requête a utilisé un btreecursor nommé user_name_1 (que nous avons défini précédemment) et a analysé un seul document par opposition aux 500 documents recherchés dans la requête précédente sans indexation. Pour l'instant, comprenez que tous les index MongoDB utilisent une structure de données BTREE dans son algorithme, et Btreecursor est le curseur par défaut pour cela. Une discussion détaillée de Btreecursor est hors de portée pour cet article, mais cela n'affecte aucune compréhension supplémentaire. La comparaison ci-dessus indique comment les index peuvent améliorer considérablement les performances de la requête.

Index des composés

Il y aura des cas lorsqu'une requête utilisera plus d'un champ. Dans de tels cas, nous pouvons utiliser des index de composés. Considérez la requête suivante qui utilise à la fois les champs post_type et post_likes:

<span>{
</span>    <span>"_id": <span>ObjectId</span>("5146bb52d852470060001f4"),
</span>    <span>"comments": {
</span>        <span>"0": "This is the first comment",
</span>        <span>"1": "This is the second comment"
</span>    <span>},
</span>    <span>"post_likes": 40,
</span>    <span>"post_tags": {
</span>        <span>"0": "MongoDB",
</span>        <span>"1": "Tutorial",
</span>        <span>"2": "Indexing"
</span>    <span>},
</span>    <span>"post_text": "Hello Readers!! This is my post text",
</span>    <span>"post_type": "private",
</span>    <span>"user_name": "Mark Anthony"
</span><span>}</span>

L'analyse de cette requête avec Explication () donne le résultat suivant, qui montre que la requête utilise BasicCursor et que les 500 documents sont analysés pour récupérer un document.

Ceci est très inefficace, alors appliquons certains index. Nous pouvons définir un index composé sur les champs post_type et post_likes comme suit:

L'analyse de la requête donne désormais le résultat de suivi:

Un point très important ici est que les index de composés définis sur plusieurs champs peuvent être utilisés pour interroger un sous-ensemble de ces champs. Par exemple, supposons qu'il existe un index composé {Field1, Field2, Field3}. Cet index peut être utilisé pour interroger sur:

• field1
• field1, field2
• Field1, Field2, Field3

Donc, si nous avons défini l'index {Field1, Field2, Field3}, nous n'avons pas besoin de définir des index séparés {field1} et {field1, field2}. Cependant, si nous avons besoin de cet index de composé lors de l'interrogation Field2 et Field2, Field3, nous pouvons utiliser Hint () si l'Optimiseur ne sélectionne pas l'index souhaité. La méthode Hint () peut être utilisée pour forcer MongoDB à utiliser un index que nous spécifions et remplacez le processus de sélection et d'optimisation de requête par défaut. Vous pouvez spécifier les noms de champ utilisés dans l'index comme un argument comme indiqué ci-dessous:

<span><span><?php
</span></span><span><span>// query to find posts with user_name "Jim Alexandar"
</span></span><span><span>$cursor = $collection->find(
</span></span><span>    <span>array("user_name" => "Jim Alexandar")
</span></span><span><span>);
</span></span><span><span>//  use explain() to get explanation of query indexes
</span></span><span><span>var_dump($cursor->explain());</span></span>

Cela garantit que la requête utilise l'index composé défini sur les champs post_type et post_likes.

Index Multikey

Lorsque l'indexation est effectuée sur un champ de tableau, elle est appelée un index multiplié. Considérez à nouveau notre document postal; Nous pouvons appliquer un index multi-out sur Post_Tags. L'indice multikey indexerait chaque élément du tableau, donc dans ce cas, des index distincts seraient créés pour les valeurs post_tags: MongoDB , Tutoriel , Indexation , et et bientôt.

Les index sur les champs de tableau doivent être utilisés très sélectivement, car ils consomment beaucoup de mémoire en raison de l'indexation de chaque valeur.

Index du composé multikey

Nous pouvons créer un index de composé à plusieurs fois, mais avec la limitation qui, au maximum, un champ de l'index peut être un tableau. Donc, si nous avons Field1 en tant que chaîne, et [Field2, Field3] en tant que tableau, nous ne pouvons pas définir l'index {Field2, Field3} puisque les deux champs sont des tableaux. Dans l'exemple ci-dessous, nous créons un index sur les champs post_tags et user_name:

Limitations et considérations d'indexation

Il est important de savoir que l'indexation ne peut pas être utilisée dans les requêtes qui utilisent des expressions régulières, des opérateurs de négation (c'est-à-dire $ ne, $ pas, etc.), des opérateurs arithmétiques (c'est-à-dire $ mod, etc.), des expressions javascript dans le $ où clause, et dans certains autres cas. Les opérations d'indexation ont également leur propre coût. Chaque index occupe l'espace et provoque des frais généraux supplémentaires sur chaque insert, mise à jour et supprimer l'opération sur la collection. Vous devez considérer le rapport lecture: écriture pour chaque collection; L'indexation est bénéfique pour les collections lourdes en lecture, mais peut ne pas être pour les collections lourdes en écriture. MongoDB conserve des index dans la RAM. Assurez-vous que la taille totale de l'indice ne dépasse pas la limite de RAM. Si c'est le cas, certains index seront supprimés de la RAM et donc les requêtes ralentiront. De plus, une collection peut avoir un maximum de 64 index.

Résumé

C’est tout pour cette partie. Pour résumer, les index sont très bénéfiques pour une application si une approche d'indexation appropriée est choisie. Dans la partie suivante, nous examinerons l'utilisation d'index sur des documents intégrés, des sous-documents et la commande. Restez à l'écoute! Image via Fotolia

Les questions fréquemment posées sur l'indexation de MongoDB

Quelle est l'importance de l'indexation de MongoDB dans la gestion des bases de données?

L'indexation de MongoDB est un aspect essentiel de la gestion des bases de données. Il améliore considérablement les performances des opérations de base de données en fournissant un chemin plus efficace vers les données. Sans index, MongoDB doit effectuer une analyse de collection, c'est-à-dire la numérisation de chaque document d'une collection, pour sélectionner les documents qui correspondent à l'instruction de requête. Avec les index, MongoDB peut limiter sa recherche aux parties pertinentes des données, réduisant ainsi la quantité de données dont il a besoin pour scanner. Il en résulte des temps de réponse de requête plus rapides et une utilisation inférieure au processeur, ce qui est particulièrement bénéfique dans les grandes bases de données.

Comment fonctionne l'indexation de MongoDB?

L'indexation de MongoDB fonctionne en créant une structure de données spéciale qui contient une petite partie des données de la collection. Cette structure de données comprend la valeur d'un champ ou d'un ensemble spécifique de champs, ordonnés par la valeur du champ, comme spécifié dans l'index. Lorsqu'une requête est exécutée, MongoDB utilise ces index pour limiter le nombre de documents qu'il doit inspecter. Les index sont particulièrement bénéfiques lorsque la taille totale des documents dépasse la RAM disponible.

Quels sont les différents types d'index dans MongoDB?

MongoDB prend en charge plusieurs types d'index que vous pouvez utiliser pour améliorer pour améliorer les performances de vos requêtes. Il s'agit notamment des index de champ, composé, multikey, texte, 2D et 2DSphere. Chaque type d'index sert un objectif spécifique et est utilisé pour différents types de requêtes. Par exemple, les index de champ et de composés uniques sont utilisés pour les requêtes sur des champs uniques ou multiples, respectivement. Les index multi-likey sont utilisés pour les tableaux, et les index de texte sont utilisés pour le contenu de la chaîne.

Comment créer un index dans MongoDB?

Vous pouvez créer un index dans MongoDB à l'aide de la méthode createIndex () . Cette méthode crée un index sur un champ spécifié si l'index n'existe pas déjà. La méthode prend deux paramètres: le champ ou les champs pour indexer et un document d'options qui vous permet de spécifier des options supplémentaires.

Puis-je créer plusieurs index dans MongoDB?

Oui, vous pouvez créer plusieurs Index dans MongoDB. Cependant, il est important de noter que si les index améliorent les performances de la requête, ils consomment également les ressources système, en particulier l'espace et la mémoire disque. Par conséquent, il est crucial de créer des index judicieusement et uniquement sur les champs qui seront fréquemment interrogés.

Comment choisir les champs à indexer dans MongoDB?

Le choix des champs à indexer en index MongoDB dépend en grande partie des modèles de requête de votre application. Les champs fréquemment interrogés ou utilisés dans les opérations de tri sont de bons candidats à l'indexation. De plus, les champs avec un degré élevé de caractère unique sont également de bons candidats à l'indexation car ils peuvent réduire considérablement le nombre de documents dont le MongoDB doit scanner lors de l'exécution d'une requête.

Comment puis-je vérifier si un index existe dans MongoDB?

Vous pouvez vérifier si un index existe dans MongoDB à l'aide de la méthode getIndexes (). Cette méthode renvoie une liste de tous les index sur une collection, y compris l'index _ID qui est créé par défaut.

MongoDB utilisant la méthode DropIndex (). Cette méthode supprime l'index spécifié d'une collection.

Qu'est-ce que l'intersection d'index dans MongoDB?

L'intersection d'index est une fonctionnalité dans MongoDB qui permet à la base de données d'utiliser plus d'un index pour réaliser une requête . Cela peut être particulièrement utile lorsqu'aucun index unique ne peut satisfaire à une requête, mais l'intersection de deux ou plusieurs index ne peut.

Quel est l'impact de l'indexation sur les opérations d'écriture dans MongoDB?

Bien que l'indexation améliore considérablement les performances des opérations de lecture, elle peut avoir un impact sur les opérations d'écriture. En effet, chaque fois qu'un document est inséré ou mis à jour, tous les index de la collection doivent également être mis à jour. Par conséquent, plus une collection a des index, plus les opérations d'écriture seront lentes. Il est important de trouver un équilibre entre les performances de lecture et les performances d'écriture lors de la création d'index.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!