Écrire des requêtes MongoDB de base

Introduction

Dans ce laboratoire, vous allez apprendre à écrire des requêtes MongoDB de base, y compris la recherche de tous les documents, la réalisation de correspondances exactes, l'utilisation d'opérateurs de requête, la sélection de champs spécifiques et la mise en forme de la sortie de la requête. Vous commencerez par récupérer tous les documents d'une collection MongoDB en utilisant la méthode find(), puis passerez à des techniques plus avancées telles que la recherche de correspondances exactes, l'utilisation d'opérateurs de requête et la personnalisation de la sortie. À la fin de ce laboratoire, vous aurez une compréhension solide des compétences fondamentales requises pour travailler avec des bases de données MongoDB.

Skills Graph

Trouver tous les documents

Dans cette étape, vous allez apprendre à récupérer tous les documents d'une collection MongoDB en utilisant la méthode find(). C'est une compétence fondamentale pour travailler avec des bases de données MongoDB.

Tout d'abord, lançons le shell MongoDB et créons une base de données d'exemple avec quelques documents avec lesquels travailler :

mongosh

Une fois dans le shell MongoDB, créez une nouvelle base de données et ajoutez quelques données d'exemple :

use bookstore
db.books.insertMany([
    { titre: "Python Basics", auteur: "John Smith", année: 2022 },
    { titre: "MongoDB Essentials", auteur: "Jane Doe", année: 2023 },
    { titre: "Web Development", auteur: "Alice Johnson", année: 2021 }
])

Maintenant, pour trouver tous les documents dans la collection books, utilisez la méthode find() sans aucun paramètre :

db.books.find();

Vous devriez voir une sortie similaire à celle-ci :

[
  {
    _id: ObjectId("..."),
    titre: 'Python Basics',
    auteur: 'John Smith',
    année: 2022
  },
  {
    _id: ObjectId("..."),
    titre: 'MongoDB Essentials',
    auteur: 'Jane Doe',
    année: 2023
  },
  {
    _id: ObjectId("..."),
    titre: 'Web Development',
    auteur: 'Alice Johnson',
    année: 2021
  }
]

Analysons ce qui s'est passé :

• use bookstore crée ou passe à la base de données bookstore
• db.books.insertMany() ajoute plusieurs documents à la collection books
• db.books.find() récupère tous les documents de la collection

Si vous voulez une sortie plus lisible, vous pouvez utiliser pretty() :

db.books.find().pretty();

Cela formatera la sortie avec des retours à la ligne et des indentations, la rendant plus facile à lire.

Rechercher des correspondances exactes

Dans cette étape, vous allez apprendre à effectuer des correspondances exactes dans les requêtes MongoDB. En vous appuyant sur l'étape précédente, nous allons continuer à utiliser notre base de données bookstore pour démontrer la récupération précise de documents.

Tout d'abord, assurez-vous d'être dans le shell MongoDB et d'utiliser la base de données bookstore :

use bookstore

Pour trouver des documents avec une correspondance exacte pour un champ spécifique, vous utiliserez la méthode find() avec un objet de requête. Cherchons un livre par son titre exact :

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

Cette requête ne renverra que le document où le titre correspond exactement à "Python Basics". Vous devriez voir une sortie comme celle-ci :

[
  {
    _id: ObjectId("..."),
    titre: 'Python Basics',
    auteur: 'John Smith',
    année: 2022
  }
]

Maintenant, essayons une correspondance exacte sur un autre champ - l'auteur :

db.books.find({ auteur: "Jane Doe" });

Vous pouvez également combiner plusieurs conditions de correspondance exacte pour resserrer votre recherche :

db.books.find({
  titre: "MongoDB Essentials",
  auteur: "Jane Doe"
});

Cette requête renverra les documents qui correspondent exactement au titre et à l'auteur.

Explorons un autre exemple avec le champ année :

db.books.find({ année: 2022 });

Notes importantes sur les correspondances exactes :

• La correspondance est sensible à la casse
• Tout le champ doit correspondre exactement
• L'ordre et l'orthographe exacte comptent

Si vous voulez voir combien de documents correspondent à votre requête, utilisez countDocuments() :

db.books.countDocuments({ année: 2022 });

Utiliser les opérateurs de requête

Dans cette étape, vous allez apprendre à utiliser les opérateurs de requête MongoDB pour effectuer des requêtes plus complexes et flexibles. Les opérateurs de requête vous permettent de créer des filtres plus avancés au-delà des correspondances exactes.

Tout d'abord, assurez-vous d'être dans le shell MongoDB en utilisant la base de données bookstore :

use bookstore

Ajoutons quelques livres supplémentaires à notre collection pour démontrer différents opérateurs :

db.books.insertMany([
  { titre: "Advanced Python", auteur: "John Smith", année: 2020, prix: 39,99 },
  {
    titre: "Data Science Handbook",
    auteur: "Jane Doe",
    année: 2019,
    prix: 45,5
  },
  {
    titre: "Machine Learning Basics",
    auteur: "Alice Johnson",
    année: 2021,
    prix: 55,25
  }
]);

Maintenant, explorons quelques opérateurs de requête courants :

1. Opérateurs Supérieur à ($gt) et Inférieur à ($lt) :
   Trouvez les livres publiés après 2020 :

db.books.find({ année: { $gt: 2020 } });

Trouvez les livres publiés avant 2020 :

db.books.find({ année: { $lt: 2020 } });

2. Opérateurs Supérieur ou égal à ($gte) et Inférieur ou égal à ($lte) :
   Trouvez les livres publiés en 2020 ou après :

db.books.find({ année: { $gte: 2020 } });

