MongoDB Queries : comment ça marche ?

Les Queries de MongoDB (ou « requêtes ») vous per­met­tent de re­cher­cher et d’analyser votre base de données ra­pi­de­ment et ef­fi­ca­ce­ment. La structure de la méthode est très logique et permet d’utiliser de nombreux pa­ra­mètres pour spécifier les requêtes.

Re­cher­cher ef­fi­ca­ce­ment dans les col­lec­tions

En tant que solution NoSQL basée sur des documents, MongoDB offre la pos­si­bi­lité de stocker et de gérer fa­ci­le­ment des quantités de données im­por­tantes et variées. Le système de gestion de base de données est très flexible et fa­ci­le­ment modulable ho­ri­zon­ta­le­ment.

Con­trai­re­ment aux bases de données re­la­tion­nelles, les données sont ici stockées dans des documents BSON (Binary JSON) et re­grou­pées dans des col­lec­tions ou des ensembles. Pour que cette approche fonc­tionne vraiment, il faut de puissants mé­ca­nismes de requêtes qui filtrent la base de données et ne pré­sen­tent que les in­for­ma­tions dont on a vraiment besoin. Ces requêtes MongoDB par­cou­rent même les col­lec­tions les plus étendues et four­nis­sent les in­for­ma­tions re­cher­chées.

MongoDB Queries : dé­fi­ni­tion

Les requêtes MongoDB sont un outil pratique pour re­cher­cher des struc­tures de données complexes. Elles suivent des règles logiques et fonc­tion­nent comme les options de filtrage connues sur de nombreux sites Web. Vous avez ainsi la pos­si­bi­lité de formuler votre recherche de la manière la plus précise possible et pour obtenir les meilleurs résultats possibles. Cela est d’autant plus important que MongoDB offre l’option de stocker de nombreux types de données dif­fé­rents. Sans les pos­si­bi­li­tés de filtrage né­ces­saires, il serait difficile de gérer la base de données de manière sa­tis­fai­sante. Découvrez comment créer fa­ci­le­ment des Queries sur MongoDB et comment les utiliser à votre avantage dans notre guide étape par étape.

Quelles sont les con­di­tions requises sur MongoDB Queries ?

Pour pouvoir utiliser MongoDB Queries, quelques prérequis sont né­ces­saires.

1. Vous devez d’abord installer MongoDB sur votre or­di­na­teur. La base de données fonc­tionne sur de nombreux systèmes d’ex­ploi­ta­tion, c’est pourquoi le fait que vous utilisiez Linux, macOS ou Windows ne fait pas grande dif­fé­rence pour ce guide. Les étapes de travail au-delà de l’ins­tal­la­tion sont les mêmes sur tous les systèmes et ne con­cer­nent que la base de données elle-même. Pour savoir comment fonc­tionne l’ins­tal­la­tion, consultez notre tutoriel MongoDB.
2. Pour pouvoir créer des requêtes, vous devez avoir les droits d’ad­mi­nis­tra­tion.
3. Il est pré­fé­rable de créer un en­vi­ron­ne­ment de test afin de pouvoir essayer la méthode sans risque.

Création d’une col­lec­tion de tests

Ouvrez le shell et connectez-vous avec vos droits d’ad­mi­nis­tra­tion. Ensuite, créez une nouvelle col­lec­tion qui servira d’en­vi­ron­ne­ment de test pour vos premières requêtes MongoDB. Comme la méthode peut prendre en compte des documents simples mais aussi des tableaux, dif­fé­rents champs ou des documents intégrés, nous allons créer une col­lec­tion un peu plus complexe pour une dé­mons­tra­tion de l’étendue des MongoDB Queries.

Dans notre exemple, il s’agit d’une liste de clients. Le format de cette liste se présente comme suit :

