Trier et Limiter les Résultats MongoDB

Introduction

Dans ce laboratoire, vous apprendrez les techniques fondamentales de requête MongoDB pour trier, limiter et filtrer les résultats de la base de données. Ces compétences sont essentielles pour gérer et récupérer des données efficacement. Vous travaillerez avec le shell MongoDB (mongosh) pour effectuer ces opérations sur une collection d'échantillons de documents.

Le laboratoire vous guidera à travers le tri des documents par un ou plusieurs champs, le contrôle du nombre de résultats renvoyés à l'aide de limites et de décalages (offsets), et le comptage des documents qui correspondent à des critères spécifiques. À la fin de ce laboratoire, vous aurez une solide compréhension de la manière d'organiser et de récupérer des données à partir d'une base de données MongoDB.

Trier les Documents par un Champ Unique

Dans cette étape, vous apprendrez à trier les documents d'une collection MongoDB. Le tri vous permet d'organiser les résultats d'une requête dans un ordre spécifique, ce qui est crucial pour l'analyse et la présentation des données. Votre environnement a été préconfiguré avec une base de données bookstore contenant une collection books.

Tout d'abord, ouvrez le shell MongoDB pour interagir avec la base de données. Dans votre terminal, exécutez la commande suivante :

mongosh

Une fois dans le shell, basculez vers la base de données bookstore.

use bookstore

Pour voir les documents de la collection books, vous pouvez utiliser la méthode find().

db.books.find();

Maintenant, trions ces documents. Pour trier par un seul champ, vous chaînez la méthode .sort() à une requête find(). La méthode sort() prend un objet spécifiant le champ par lequel trier et la direction : 1 pour ascendant et -1 pour descendant.

Trions les livres par nombre de pages dans l'ordre ascendant (du moins au plus de pages).

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

Vous verrez le livre avec le moins de pages, "Python Basics", listé en premier.

[
  {
    _id: ObjectId('...'),
    title: 'Python Basics',
    pages: 250,
    price: 29.99
  },
  {
    _id: ObjectId('...'),
    title: 'MongoDB Fundamentals',
    pages: 300,
    price: 34.99
  },
  ...
]

Ensuite, trions les livres par prix dans l'ordre descendant pour trouver d'abord les plus chers.

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

Cette commande affichera "Data Science" en premier, car il a le prix le plus élevé.

[
  {
    _id: ObjectId('...'),
    title: 'Data Science',
    pages: 350,
    price: 44.99
  },
  {
    _id: ObjectId('...'),
    title: 'JavaScript Advanced',
    pages: 400,
    price: 39.99
  },
  ...
]

Trier par Plusieurs Champs

Parfois, trier par un seul champ ne suffit pas. MongoDB vous permet de spécifier plusieurs clés de tri pour créer des ordres plus précis. Dans cette étape, vous apprendrez à trier les documents en fonction d'une séquence de champs.

Ajoutons quelques livres supplémentaires à notre collection pour mieux illustrer le tri par plusieurs clés. Ces nouveaux livres ont le même prix qu'un livre existant mais avec des nombres de pages différents.

db.books.insertMany([
  { title: "Machine Learning", pages: 420, price: 39.99 },
  { title: "Web Development", pages: 380, price: 39.99 }
]);

Nous avons maintenant trois livres au prix de 39,99 $. Si nous trions uniquement par prix, l'ordre de ces trois livres n'est pas garanti. Pour créer un ordre prévisible, nous pouvons ajouter une deuxième clé de tri.

Trions les livres d'abord par price dans l'ordre ascendant, puis par pages dans l'ordre descendant pour les livres ayant le même prix.

db.books.find().sort({ price: 1, pages: -1 });

Le processeur de requêtes trie d'abord tous les documents par price. Ensuite, pour les documents qui ont le même price (comme nos trois livres à 39,99 $), il les trie par pages dans l'ordre descendant.

Votre sortie pour les livres à 39,99 $ devrait apparaître dans cet ordre :

1. "Machine Learning" (420 pages)
2. "JavaScript Advanced" (400 pages)
3. "Web Development" (380 pages)

[
  ...,
  {
    _id: ObjectId('...'),
    title: 'Machine Learning',
    pages: 420,
    price: 39.99
  },
  {
    _id: ObjectId('...'),
    title: 'JavaScript Advanced',
    pages: 400,
    price: 39.99
  },
  {
    _id: ObjectId('...'),
    title: 'Web Development',
    pages: 380,
    price: 39.99
  },
  ...
]

