Filtrer les collections MongoDB

Introduction

Dans ce laboratoire, vous apprendrez à filtrer efficacement les collections MongoDB en utilisant diverses techniques de requête. Le laboratoire couvre l'application de conditions multiples, l'utilisation d'opérateurs de comparaison, la correspondance avec des expressions régulières, la vérification de l'existence de champs et la recherche de valeurs nulles. Ces compétences sont essentielles pour une récupération de données précise dans MongoDB. Les instructions étape par étape fournissent des exemples pratiques pour vous aider à maîtriser les bases des requêtes MongoDB.

Appliquer plusieurs conditions

Dans cette étape, vous apprendrez à appliquer plusieurs conditions pour filtrer les documents d'une collection MongoDB. Cela permet des requêtes plus précises en combinant plusieurs critères.

Tout d'abord, ouvrez votre terminal et démarrez le MongoDB Shell. Ce shell interactif est l'endroit où vous exécuterez toutes vos commandes de base de données.

mongosh

Une fois dans le shell mongosh, vous verrez une invite >. Passons à une nouvelle base de données appelée school_database et créons une collection students avec quelques données d'exemple.

use school_database

db.students.insertMany([
  { name: "Alice", age: 22, grade: "A", major: "Computer Science" },
  { name: "Bob", age: 20, grade: "B", major: "Mathematics" },
  { name: "Charlie", age: 25, grade: "A", major: "Physics" },
  { name: "David", age: 19, grade: "C", major: "Computer Science" }
]);

Cette commande insère quatre documents dans la collection students. Maintenant, trouvons les étudiants qui remplissent plusieurs conditions. Nous utiliserons l'opérateur $and pour trouver les étudiants qui ont 20 ans ou plus ET qui ont une note "A".

db.students.find({
  $and: [{ age: { $gte: 20 } }, { grade: "A" }]
});

Cette requête utilise $gte, qui signifie "greater than or equal to" (supérieur ou égal à), et $and pour s'assurer que les deux conditions sont remplies. La sortie affichera Alice et Charlie :

[
  {
    _id: ObjectId("..."),
    name: 'Alice',
    age: 22,
    grade: 'A',
    major: 'Computer Science'
  },
  {
    _id: ObjectId("..."),
    name: 'Charlie',
    age: 25,
    grade: 'A',
    major: 'Physics'
  }
]

Ensuite, utilisons l'opérateur $or pour trouver les documents qui correspondent à au moins une des plusieurs conditions. Cette requête trouve les étudiants qui sont soit en "Computer Science" SOIT ont moins de 21 ans.

db.students.find({
  $or: [{ major: "Computer Science" }, { age: { $lt: 21 } }]
});

Cette requête utilise $lt, qui signifie "less than" (inférieur à). Le résultat inclura Alice et David (étudiants en Computer Science) et Bob et David (âgés de moins de 21 ans). Comme David correspond aux deux, il apparaît une seule fois.

[
  {
    _id: ObjectId("..."),
    name: 'Alice',
    age: 22,
    grade: 'A',
    major: 'Computer Science'
  },
  {
    _id: ObjectId("..."),
    name: 'Bob',
    age: 20,
    grade: 'B',
    major: 'Mathematics'
  },
  {
    _id: ObjectId("..."),
    name: 'David',
    age: 19,
    grade: 'C',
    major: 'Computer Science'
  }
]

Dans la prochaine étape, vous explorerez d'autres opérateurs de comparaison. Pour l'instant, vous pouvez rester dans le shell mongosh.

Utiliser les opérateurs de comparaison

Dans cette étape, vous utiliserez les opérateurs de comparaison de MongoDB pour construire des requêtes plus sophistiquées. Ces opérateurs vous permettent de filtrer les données en fonction de comparaisons de valeurs.

Vous devriez toujours être dans le shell mongosh de l'étape précédente. Tout d'abord, supprimons la collection existante et insérons de nouvelles données avec un champ credits sur lequel travailler.