3. Opérateur Non égal ($ne) :
   Trouvez les livres n'ayant pas été écrits par John Smith :

db.books.find({ auteur: { $ne: "John Smith" } });

4. Opérateur Dans ($in) :
   Trouvez les livres d'auteurs spécifiques :

db.books.find({ auteur: { $in: ["John Smith", "Jane Doe"] } });

5. Opérateur Non dans ($nin) :
   Trouvez les livres n'étant pas de ces auteurs :

db.books.find({ auteur: { $nin: ["John Smith", "Jane Doe"] } });

6. Conditions multiples :
   Combinez les opérateurs pour des requêtes plus complexes :

db.books.find({
  année: { $gte: 2020 },
  prix: { $lt: 50 }
});

Cette requête trouve les livres publiés en 2020 ou après avec un prix inférieur à 50.

Sélectionner des champs spécifiques

Dans cette étape, vous allez apprendre à sélectionner et à projeter uniquement des champs spécifiques de vos documents MongoDB. Cela est utile lorsque vous voulez récupérer seulement les informations dont vous avez besoin, réduisant le transfert de données et améliorant les performances de requête.

Tout d'abord, assurez-vous d'être dans le shell MongoDB en utilisant la base de données bookstore :

use bookstore

1. Sélectionner des champs spécifiques :
   Pour sélectionner seulement certains champs, utilisez le second argument dans la méthode find() :

db.books.find({}, { titre: 1, auteur: 1, _id: 0 });

Analysons la requête :

• Le premier argument {} signifie aucun filtre (sélectionner tous les documents)
• Le second argument spécifie les champs à inclure
• 1 signifie inclure le champ
• _id: 0 exclut explicitement le champ _id par défaut

Vous devriez voir une sortie comme celle-ci :

[
  { titre: 'Python Basics', auteur: 'John Smith' },
  { titre: 'MongoDB Essentials', auteur: 'Jane Doe' },
...
]

2. Combiner la sélection de champs avec le filtrage :
   Vous pouvez combiner la sélection de champs avec des conditions de requête :

db.books.find({ année: { $gt: 2020 } }, { titre: 1, année: 1, _id: 0 });

Cette requête trouve les livres publiés après 2020 et renvoie seulement leurs titres et années.

3. Exclure des champs :
   Vous pouvez également exclure des champs spécifiques :

db.books.find({}, { prix: 0 });

Cela renvoie tous les champs sauf le champ prix.

4. Projeter des champs imbriqués :
   Si vous avez des documents imbriqués, vous pouvez sélectionner des champs imbriqués spécifiques :

// En supposant une structure de document plus complexe
db.books.find({}, { "auteur.nom": 1, titre: 1, _id: 0 });

Notes importantes :

• Vous ne pouvez pas mélanger l'inclusion et l'exclusion dans une seule projection (sauf pour _id)
• _id est inclus par défaut sauf s'il est explicitement défini sur 0
• Les projections aident à réduire la quantité de données transférées

Formater la sortie de la requête

Dans cette étape, vous allez apprendre à formater et à manipuler la sortie de vos requêtes MongoDB, afin de rendre vos résultats plus lisibles et utiles.

Tout d'abord, assurez-vous d'être dans le shell MongoDB en utilisant la base de données bookstore :

use bookstore

1. Affichage agréable :
   Utilisez .pretty() pour formater la sortie avec des indentations :

db.books.find().pretty();

2. Limiter les résultats :
   Utilisez .limit() pour restreindre le nombre de documents renvoyés :

db.books.find().limit(2);

3. Trier les résultats :
   Utilisez .sort() pour ordonner vos documents. L'argument est un objet spécifiant le champ et la direction de tri :

// Trier par année dans l'ordre croissant
db.books.find().sort({ année: 1 });

// Trier par année dans l'ordre décroissant
db.books.find().sort({ année: -1 });

4. Combiner les méthodes :
   Vous pouvez chaîner plusieurs méthodes de formatage :

db.books
  .find()
  .sort({ année: -1 }) // Trier par année décroissante
  .limit(3) // Obtenir les 3 premiers résultats
  .pretty(); // Formater agréablement

5. Ignorer des documents :
   Utilisez .skip() pour ignorer un nombre spécifié de documents :

// Ignorer les 2 premiers documents
db.books.find().skip(2).limit(2);

6. Compter les documents :
   Utilisez .count() ou countDocuments() pour obtenir le nombre total de documents correspondants :

// Compter tous les livres
db.books.countDocuments();

// Compter les livres publiés après 2020
db.books.countDocuments({ année: { $gt: 2020 } });

Exemple pratique :
Combinons plusieurs techniques de formatage :

db.books
  .find({ année: { $gte: 2020 } })
  .sort({ prix: 1 }) // Trier par prix croissant
  .limit(2) // Obtenir les 2 livres les moins chers après 2020
  .pretty();

Récapitulatif

Dans ce laboratoire, vous allez apprendre à effectuer des requêtes MongoDB de base, y compris la recherche de tous les documents d'une collection, la requête de correspondances exactes, l'utilisation d'opérateurs de requête, la sélection de champs spécifiques et la formatage de la sortie de la requête. Vous commencerez par apprendre à récupérer tous les documents d'une collection MongoDB en utilisant la méthode find(), qui est une compétence fondamentale pour travailler avec les bases de données MongoDB. Ensuite, vous explorerez la manière de réaliser des correspondances exactes dans les requêtes MongoDB, vous permettant de récupérer des documents avec des valeurs de champ spécifiques. Au cours du laboratoire, vous acquerrez une compréhension solide des techniques de requêtage essentiellement de MongoDB.