Trier et limiter les résultats de MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à trier et limiter les résultats d'une requête MongoDB. Le laboratoire couvre le tri des documents par un seul champ, l'utilisation de plusieurs clés de tri, la limitation du nombre de résultats, le saut de documents et le comptage du nombre de résultats. Ces techniques sont essentielles pour organiser et gérer les données dans MongoDB, vous permettant de récupérer et d'analyser efficacement les informations de votre base de données.

Le laboratoire commence par démontrer comment trier les documents par un seul champ, dans l'ordre croissant et décroissant. Il explore ensuite l'utilisation de plusieurs clés de tri, vous permettant de créer des critères de tri plus complexes. En outre, vous allez apprendre à limiter le nombre de résultats renvoyés, à sauter un certain nombre de documents et à compter le nombre total de résultats. Ces compétences sont cruciales pour optimiser vos requêtes MongoDB et adapter la sortie à vos besoins spécifiques.

Skills Graph

Trier par un seul champ

Dans cette étape, vous allez apprendre à trier les documents dans MongoDB en utilisant un seul champ. Le tri est une technique puissante qui vous permet d'organiser les résultats de votre requête dans un ordre spécifique, ce qui est essentiel pour l'analyse et la récupération de données.

Commençons par lancer le shell MongoDB dans votre terminal :

mongosh

Maintenant, créons une collection d'exemple de livres pour démontrer le tri :

use bookstore

db.books.insertMany([
    { titre: "Python Basics", pages: 250, prix: 29,99 },
    { titre: "JavaScript Advanced", pages: 400, prix: 39,99 },
    { titre: "MongoDB Fundamentals", pages: 300, prix: 34,99 },
    { titre: "Data Science", pages: 350, prix: 44,99 }
])

Dans cet exemple, nous avons créé une collection appelée books avec quatre documents. Chaque livre a un titre, un nombre de pages et un prix.

Pour trier les documents par un seul champ dans l'ordre croissant, utilisez la méthode find() avec .sort() :

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

Cette commande trie les livres par le nombre de pages dans l'ordre croissant. Le 1 indique l'ordre croissant, ce qui signifie que les livres seront triés du moins de pages au plus.

Essayons de trier par prix dans l'ordre décroissant :

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

Le -1 indique l'ordre décroissant. Cela affichera les livres les plus chers en premier. Vous devriez voir les livres triés du plus haut prix au plus bas.

Utiliser plusieurs clés de tri

Dans cette étape, vous allez apprendre à trier les documents dans MongoDB en utilisant plusieurs clés. Cette technique de tri avancée vous permet de créer des critères de tri plus complexes et précis pour vos requêtes de base de données.

Continuons d'utiliser la base de données bookstore que nous avons créée dans l'étape précédente :

use bookstore

Parfois, vous souhaiterez peut-être trier les documents par plus d'un champ. Par exemple, vous pourriez vouloir trier les livres d'abord par prix, puis par le nombre de pages dans chaque groupe de prix.

Voici comment vous pouvez utiliser plusieurs clés de tri :

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

Dans cet exemple, le tri fonctionnera comme suit :

• Tout d'abord, il trie les documents par prix dans l'ordre croissant (du plus bas au plus haut)
• Dans chaque groupe de prix, il trie ensuite par nombre de pages dans l'ordre décroissant (du plus de pages au moins de pages)

Ajoutons quelques livres supplémentaires pour démontrer cela plus clairement :

db.books.insertMany([
  { titre: "Machine Learning", pages: 400, prix: 39,99 },
  { titre: "Web Development", pages: 300, prix: 39,99 },
  { titre: "Artificial Intelligence", pages: 450, prix: 44,99 }
]);

Maintenant, exécutons notre tri à clés multiples :

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

Lorsque vous exécutez cette commande, vous remarquerez que les livres ayant le même prix sont triés par leur nombre de pages dans l'ordre décroissant.

Vous pouvez également trier dans des directions différentes pour différents champs. Par exemple :

db.books.find().sort({ prix: 1, titre: 1 });

Cela triera tout d'abord par prix dans l'ordre croissant, puis trier les livres ayant le même prix par ordre alphabétique du titre.

Limiter le nombre de résultats

Dans cette étape, vous allez apprendre à limiter le nombre de documents renvoyés par une requête MongoDB. Il s'agit d'une technique puissante pour gérer de grandes bases de données et ne récupérer que les informations les plus pertinentes.

Continuons d'utiliser la base de données bookstore :

use bookstore

MongoDB fournit la méthode .limit() pour restreindre le nombre de documents renvoyés dans une requête. Cela est particulièrement utile lorsque vous voulez :

• Afficher seulement les N premiers résultats
• Mettre en œuvre la pagination
• Réduire la quantité de données transférées

Démontrons la limitation des résultats :

// Récupérez seulement les 3 premiers livres
db.books.find().limit(3);

Cette commande renverra seulement les 3 premiers documents de la collection, quelle que soit la quantité de livres existant dans la base de données.