Cette technique est utile pour créer des tris complexes et stables pour les interfaces utilisateur et les rapports.

Limiter et Ignorer les Résultats

Lorsque vous travaillez avec de grands ensembles de données, vous devez souvent récupérer uniquement un sous-ensemble des résultats. MongoDB fournit les méthodes .limit() et .skip() à cet effet. Ensemble, elles constituent la base de l'implémentation de la pagination.

La méthode .limit() restreint le nombre de documents retournés par une requête. Récupérons uniquement les 3 livres les plus chers.

db.books.find().sort({ price: -1 }).limit(3);

Cette commande trie d'abord tous les livres par prix dans l'ordre décroissant, puis retourne uniquement les trois premiers documents de la liste triée.

La méthode .skip() indique au curseur d'ignorer un nombre spécifié de documents au début de l'ensemble de résultats. Ceci est utile pour naviguer à travers les pages de données.

Par exemple, pour obtenir la deuxième page de résultats où chaque page contient 2 livres, vous ignoreriez les 2 premiers livres et limiteriez le résultat à 2. Appliquons cela à notre liste triée par prix pour obtenir les 3ème et 4ème livres les plus chers.

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

Cette requête effectue les actions suivantes dans l'ordre :

1. sort({ price: -1 }) : Trie tous les livres du plus cher au moins cher.
2. skip(2) : Ignore les 2 livres les plus chers.
3. limit(2) : Retourne les 2 livres suivants de la liste.

La sortie affichera les troisième et quatrième livres de la liste triée.

[
  {
    _id: ObjectId('...'),
    title: 'JavaScript Advanced',
    pages: 400,
    price: 39.99
  },
  {
    _id: ObjectId('...'),
    title: 'Web Development',
    pages: 380,
    price: 39.99
  }
]

En ajustant les valeurs dans skip() et limit(), vous pouvez implémenter un système de pagination complet.

Compter les Documents

Une autre exigence courante est de compter le nombre de documents dans une collection, soit au total, soit en faisant correspondre un filtre spécifique. MongoDB fournit la méthode countDocuments() à cet effet.

Pour obtenir le nombre total de livres dans notre collection, exécutez la commande suivante :

db.books.countDocuments();

Cela retournera le nombre total de documents, qui devrait être de 6 après les ajouts de l'étape 2.

Plus puissamment, countDocuments() peut accepter un filtre de requête pour ne compter que les documents qui correspondent à certains critères. Comptons combien de livres coûtent plus de 35 . Nous utilisons l'opérateur de requête `gt` (supérieur à) pour cela.

db.books.countDocuments({ price: { $gt: 35 } });

Cela retournera le nombre de livres dont le prix est supérieur à 35.

Vous pouvez également utiliser plusieurs conditions dans votre filtre. Comptons les livres dont le prix est exactement de 39,99 $ et qui ont 400 pages ou plus. Nous utilisons ici l'opérateur $gte (supérieur ou égal à).

db.books.countDocuments({ price: 39.99, pages: { $gte: 400 } });

Cette commande retournera 2, correspondant à "Machine Learning" (420 pages) et "JavaScript Advanced" (400 pages). L'utilisation de countDocuments() avec des filtres est un moyen efficace d'obtenir des statistiques sur vos données sans récupérer les documents eux-mêmes.

Pour quitter le shell MongoDB, vous pouvez taper exit ou appuyer sur Ctrl+D.

exit;

Résumé

Dans ce laboratoire, vous avez appris plusieurs techniques essentielles de requête MongoDB. Vous avez commencé par trier les documents en utilisant un seul champ, dans l'ordre ascendant et descendant, avec la méthode .sort(). Vous êtes ensuite passé au tri multi-clés, qui permet un ordonnancement plus complexe et stable des résultats.

Ensuite, vous avez exploré comment contrôler la taille de votre ensemble de résultats en utilisant .limit() pour restreindre le nombre de documents retournés et .skip() pour implémenter la pagination. Enfin, vous avez appris à utiliser countDocuments() pour compter efficacement les documents, à la fois dans une collection entière et ceux qui correspondent à des critères de filtre spécifiques. Ces commandes sont des outils fondamentaux pour tout développeur travaillant avec MongoDB.