Écrire des requêtes MongoDB de base

Introduction

Dans ce laboratoire, vous apprendrez les techniques essentielles de requête MongoDB. Vous commencerez par vous connecter à une base de données et insérer des données. Ensuite, vous pratiquerez la récupération de documents, leur filtrage avec des correspondances exactes et des opérateurs de comparaison, la sélection de champs spécifiques à retourner, et la mise en forme de la sortie en triant et en limitant les résultats. À la fin de ce laboratoire, vous aurez une base solide pour interroger des données dans une base de données MongoDB.

Se connecter à MongoDB et trouver tous les documents

Dans cette première étape, vous allez vous connecter au serveur MongoDB, créer une base de données et une collection, insérer des données d'exemple, puis récupérer tous les documents de cette collection. C'est le point de départ de toute interaction avec une base de données.

Tout d'abord, ouvrez votre terminal et démarrez le Shell MongoDB en exécutant la commande mongosh.

mongosh

L'invite de votre terminal changera pour indiquer que vous êtes maintenant dans le Shell MongoDB, prêt à exécuter des commandes de base de données.

Ensuite, basculez vers une nouvelle base de données nommée bookstore. Si la base de données n'existe pas, MongoDB la créera lorsque vous y stockerez des données pour la première fois.

use bookstore

Maintenant, insérons quelques documents dans une nouvelle collection appelée books. Une collection est un groupe de documents MongoDB, similaire à une table dans une base de données relationnelle. La méthode insertMany() vous permet d'ajouter plusieurs documents à la fois.

db.books.insertMany([
  { title: "Python Basics", author: "John Smith", year: 2022, stock: 15 },
  { title: "MongoDB Essentials", author: "Jane Doe", year: 2023, stock: 8 },
  { title: "Web Development", author: "Alice Johnson", year: 2021, stock: 20 }
]);

Après avoir exécuté la commande, vous verrez une confirmation que les documents ont été insérés avec succès.

Pour récupérer et afficher tous les documents de la collection books, utilisez la méthode find() sans aucun argument.

db.books.find();

La sortie listera les trois documents que vous venez d'insérer. Chaque document possède un champ _id, qui est un identifiant unique ajouté automatiquement par MongoDB.

[
  {
    _id: ObjectId("..."),
    title: 'Python Basics',
    author: 'John Smith',
    year: 2022,
    stock: 15
  },
  {
    _id: ObjectId("..."),
    title: 'MongoDB Essentials',
    author: 'Jane Doe',
    year: 2023,
    stock: 8
  },
  {
    _id: ObjectId("..."),
    title: 'Web Development',
    author: 'Alice Johnson',
    year: 2021,
    stock: 20
  }
]

Interroger des documents avec des correspondances exactes

Maintenant que vous pouvez récupérer tous les documents, l'étape suivante consiste à les filtrer pour en trouver des spécifiques. Vous pouvez le faire en fournissant un document de filtre de requête à la méthode find(). Cela vous permet d'effectuer des correspondances exactes sur les valeurs des champs.

Recherchons le livre avec le titre exact "Python Basics". Le filtre de requête { title: "Python Basics" } indique à MongoDB de retourner uniquement les documents dont le champ title est exactement "Python Basics".

db.books.find({ title: "Python Basics" });

La commande retournera uniquement le document qui correspond aux critères :

[
  {
    _id: ObjectId("..."),
    title: 'Python Basics',
    author: 'John Smith',
    year: 2022,
    stock: 15
  }
]

Vous pouvez également effectuer des requêtes basées sur d'autres champs, tels que des nombres. Par exemple, pour trouver tous les livres publiés en 2021 :

db.books.find({ year: 2021 });

Pour créer une requête plus spécifique, vous pouvez spécifier plusieurs champs dans le document de filtre. Cela crée une condition "ET" implicite, ce qui signifie que toutes les conditions spécifiées doivent être vraies pour qu'un document soit retourné. Recherchons un livre écrit par "Jane Doe" ET publié en 2023.

db.books.find({ author: "Jane Doe", year: 2023 });

Cette requête retournera le livre "MongoDB Essentials", car c'est le seul qui correspond à la fois à l'auteur et à l'année.

Filtrer avec des opérateurs de comparaison

Les correspondances exactes sont utiles, mais il est souvent nécessaire de trouver des documents basés sur des comparaisons, comme trouver tous les livres publiés après une certaine année ou avec un stock supérieur à un certain niveau. MongoDB fournit un ensemble d'opérateurs de requête à cet effet.

Les opérateurs de comparaison sont spécifiés dans le document de requête en utilisant une syntaxe telle que { champ: { $opérateur: valeur } }.

Trouvons tous les livres publiés après 2021. Nous utiliserons l'opérateur "supérieur à", $gt.

db.books.find({ year: { $gt: 2021 } });

Cela retournera "Python Basics" (2022) et "MongoDB Essentials" (2023).