Vous pouvez combiner .limit() avec le tri pour obtenir des résultats encore plus spécifiques :

// Obtenez les 3 livres les plus chers
db.books.find().sort({ prix: -1 }).limit(3);

Cette requête trie d'abord les livres par prix dans l'ordre décroissant, puis renvoie seulement les 3 livres les plus chers.

Essayons un autre exemple combinant plusieurs techniques :

// Obtenez les 2 livres ayant le plus de pages
db.books.find().sort({ pages: -1 }).limit(2);

Cela renverra les deux livres ayant le plus grand nombre de pages, triés du plus de pages au moins.

Sauter des documents

Dans cette étape, vous allez apprendre à utiliser la méthode .skip() dans MongoDB pour sauter un nombre spécifié de documents dans une requête. Cette technique est cruciale pour la mise en œuvre de la pagination et la récupération de sous-ensembles spécifiques de données.

Continuons d'utiliser la base de données bookstore :

use bookstore

La méthode .skip() vous permet de contourner un certain nombre de documents avant de commencer à renvoyer les résultats. Cela est particulièrement utile lorsque vous voulez :

• Mettre en œuvre la pagination
• Sauter les premiers résultats
• Créer des requêtes basées sur un décalage

Démontrons le saut de documents :

// Sauter les 2 premiers livres
db.books.find().skip(2);

Cette commande saute les 2 premiers documents et renvoie le reste des documents de la collection.

Vous pouvez combiner .skip() avec .limit() pour créer des requêtes puissantes ressemblant à la pagination :

// Sauter les 2 premiers livres puis renvoyer les 3 suivants
db.books.find().skip(2).limit(3);

Cette requête :

1. Sautera les 2 premiers livres
2. Renverra les 3 livres suivants

Créons un exemple plus complexe en combinant le tri, le saut et la limitation :

// Trier les livres par prix, sauter les 2 plus chers et renvoyer les 2 suivants
db.books.find().sort({ prix: -1 }).skip(2).limit(2);

Cette requête :

1. Triera les livres par prix dans l'ordre décroissant
2. Sautera les 2 livres les plus chers
3. Renverra les 2 livres suivants dans la liste triée

Compter les résultats

Dans cette étape, vous allez apprendre à compter les documents dans MongoDB en utilisant différentes méthodes. Le comptage est une opération essentielle pour comprendre la taille de votre ensemble de données et filtrer les résultats.

Continuons d'utiliser la base de données bookstore :

use bookstore

MongoDB propose plusieurs façons de compter les documents. Nous allons explorer trois méthodes principales :

1. Comptage de documents de base :

// Comptez le nombre total de livres
db.books.countDocuments();

Cette méthode renvoie le nombre total de documents dans la collection books. Lorsque vous exécutez cette commande, vous verrez le comptage total de livres dans votre base de données.

2. Comptage avec un filtre :

// Comptez les livres dont le prix est supérieur à 40 $
db.books.countDocuments({ prix: { $gt: 40 } });

Ici, $gt signifie "supérieur à". Cette requête compte les livres dont le prix est supérieur à 40 $. Elle vous permet d'obtenir un comptage des documents qui correspondent à des critères spécifiques.

3. Filtrer avec plusieurs conditions :

// Comptez les livres ayant plus de 350 pages et un prix supérieur à 40 $
db.books.countDocuments({
  pages: { $gt: 350 },
  prix: { $gt: 40 }
});

Cette requête plus complexe montre comment vous pouvez combiner plusieurs conditions pour compter les documents qui répondent à des exigences spécifiques.

Ajoutons quelques livres supplémentaires pour démontrer un comptage plus complexe :

db.books.insertMany([
  { titre: "Advanced Algorithms", pages: 500, prix: 49,99 },
  { titre: "Cloud Computing", pages: 400, prix: 45,99 },
  { titre: "Network Security", pages: 350, prix: 39,99 }
]);

Maintenant, essayons quelques scénarios de comptage plus avancés :

// Comptez les livres ayant entre 300 et 450 pages
db.books.countDocuments({
  pages: {
    $gte: 300,
    $lte: 450
  }
});

Cette requête utilise $gte (supérieur ou égal) et $lte (inférieur ou égal) pour compter les livres dans une plage de pages spécifique. C'est un moyen puissant de filtrer et de compter les documents en fonction de plages numériques.

Sommaire

Dans ce laboratoire, vous avez appris à trier les résultats de MongoDB par un seul champ, en utilisant l'ordre croissant et décroissant. Vous avez également exploré l'utilisation de plusieurs clés de tri, qui vous permet de créer des critères de tri plus complexes en triant sur plusieurs champs. En outre, vous avez appris à limiter le nombre de résultats renvoyés et à sauter un certain nombre de documents, ce qui est utile pour la pagination et l'analyse de données. Enfin, vous avez découvert comment compter le nombre total de documents qui correspondent à une requête, ce qui est une fonction importante pour comprendre la taille et la portée de vos données.