Tutoriel sur la notation par points dans MongoDB : interroger des champs imbriqués

Si vous débutez avec MongoDB, vous avez sans doute atteint un stade où vos documents deviennent un peu complexes. Ils sont passés de données plates, proches du relationnel, à des structures avec des objets imbriqués, des tableaux imbriqués, voire quatre ou cinq niveaux d’imbrication. Alors, comment interroger ces données lorsqu’elles se trouvent à plusieurs niveaux de profondeur ?

Dans ce court tutoriel, nous allons voir la notation par points dans MongoDB et comment filtrer très rapidement et simplement nos documents en fonction de valeurs présentes dans des champs imbriqués.

Par notation par points, on entend la séparation des champs imbriqués par un point en tant que délimiteur. Par exemple :

root_field.nested_field_1.next_layer_nested_field_1

À chaque niveau d’imbrication, on ajoute simplement un point pour séparer ce niveau lors de l’interrogation. Nous verrons des exemples plus complets au fil du tutoriel.

Si vous débutez avec MongoDB, n’hésitez pas à consulter le cours Introduction to MongoDB in Python sur DataCamp.

Prérequis

Pour réussir ce tutoriel, vous devez disposer d’une instance MongoDB déployée et configurée. Autrement dit, vous êtes prêt à commencer à utiliser MongoDB. Vous devriez également connaître au moins les bases des requêtes sur les collections MongoDB. La documentation est un bon point de départ si vous avez besoin d’aide.

Pour notre exemple, nous utiliserons les données suivantes dans une base de données "dbinc" et une collection "people" :

[
    {
        "name": "Nic Raboy",
        "websites": [
            {
                "type": "other",
                "name": "Portfolio",
                "url": "https://www.nraboy.com"
            },
            {
                "type": "social",
                "name": "LinkedIn",
                "url": "https://www.linkedin.com/in/nraboy"
            }
        ],
        "employment": {
            "employer": "MongoDB",
            "address": {
                "street": "1633 Broadway",
                "city": "New York",
                "state": "New York",
                "postal_code": 10019
            }
        }
    },
    {
        "name": "Tony Kim",
        "websites": [
            {
                "type": "social",
                "name": "LinkedIn",
                "url": "https://www.linkedin.com/in/hyung-kim/"
            },
            {
                "type": "coding",
                "name": "GitHub",
                "url": "https://github.com/hjkmines"
            }
        ],
        "employment": {
            "employer": "MongoDB",
            "address": {
                "street": "1633 Broadway",
                "city": "New York",
                "state": "New York",
                "postal_code": 10019
            }
        }
    }
]

Ces données représentent deux documents d’une complexité non négligeable, avec des objets et des tableaux imbriqués. Pour l’anecdote, MongoDB prend en charge plus de 100 niveaux d’imbrication dans les documents BSON.

Si vous souhaitez suivre le tutoriel pas à pas, assurez-vous que ces documents existent dans votre instance MongoDB.

Interroger les données dans MongoDB avec différentes approches

Nous allons commencer simplement et monter progressivement en complexité. La bonne nouvelle, c’est que plus complexe ne veut pas forcément dire plus difficile.

Imaginons que nous voulions trouver toutes les personnes de la collection qui travaillent chez MongoDB. Nous pourrions exécuter une requête comme celle-ci :

use dbinc;

db.people.find({
	"employment.employer": "MongoDB"
});

Dans cet exemple, employer est un champ imbriqué dans l’objet employment. Nous pouvons l’interroger avec la notation par points, c’est-à-dire des champs séparés par des points. Ce n’est pas différent si l’on veut trouver les personnes travaillant dans l’État de New York. Nous pourrions faire :

use dbinc;

db.people.find({
	"employment.address.state": "New York"
});

Dans la requête ci-dessus, nous sommes allés trois niveaux en profondeur dans le document, sans aucun problème.

Regardons maintenant comment travailler avec ce tableau d’objets imbriqué. Il existe plusieurs façons d’interroger, selon l’objectif.

Supposons que nous voulions retourner toutes les personnes ayant un site "Portfolio". Nous pourrions exécuter une requête comme celle-ci :

use dbinc;

db.people.find({
	"websites.name": "Portfolio"
});

Cette requête renverrait un seul résultat, car un seul document comporte un "Portfolio". Remarquez que, même avec un tableau, la notation par points fonctionne toujours. Le point important, c’est que "Portfolio" doit apparaître au moins une fois dans ce tableau.

C’est là que les choses deviennent intéressantes.

Disons que nous voulons restreindre davantage les résultats. Nous allons ajouter des critères de filtrage, mais avec des objets imbriqués dans des tableaux, la logique change un peu. Par exemple :

use dbinc;

db.people.find({
    "websites.name": "Portfolio",
    "websites.type": "social"
});

Ici, nous demandons des résultats où "Portfolio" et "social" existent dans le tableau, mais pas nécessairement au sein du même objet. Nous n’obtenons qu’un résultat, car le document "Tony Kim" contient "social" mais pas "Portfolio". Si nous avions besoin que les deux champs soient présents dans le même objet, la notation par points ne suffirait pas.

Même si cela dépasse le cadre de ce tutoriel, l’opérateur $elemMatch permet de répondre à ce besoin :

use dbinc;

db.people.find(
    { 
        "websites": { 
            "$elemMatch": { 
                "name": "Portfolio",
                "type": "social" 
            }
        }
    }
);

Aucun résultat ne serait retourné dans ce cas, car nos données d’exemple n’ont pas de name et de type correspondants dans le même objet.

Si vous travaillez avec des tableaux et que vous connaissez l’index du tableau à cibler, vous pouvez continuer d’utiliser la notation par points. Par exemple :

use dbinc;

db.people.find({
    "websites.0.name": "Portfolio"
});

Cette requête utilise l’index de l’élément du tableau à vérifier. Ici, nous voulons retourner tous les documents dont le premier élément du tableau a un name égal à "Portfolio".

Même si cela dépasse le cadre de ce tutoriel, il est important de noter que la notation par points ne se limite pas aux requêtes en lecture. Vous pouvez l’utiliser, comme ici, dans les opérations de mise à jour, les projections et les pipelines d’agrégation.

Conclusion

Vous venez de découvrir rapidement comment utiliser la notation par points dans vos requêtes MongoDB. Nous avons appris :

• La notation par points fonctionne pour les objets imbriqués.
• Vous pouvez l’utiliser avec des tableaux, mais avec des limites selon vos attentes vis-à-vis de ces tableaux.
• L’opérateur $elemMatch est nécessaire si vous souhaitez faire correspondre plusieurs champs au sein d’un même objet de tableau.
• Les index de tableau dans la notation par points peuvent être utilisés pour cibler certains éléments d’un tableau.

Les données de vos collections MongoDB seront rarement plates : à un moment ou à un autre, vous aurez des objets imbriqués, des tableaux imbriqués, des tableaux dans des objets, et d’autres combinaisons plus complexes. La bonne nouvelle, c’est que MongoDB facilite grandement la manipulation de ces informations grâce à une API de requêtes riche.

Si vous n’utilisez pas encore MongoDB, découvrez MongoDB Atlas ou consultez mon autre tutoriel qui montre comment démarrer avec MongoDB et Docker. Vous pouvez aussi en savoir plus sur la MongoDB Certification dans notre guide dédié.