db.students.drop();

db.students.insertMany([
  {
    name: "Alice",
    age: 22,
    grade: "A",
    major: "Computer Science",
    credits: 45
  },
  { name: "Bob", age: 20, grade: "B", major: "Mathematics", credits: 35 },
  { name: "Charlie", age: 25, grade: "A", major: "Physics", credits: 50 },
  { name: "David", age: 19, grade: "C", major: "Computer Science", credits: 25 }
]);

Maintenant, utilisons les opérateurs "greater than" ($gt) et "less than" ($lt) pour trouver les étudiants qui ont plus de 20 ans mais moins de 25 ans.

db.students.find({ age: { $gt: 20, $lt: 25 } });

Cette requête ne retournera que le document d'Alice, qui a 22 ans.

Ensuite, utilisez "greater than or equal to" ($gte) et "less than or equal to" ($lte) pour trouver les étudiants ayant entre 40 et 50 crédits, inclus.

db.students.find({ credits: { $gte: 40, $lte: 50 } });

Cette requête retournera Alice (45 crédits) et Charlie (50 crédits).

Enfin, utilisons l'opérateur "not equal to" ($ne) pour trouver tous les étudiants dont la note n'est pas "C".

db.students.find({ grade: { $ne: "C" } });

Cela retournera Alice, Bob et Charlie, en excluant David qui a la note "C". Ces opérateurs sont fondamentaux pour créer des requêtes détaillées et spécifiques dans MongoDB.

Correspondance avec les expressions régulières

Les expressions régulières (regex) offrent un moyen flexible d'effectuer des recherches textuelles puissantes. Dans cette étape, vous apprendrez à utiliser les regex dans vos requêtes MongoDB.

Tout d'abord, préparons les données pour cette étape. Supprimez la collection et insérez de nouveaux documents avec des champs de type chaîne de caractères plus détaillés.

db.students.drop();

db.students.insertMany([
  {
    name: "Alice Johnson",
    age: 22,
    major: "Computer Science",
    email: "alice.j@example.com"
  },
  {
    name: "Bob Smith",
    age: 20,
    major: "Mathematics",
    email: "bob.smith@university.edu"
  },
  {
    name: "Charlie Brown",
    age: 25,
    major: "Physics",
    email: "charlie.brown@school.org"
  },
  {
    name: "David Lee",
    age: 19,
    major: "Computer Engineering",
    email: "david.lee@tech.net"
  }
]);

Pour trouver tous les étudiants dont le nom commence par "Alice", vous pouvez utiliser l'opérateur $regex avec l'ancre ^.

db.students.find({ name: { $regex: "^Alice" } });

Cette requête retournera le document de "Alice Johnson". Le caractère ^ signifie le début de la chaîne.

Pour trouver les étudiants ayant une adresse e-mail d'un domaine spécifique, comme example.com, utilisez l'ancre $ pour faire correspondre la fin de la chaîne.

db.students.find({ email: { $regex: "@example.com$" } });

Cela trouvera "Alice Johnson" dont l'e-mail se termine par @example.com.

Vous pouvez également effectuer des recherches insensibles à la casse. La requête suivante trouve tout étudiant dont le nom contient "smith", quelle que soit la casse, en utilisant l'option i.

db.students.find({ name: { $regex: "smith", $options: "i" } });

Cette requête correspondra à "Bob Smith".

Enfin, pour trouver n'importe quelle spécialisation qui contient le mot "Computer", vous pouvez utiliser un simple motif regex sans aucune ancre.

db.students.find({ major: { $regex: "Computer" } });

Cela retournera à la fois "Alice Johnson" (Computer Science) et "David Lee" (Computer Engineering).

Vérifier l'existence des champs

Parfois, les documents d'une collection ont des structures différentes. Cette étape vous apprend comment interroger des documents en fonction de la présence ou de l'absence d'un champ spécifique.