Voici quelques autres opérateurs de comparaison courants :

• $lt : inférieur à
• $gte : supérieur ou égal à
• $lte : inférieur ou égal à
• $ne : différent de

Par exemple, pour trouver tous les livres avec un stock de 15 ou moins, vous pouvez utiliser l'opérateur $lte.

db.books.find({ stock: { $lte: 15 } });

Un autre opérateur utile est $in, qui correspond à l'une des valeurs spécifiées dans un tableau. Trouvons tous les livres écrits par "John Smith" ou "Alice Johnson".

db.books.find({ author: { $in: ["John Smith", "Alice Johnson"] } });

Cette requête retournera "Python Basics" et "Web Development". Vous pouvez combiner des opérateurs avec des correspondances exactes pour construire des requêtes plus complexes. Par exemple, trouvez les livres publiés en 2022 ou après, avec un stock inférieur à 20.

db.books.find({ year: { $gte: 2022 }, stock: { $lt: 20 } });

Sélectionner des champs spécifiques à retourner (Projection)

Par défaut, les requêtes MongoDB retournent tous les champs des documents correspondants. Pour améliorer les performances et rendre la sortie plus claire, vous pouvez spécifier les champs à retourner. C'est ce qu'on appelle la projection.

La projection est gérée par le deuxième argument de la méthode find(). Cet argument est un document dans lequel vous spécifiez les champs à inclure avec un 1 ou à exclure avec un 0.

Récupérons tous les livres mais retournons uniquement leurs champs title et author. Le premier argument, {}, est un filtre vide, qui correspond à tous les documents.

db.books.find({}, { title: 1, author: 1 });

Vous remarquerez que le champ _id est toujours inclus dans la sortie. Le champ _id est toujours retourné par défaut. Pour l'exclure, vous devez explicitement le définir à 0.

db.books.find({}, { title: 1, author: 1, _id: 0 });

Maintenant, la sortie sera beaucoup plus propre, ne contenant que les champs demandés :

[
  { "title": "Python Basics", "author": "John Smith" },
  { "title": "MongoDB Essentials", "author": "Jane Doe" },
  { "title": "Web Development", "author": "Alice Johnson" }
]

Vous pouvez combiner un filtre de requête avec une projection. Par exemple, trouvons les livres publiés en 2023 et retournons uniquement leurs titres.

db.books.find({ year: 2023 }, { title: 1, _id: 0 });

Cette fonctionnalité puissante vous permet d'adapter les résultats de la requête à ce dont votre application a exactement besoin, en réduisant les transferts de données inutiles.

Trier, ignorer et limiter les résultats

Souvent, vous devez contrôler l'ordre et la quantité des résultats retournés par une requête. MongoDB fournit des méthodes de curseur que vous pouvez chaîner à une requête find() pour trier, ignorer et limiter les documents dans l'ensemble de résultats.

Pour trier les résultats, utilisez la méthode .sort(). Elle prend un document spécifiant le champ sur lequel trier et la direction : 1 pour ascendant et -1 pour descendant. Triions les livres par année dans l'ordre décroissant (les plus récents d'abord).

db.books.find().sort({ year: -1 });

Pour limiter le nombre de documents retournés, utilisez la méthode .limit(). Par exemple, pour obtenir seulement les 2 livres les plus récents :

db.books.find().sort({ year: -1 }).limit(2);

La méthode .skip() est utilisée pour ignorer un nombre spécifié de documents depuis le début de l'ensemble de résultats. Ceci est utile pour implémenter la pagination. Récupérons tous les livres, mais ignorons le premier.

db.books.find().sort({ year: 1 }).skip(1);

Vous pouvez chaîner ces méthodes ensemble pour créer des requêtes puissantes et précises. Par exemple, pour trouver le deuxième livre le plus ancien de la collection, vous pouvez trier par année ascendante, ignorer le premier résultat et limiter la sortie à un.

db.books.find().sort({ year: 1 }).skip(1).limit(1);

Cette commande retournera le livre "Python Basics", qui a été publié en 2022.

Enfin, pour quitter le shell MongoDB, tapez exit ou appuyez sur Ctrl+D.

exit;

Résumé

Dans ce laboratoire, vous avez appris les bases de l'écriture de requêtes simples dans MongoDB. Vous avez commencé par vous connecter à une base de données avec le shell mongosh et insérer des documents dans une collection. Vous avez ensuite pratiqué la récupération de documents à l'aide de find(), le filtrage des résultats avec des correspondances exactes et des opérateurs de comparaison tels que $gt et $in, et l'utilisation de la projection pour sélectionner des champs spécifiques. Enfin, vous avez appris à formater la sortie en chaînant des méthodes de curseur comme .sort(), .limit() et .skip() pour contrôler l'ordre et la taille de votre ensemble de résultats. Ces compétences constituent la base de l'interaction et de la gestion des données dans MongoDB.