Filtrer les collections MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à filtrer efficacement les collections MongoDB à l'aide de diverses techniques de requête. Le laboratoire couvre l'application de plusieurs conditions, l'utilisation d'opérateurs de comparaison, la correspondance d'expressions régulières, la vérification de l'existence d'un champ et la recherche de valeurs nulles. Ces compétences sont essentielles pour interroger et manipuler les données dans MongoDB, vous permettant d'extraire des informations précises et pertinentes de votre base de données. Les instructions étape par étape fournissent des exemples pratiques et des explications pour vous aider à maîtriser les bases de l'interrogation MongoDB.

Skills Graph

Appliquer plusieurs conditions

Dans cette étape, vous allez apprendre à appliquer plusieurs conditions lors de l'interrogation des collections MongoDB. Plusieurs conditions vous permettent de créer des requêtes plus précises et complexes pour filtrer efficacement vos données.

Tout d'abord, ouvrez un terminal et lancez le shell MongoDB :

mongosh

Maintenant, créons une collection d'étudiants de démonstration pour illustrer les requêtes avec plusieurs conditions :

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" }
])

Explorons comment appliquer plusieurs conditions à l'aide de l'opérateur $and. Cela nous permet de spécifier plusieurs conditions qui doivent toutes être vraies :

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

Cette requête retournera les étudiants âgés de 20 ans ou plus ET ayant une note de "A". Détaillemos les conditions :

• $gte signifie "plus grand ou égal à"
• $and garantit que les deux conditions doivent être remplies

Vous devriez voir une sortie similaire à :

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

Nous pouvons également utiliser l'opérateur $or pour trouver les documents qui correspondent à au moins une condition :

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

Cette requête retournera les étudiants qui sont soit en informatique soit âgés de moins de 21 ans.

• $lt signifie "moins que"

Le résultat inclura des étudiants comme David (moins de 21 ans) et Alice et David (étudiants en informatique).

Utiliser les opérateurs de comparaison

Dans cette étape, vous allez découvrir les opérateurs de comparaison de MongoDB qui vous aident à créer des requêtes plus sophistiquées pour filtrer les données selon différentes conditions.

Tout d'abord, assurez-vous d'être dans le shell MongoDB :

mongosh

Continuons d'utiliser la school_database de l'étape précédente. Si vous avez fermé le shell, recréez la collection d'étudiants :

use school_database

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 }
])

MongoDB fournit des opérateurs de comparaison puissants pour vous aider à filtrer précisément les données. Explorer quelques opérateurs clés :

1. Plus grand que ($gt) et Moins grand que ($lt) :

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

Cette requête trouve les étudiants âgés de plus de 20 ans mais moins de 25 ans. Dans notre exemple, cela retournerait Alice.

2. Plus grand ou égal à ($gte) et Moins grand ou égal à ($lte) :

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

Cela trouve les étudiants ayant de 40 à 50 crédits (inclus). Cela retournera Alice et Charlie.

3. Pas égal à ($ne) :

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

Cela retourne les étudiants dont la note n'est pas "C", qui seraient Alice, Bob et Charlie.

Détaillemos ces opérateurs :

• $gt : Plus grand que
• $lt : Moins grand que
• $gte : Plus grand ou égal à
• $lte : Moins grand ou égal à
• $ne : Pas égal à

Chaque requête démontre une manière différente de filtrer précisément les données à l'aide d'opérateurs de comparaison.

Correspondre à des expressions régulières

Dans cette étape, vous allez apprendre à utiliser des expressions régulières (regex) dans MongoDB pour effectuer des recherches textuelles flexibles et puissantes dans vos collections.

Tout d'abord, assurez-vous d'être dans le shell MongoDB :

mongosh

Continuons d'utiliser la school_database et ajoutons des données plus diverses :

use school_database

db.students.insertMany([
    { name: "Alice Johnson", age: 22, major: "Computer Science", email: "alice.johnson@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" }
])

Les expressions régulières dans MongoDB vous permettent d'effectuer des recherches textuelles complexes. Explorer différents modèles de regex :

1. Trouver les noms commençant par une lettre spécifique :

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

Cette requête trouve les étudiants dont les noms commencent par "A". Le symbole ^ signifie "commence par".

2. Trouver les adresses e-mail d'un domaine spécifique :

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

