MongoDB Queries : comment ça marche ?

Les Queries de MongoDB (ou « requêtes ») vous permettent de rechercher et d’analyser votre base de données rapidement et efficacement. La structure de la méthode est très logique et permet d’utiliser de nombreux paramètres pour spécifier les requêtes.

Rechercher efficacement dans les collections

En tant que solution NoSQL basée sur des documents, MongoDB offre la possibilité de stocker et de gérer facilement des quantités de données importantes et variées. Le système de gestion de base de données est très flexible et facilement modulable horizontalement.

Contrairement aux bases de données relationnelles, les données sont ici stockées dans des documents BSON (Binary JSON) et regroupées dans des collections ou des ensembles. Pour que cette approche fonctionne vraiment, il faut de puissants mécanismes de requêtes qui filtrent la base de données et ne présentent que les informations dont on a vraiment besoin. Ces requêtes MongoDB parcourent même les collections les plus étendues et fournissent les informations recherchées.

MongoDB Queries : définition

Les requêtes MongoDB sont un outil pratique pour rechercher des structures de données complexes. Elles suivent des règles logiques et fonctionnent comme les options de filtrage connues sur de nombreux sites Web. Vous avez ainsi la possibilité 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 différents. Sans les possibilités de filtrage nécessaires, il serait difficile de gérer la base de données de manière satisfaisante. Découvrez comment créer facilement des Queries sur MongoDB et comment les utiliser à votre avantage dans notre guide étape par étape.

Quelles sont les conditions requises sur MongoDB Queries ?

Pour pouvoir utiliser MongoDB Queries, quelques prérequis sont nécessaires.

1. Vous devez d’abord installer MongoDB sur votre ordinateur. La base de données fonctionne sur de nombreux systèmes d’exploitation, c’est pourquoi le fait que vous utilisiez Linux, macOS ou Windows ne fait pas grande différence pour ce guide. Les étapes de travail au-delà de l’installation sont les mêmes sur tous les systèmes et ne concernent que la base de données elle-même. Pour savoir comment fonctionne l’installation, consultez notre tutoriel MongoDB.
2. Pour pouvoir créer des requêtes, vous devez avoir les droits d’administration.
3. Il est préférable de créer un environnement de test afin de pouvoir essayer la méthode sans risque.

Création d’une collection de tests

Ouvrez le shell et connectez-vous avec vos droits d’administration. Ensuite, créez une nouvelle collection qui servira d’environnement de test pour vos premières requêtes MongoDB. Comme la méthode peut prendre en compte des documents simples mais aussi des tableaux, différents champs ou des documents intégrés, nous allons créer une collection un peu plus complexe pour une démonstration 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 informations suivantes :

• name : le nom de l’entreprise cliente qui a acheté la marchandise.
• units : le nombre total de produits que l’entreprise a commandés.
• location : le siège de l’autre entreprise. S’il y a plusieurs succursales, elles peuvent être enregistrées sous forme de tableau.
• transactions : ce champ contient un autre document qui est inclus (en anglais, on parle de embedded documents ou nested documents). Chacun de ces documents transactionnels contient des informations sur la date à laquelle l’entreprise 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 supplémentaires ont été insérés afin que d’autres informations puissent être ajoutées ultérieurement. Cela permet de préserver la vue d’ensemble.

Création de la collection test pour les MongoDB Queries

Nous allons maintenant créer une collection nommée « clients » qui, pour notre exemple, ne contiendra que cinq entrées pour une meilleure vue d’ensemble. Si vous utilisez ultérieurement MongoDB Queries de manière professionnelle, vous pourrez créer des collections beaucoup plus importantes. 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 permettent que chaque document puisse être trouvé par son ID. Si vous voulez vous assurer que tous les documents ont été repris dans la collection, vous pouvez utiliser MongoDB find et ainsi vous passer de paramètres supplémentaires :

db.clients.find ( )

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

Interroger des champs individuels 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 caractères qui rendront très difficile une recherche sans outils. Nous utiliserons donc la méthode find en spécifiant notre recherche. Pour cela, nous définissons une exigence spéciale qu’un document doit remplir pour être édité. Ainsi, nous allons rechercher tous les documents dont le nom correspond à la valeur « ATS ».

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

Les requêtes MongoDB simples de ce type recherchent maintenant tous les documents déposés dans la collection correspondante et comparent ceux qui ont la valeur de nom « ATS ». Dans notre collection, 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 fonctionne également. Si vous voulez afficher tous les résultats sauf l’entrée pour « ATS », choisissez l’entrée suivante et vous obtiendrez à nouveau un résultat très complet :

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

Si vous souhaitez éditer des requêtes MongoDB avec diffé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" ] } } }
)

Interroger plusieurs champs avec des requêtes MongoDB

Pour interroger plusieurs champs, il est important de spécifier davantage votre requête, surtout si vous avez besoin de résultats très spécifiques. C’est pourquoi vous pouvez définir les requêtes MongoDB de manière encore plus précise en ajoutant des paramètres supplémentaires. Si nous indiquons pour une requête, en plus du nom de l’entreprise « 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 correspondance exacte. Mais si l’une des deux valeurs ne correspond 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 diffé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 } ] }
)

Interroger 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 entreprises qui ont des filiales dans plusieurs pays. Si vous voulez éditer tous les clients qui ont au moins une succursale en France, la saisie est très simple :

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

La sortie contient maintenant les trois clients qui ont au moins une succursale en France. Mais si vous voulez élargir votre entrée et récupérer en même temps les clients ayant des succursales 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 « transactions » 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 volumineuse. Il peut donc être utile de limiter la sortie à quelques champs seulement. Pour cela, on utilise ce que l’on appelle des projections. Celles-ci contiennent la valeur 1 (pour les champs inclus) et 0 (pour les champs qui doivent être exclus). Dans l’exemple suivant, nous effectuons une requête en deux parties. Tout d’abord, une recherche sans paramètres est lancée, qui contiendrait toutes les informations. Juste après, une projection 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 permettant 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 fonctionne ainsi :

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

La donnée suivante permet de réorganiser 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 } )