Commençons par insérer un nouvel ensemble de documents où certains champs sont manquants.

db.students.drop();

db.students.insertMany([
  { name: "Alice", age: 22, major: "Computer Science", scholarship: 1000 },
  { name: "Bob", age: 20, major: "Mathematics" },
  { name: "Charlie", age: 25, major: "Physics", internship: "Research Lab" },
  { name: "David", age: 19, contact: { phone: "555-1234" } }
]);

Pour trouver tous les étudiants qui ont un champ scholarship, utilisez l'opérateur $exists avec la valeur true.

db.students.find({ scholarship: { $exists: true } });

Cette requête ne retournera que le document d'Alice, car elle est la seule à posséder le champ scholarship.

Inversement, pour trouver les étudiants qui n'ont pas de champ internship, définissez $exists sur false.

db.students.find({ internship: { $exists: false } });

Cela retournera les documents d'Alice, Bob et David, car aucun d'entre eux ne possède le champ internship.

L'opérateur $exists fonctionne également sur les champs imbriqués. Pour trouver un étudiant qui possède un objet contact contenant un champ phone, vous pouvez utiliser la notation par points (dot notation).

db.students.find({ "contact.phone": { $exists: true } });

Cette requête recherche spécifiquement le champ phone à l'intérieur de l'objet contact et retournera le document de David.

Trouver les valeurs Null

Dans cette dernière étape, vous apprendrez à interroger les documents qui contiennent des valeurs null. Une valeur null représente l'absence intentionnelle d'une valeur.

Tout d'abord, configurons une collection avec des documents contenant des valeurs null et des champs manquants.

db.students.drop();

db.students.insertMany([
  { name: "Alice", age: 22, email: null },
  { name: "Bob", age: 20, major: "Mathematics" },
  { name: "Charlie", age: null, major: "Physics" },
  { name: "David", contact: { email: null } }
]);

Pour trouver les documents où un champ a une valeur null, vous pouvez interroger directement null. La requête suivante trouve tous les documents où le champ email est null OU où le champ email n'existe pas.

db.students.find({ email: null });

Cette requête retournera les quatre documents : Alice (où email est explicitement null), Bob (où le champ email est manquant), Charlie (où le champ email est manquant) et David (où le champ email est manquant).

Pour trouver uniquement les documents où un champ est explicitement défini sur null, vous devez combiner la vérification de null avec une vérification $exists.

db.students.find({ email: { $type: "null" } });

Alternativement, vous pouvez utiliser l'opérateur $type. Le type BSON pour null est 10. Cette requête ne retournera que le document d'Alice.

db.students.find({ email: { $type: 10 } });

Vous pouvez également interroger les valeurs null dans les documents imbriqués. La requête suivante trouve les documents où le champ email à l'intérieur de l'objet contact est null OU où le champ contact n'existe pas.

db.students.find({ "contact.email": null });

Ceci retournera les quatre documents : Alice, Bob et Charlie (où le champ contact est manquant), et David (où contact.email est explicitement null). Comprendre comment interroger les valeurs null est crucial pour gérer les données incomplètes ou éparses.

Lorsque vous avez terminé, vous pouvez quitter le shell mongosh en tapant exit ou en appuyant sur Ctrl+D.

Résumé

Dans ce laboratoire, vous avez appris plusieurs techniques essentielles pour filtrer des collections dans MongoDB. Vous avez pratiqué l'application de plusieurs conditions à l'aide des opérateurs $and et $or, ce qui permet de créer des requêtes complexes et précises. Vous avez également exploré une gamme d'opérateurs de comparaison tels que $gt, $lt et $ne pour affiner les critères de recherche. De plus, vous avez acquis de l'expérience dans la correspondance de texte à l'aide d'expressions régulières, la vérification de l'existence de champs avec $exists, et l'interrogation de valeurs null. Ces compétences constituent une base solide pour la récupération et la manipulation efficaces des données dans MongoDB.