{
    "name" : "Desbois",
    "units" : 642,
    "location" : ["France", "Belgium" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
}

Ce document contient les in­for­ma­tions suivantes :

• name : le nom de l’en­tre­prise cliente qui a acheté la mar­chan­dise.
• units : le nombre total de produits que l’en­tre­prise a commandés.
• location : le siège de l’autre en­tre­prise. S’il y a plusieurs suc­cur­sales, elles peuvent être en­re­gis­trées sous forme de tableau.
• tran­sac­tions : ce champ contient un autre document qui est inclus (en anglais, on parle de embedded documents ou nested documents). Chacun de ces documents tran­sac­tion­nels contient des in­for­ma­tions sur la date à laquelle l’en­tre­prise est devenue cliente (sous « first »), la date de la dernière commande (sous « last ») et enfin le nombre total de commandes (sous « total »).

Dans ce cas, les documents sup­plé­men­taires ont été insérés afin que d’autres in­for­ma­tions puissent être ajoutées ul­té­rieu­re­ment. Cela permet de préserver la vue d’ensemble.

Création de la col­lec­tion test pour les MongoDB Queries

Nous allons main­te­nant créer une col­lec­tion nommée « clients » qui, pour notre exemple, ne con­tien­dra que cinq entrées pour une meilleure vue d’ensemble. Si vous utilisez ul­té­rieu­re­ment MongoDB Queries de manière pro­fes­sion­nelle, vous pourrez créer des col­lec­tions beaucoup plus im­por­tantes. Pour cela, vous utilisez la méthode insertMany. Pour notre exemple, cela ressemble à ceci :

db.clients.insertMany ( [
{
    "name" : "Desbois",
    "units" : 642,
    "location" : ["France", "Belgium" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
},
{
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2,
    }
},
{
    "name" : "Meyer",
    "units" : 814,
    "location" : ["Luxembourg", "Germany" ],
    "transactions" : {
        "first" : {
            "year" : 2016,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 22,
    }
},
{
    "name" : "Romain",
    "units" : 313,
    "location" : ["France", "Spain" ],
    "transactions" : {
            "first" : {
            "year" : 2017,
            },
        "last" : {
            "year" : 2020,
        },
        "total" : 9,
    }
},
{
    "name" : "Jorgensen",
    "units" : 7,
    "location" : "Denmark",
    "transactions" : {
        "first" : {
            "year" : 2022,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 2,
    }
}
] )

Si vous effectuez cette saisie telle quelle ou avec vos propres données, vous obtenez en retour la liste des ID d’objets attribués. Ceux-ci sont uniques : ils per­met­tent que chaque document puisse être trouvé par son ID. Si vous voulez vous assurer que tous les documents ont été repris dans la col­lec­tion, vous pouvez utiliser MongoDB find et ainsi vous passer de pa­ra­mètres sup­plé­men­taires :

db.clients.find ( )

La sortie est une liste de tous les ID d’objets avec les documents complets, que vous pouvez main­te­nant parcourir avec MongoDB Queries.

In­ter­ro­ger des champs in­di­vi­duels avec MongoDB Queries

Cette sortie vous permet déjà de voir la valeur ajoutée des requêtes MongoDB. Dans notre exemple, la sortie produira de longues chaînes de ca­rac­tères qui rendront très difficile une recherche sans outils. Nous uti­li­se­rons donc la méthode find en spé­ci­fiant notre recherche. Pour cela, nous dé­fi­nis­sons une exigence spéciale qu’un document doit remplir pour être édité. Ainsi, nous allons re­cher­cher tous les documents dont le nom cor­res­pond à la valeur « ATS ».

db.clients.find (
    { "name" : "ATS" }
)

Les requêtes MongoDB simples de ce type re­cherchent main­te­nant tous les documents déposés dans la col­lec­tion cor­res­pon­dante et comparent ceux qui ont la valeur de nom « ATS ». Dans notre col­lec­tion, cela ne concerne qu’une seule entrée, c’est pourquoi la sortie se présente comme suit :

db.clients.find ( { "name" : "ATS" } )
{
    "_id" : ObjectID ( "673d14684o75iftbb0ct5003" ),
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2
    }

La méthode inverse fonc­tionne également. Si vous voulez afficher tous les résultats sauf l’entrée pour « ATS », choi­sis­sez l’entrée suivante et vous ob­tien­drez à nouveau un résultat très complet :

db.clients.find (
    { "name" : { $ne : "ATS" } }
)

Si vous souhaitez éditer des requêtes MongoDB avec dif­fé­rentes valeurs, c’est possible avec un tableau. Dans notre exemple, nous prenons en compte les clients « ATS » et « Jorgensen ».

db.clients.find (
    { "name" : [ $in : [ "ATS", "Jorgensen" ] } } }
)

In­ter­ro­ger plusieurs champs avec des requêtes MongoDB

Pour in­ter­ro­ger plusieurs champs, il est important de spécifier davantage votre requête, surtout si vous avez besoin de résultats très spé­ci­fiques. C’est pourquoi vous pouvez définir les requêtes MongoDB de manière encore plus précise en ajoutant des pa­ra­mètres sup­plé­men­taires. Si nous indiquons pour une requête, en plus du nom de l’en­tre­prise « ATS », la valeur du segment « units », le système recherche un document qui contient les deux valeurs :

db.clients.find (
    { "name" : "ATS", "units" : 17 }
)

Ici, il y a une cor­res­pon­dance exacte. Mais si l’une des deux valeurs ne cor­res­pond pas, aucun résultat n’est affiché de cette manière. Par exemple, la saisie suivante n’aurait aucun résultat :

db.client.find (
    { "name" : "ATS", "units" : 25 }
)

Si vous voulez prendre en compte dif­fé­rentes valeurs avec MongoDB Queries, mais qu’une saisie doit déjà avoir lieu lorsqu’au moins une des exigences est remplie, entrez ceci :

db.clients.find (
    { $or : [ {"name" : "ATS"}, {"units" : 25 } ] }
)

In­ter­ro­ger les valeurs dans les tableaux

Les valeurs dans les tableaux peuvent également être prises en compte avec les requêtes MongoDB. Dans notre exemple, il y a des en­tre­prises qui ont des filiales dans plusieurs pays. Si vous voulez éditer tous les clients qui ont au moins une suc­cur­sale en France, la saisie est très simple :

db.clients.find (
    { "location" : "France" }
)

La sortie contient main­te­nant les trois clients qui ont au moins une suc­cur­sale en France. Mais si vous voulez élargir votre entrée et récupérer en même temps les clients ayant des suc­cur­sales en France et en Belgique, utilisez pour cela un tableau :

db.clients.find (
    { "location" : [ "France", "Belgium" ] }
)

Notez que les requêtes MongoDB tiennent compte de la saisie exacte et donc, dans ce cas, de l’ordre. Si vous souhaitez prendre en compte des valeurs peu importe leur ordre dans un tableau, complétez la requête ainsi :

db.clients.find (
    { "location" : { $all : [ "France", "Belgium" ] } }
)

MongoDB Queries pour les documents intégrés

Dans notre exemple, nous avons également utilisé des documents intégrés. Ceux-ci peuvent être édités avec des requêtes MongoDB. Pour cela, vous devez ajouter un point pour signaler à MongoDB que les champs d’un document intégré doivent être analysés. Par exemple, si vous souhaitez obtenir une liste de tous les clients qui ont plus de dix commandes, saisissez ceci :

db.clients.find (
    { "transactions.total" : { $gt : 10 } }
)

Ainsi, MongoDB accède au document « tran­sac­tions » et prend ensuite en compte le nombre de commandes sous « total ».

MongoDB Queries : limiter la sortie

Avec les méthodes vues jusqu’à présent, la sortie des MongoDB Queries peut être très vo­lu­mi­neuse. Il peut donc être utile de limiter la sortie à quelques champs seulement. Pour cela, on utilise ce que l’on appelle des pro­jec­tions. Celles-ci con­tien­nent la valeur 1 (pour les champs inclus) et 0 (pour les champs qui doivent être exclus). Dans l’exemple suivant, nous ef­fec­tuons une requête en deux parties. Tout d’abord, une recherche sans pa­ra­mètres est lancée, qui con­tien­drait toutes les in­for­ma­tions. Juste après, une pro­jec­tion est effectuée, qui ne prend en compte que le champ du nom.

db.clients.find (
    { }
    { "name" : 1 } }
)

Ainsi, vous obtenez tous les résultats, mais la sortie se limite aux noms.

Utiliser les curseurs pour optimiser la sortie

Les curseurs sont une méthode per­met­tant non pas de réguler les résultats des requêtes MongoDB elles-mêmes, mais d’adapter leur rendu. Vous pouvez, entre autres, limiter le nombre de résultats ou modifier leur ordre. Si vous ne souhaitez afficher qu’une partie des résultats, utilisez la méthode limit. Cela fonc­tionne ainsi :

db.clients.find (
    { }
    { "name" : 1 } }
).limit ( 2 )

La donnée suivante permet de réor­ga­ni­ser la sortie. Ainsi, les trois clients qui ont commandé le moins de produits seront affichés :

db.clients.find (
    { }
    { "name" : 1 } }
).limit ( 2 ) .sort ( { "units" : 1 } )

1ac1a83541fe1442d0cb2adc29fc460f