Cette requête trouve les étudiants ayant des adresses e-mail se terminant par "@example.com". Le symbole $ signifie "se termine par".

3. Recherche regex insensible à la casse :

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

Cela trouve les noms contenant "johnson" quelle que soit la casse. Le $options: "i" rend la recherche insensible à la casse.

4. Correspondances partielles :

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

Cela trouve les étudiants ayant "Computer" quelque part dans leur domaine d'étude.

Les modèles d'expressions régulières offrent des façons puissantes de rechercher et de filtrer les données :

• ^ : Commence par
• $ : Se termine par
• $options: "i" : Correspondance insensible à la casse
• Les correspondances partielles n'exigent pas de symboles spéciaux

Vérifier l'existence d'un champ

Dans cette étape, vous allez apprendre à vérifier l'existence de champs dans les documents MongoDB à l'aide d'opérateurs puissants qui vous aident à filtrer les collections en fonction de la présence de champs.

Tout d'abord, assurez-vous d'être dans le shell MongoDB :

mongosh

Créons une collection avec des documents ayant des structures différentes pour démontrer les vérifications d'existence de champs :

use school_database

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

MongoDB fournit l'opérateur $exists pour vérifier la présence d'un champ :

1. Trouver les documents avec un champ spécifique :

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

Cette requête retourne les étudiants qui ont un champ bourse. Dans notre exemple, cela retournera le document d'Alice.

2. Trouver les documents sans un champ spécifique :

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

Cette requête retourne les étudiants sans un champ stage, ce qui inclut Alice, Bob et David.

3. Combiner $exists avec des vérifications de champs imbriqués :

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

Cela trouve les documents avec un champ contact qui a également un sous-champ téléphone, ce qui correspond au document de David.

Points clés sur l'existence de champs :

• $exists: true vérifie si un champ est présent
• $exists: false vérifie si un champ est absent
• Vous pouvez créer des requêtes complexes pour vérifier l'existence de champs imbriqués

Trouver des valeurs nulles

Dans cette étape, vous allez apprendre à trouver et à travailler avec les valeurs nulles dans MongoDB, en comprenant la différence entre null, undefined et les champs manquants.

Tout d'abord, assurez-vous d'être dans le shell MongoDB :

mongosh

Créons une collection avec des documents contenant des valeurs nulles et undefined :

use school_database

db.students.insertMany([
    { name: "Alice Johnson", age: 22, email: null },
    { name: "Bob Smith", age: null, major: "Mathematics" },
    { name: "Charlie Brown", age: 25, phone: undefined },
    { name: "David Lee", contact: { email: null } }
])

MongoDB fournit des façons spécifiques de requêter les valeurs nulles et undefined :

1. Trouver les documents avec des valeurs nulles :

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

Cette requête retourne les documents où le champ email est explicitement défini sur null. Dans notre exemple, cela retournera le document d'Alice.

2. Trouver les documents avec des champs nulles :

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

Cela trouve les documents où le champ age est spécifiquement null. Cela retournera le document de Bob.

3. Vérifier la présence de null dans des documents imbriqués :

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

Cela trouve les documents avec un email null dans un objet contact imbriqué, ce qui correspond au document de David.

4. Distinguer entre null et les champs manquants :

db.students.find({
  $and: [{ phone: null }, { phone: { $exists: true } }]
});

Cette requête trouve les documents où le champ phone existe et est null. Dans notre exemple, cela ne retournera aucun document.

Points clés sur les valeurs nulles :

• null représente une absence intentionnelle de toute valeur d'objet
• Différent de undefined qui signifie qu'une variable n'a pas été assignée
• Utilisez $exists pour vérifier la présence d'un champ
• Faites attention aux requêtes sur des documents imbriqués

Sommaire

Dans ce laboratoire, vous avez appris à appliquer plusieurs conditions lors de la requête des collections MongoDB en utilisant les opérateurs $and et $or. Cela vous permet de créer des requêtes plus précises et complexes pour filtrer efficacement vos données. Vous avez également exploré divers opérateurs de comparaison tels que $gte (plus grand ou égal à) et $lt (moins grand que) pour affiner vos critères de recherche. De plus, vous avez découvert comment correspondre à des expressions régulières, vérifier l'existence de champs et trouver des valeurs nulles dans vos collections MongoDB, vous fournissant ainsi des outils puissants pour filtrer et récupérer efficacement les données dont vous avez besoin.