Introduction
Dans ce laboratoire, vous apprendrez à travailler avec les dates dans MongoDB. Vous pratiquerez l'insertion de documents avec des valeurs de date, la recherche de documents dans des plages de dates spécifiques, le formatage des champs de date pour l'affichage, la mise à jour des champs de date existants et le tri des collections par date. Ce laboratoire fournit un guide complet et pratique des fonctionnalités de MongoDB liées aux dates, qui sont essentielles pour la gestion des données de séries temporelles, la planification et les applications de journalisation.
Insérer des documents avec des valeurs de date
Dans cette première étape, vous allez vous connecter au serveur MongoDB et insérer plusieurs documents contenant des valeurs de date. Cela constituera la base des requêtes et des opérations que vous effectuerez dans les étapes ultérieures.
Tout d'abord, ouvrez le shell MongoDB en exécutant la commande mongosh dans votre terminal. Cela vous connectera à l'instance MongoDB en cours d'exécution.
mongosh
Une fois dans le shell, vous verrez une invite telle que test>. Passons à une nouvelle base de données nommée datelab. Si la base de données n'existe pas, MongoDB la créera pour vous lors de la première insertion de données.
use datelab
Maintenant, vous allez insérer trois documents dans une nouvelle collection appelée events. Chaque document représentera un événement et inclura une date. MongoDB stocke les dates sous forme d'objets BSON Date, que vous pouvez créer à l'aide du constructeur new Date().
Insérez les documents suivants un par un. Le premier utilise une chaîne de date ISO-8601, le second utilise la date et l'heure actuelles, et le troisième utilise un horodatage Unix en millisecondes.
db.events.insertOne({
event_name: "Conference",
date: new Date("2024-06-15T10:30:00Z")
})
db.events.insertOne({
event_name: "System Maintenance",
timestamp: new Date()
})
db.events.insertOne({
event_name: "Project Deadline",
timestamp: new Date(1718476800000)
})
Après avoir inséré les documents, vous pouvez vérifier qu'ils ont été ajoutés correctement en utilisant la méthode find(), qui récupère tous les documents de la collection.
db.events.find()
Votre sortie devrait ressembler à ceci, bien que les valeurs _id et le timestamp pour "System Maintenance" soient différents pour vous.
[
{
_id: ObjectId("65d38f8a1c2d3e4f5a6b7c8d"),
event_name: 'Conference',
date: ISODate('2024-06-15T10:30:00.000Z')
},
{
_id: ObjectId("65d38f9c1c2d3e4f5a6b7c8e"),
event_name: 'System Maintenance',
timestamp: ISODate('2024-02-19T14:55:24.123Z')
},
{
_id: ObjectId("65d38fb11c2d3e4f5a6b7c8f"),
event_name: 'Project Deadline',
timestamp: ISODate('2024-06-15T18:00:00.000Z')
}
]
Vous avez maintenant inséré avec succès des documents contenant des valeurs de date. Dans la prochaine étape, vous apprendrez à interroger ces documents en fonction de leurs dates.
Interroger des documents par plage de dates
Avec des données dans votre collection, vous pouvez maintenant effectuer des requêtes pour trouver des documents qui se situent dans des plages de dates spécifiques. C'est une exigence courante pour les applications qui gèrent des événements planifiés, des journaux ou des données sensibles au temps.
Tout d'abord, ajoutons d'autres événements à notre collection pour rendre les requêtes plus intéressantes. Nous utiliserons la méthode insertMany() pour ajouter trois documents à la fois.
db.events.insertMany([
{
event_name: "Summer Conference",
date: new Date("2024-07-15T09:00:00Z")
},
{
event_name: "Winter Workshop",
date: new Date("2024-01-20T14:30:00Z")
},
{
event_name: "Spring Meetup",
date: new Date("2024-04-10T11:15:00Z")
}
])
Vous avez maintenant un total de six événements. Trouvons tous les événements qui se sont produits après le 1er juin 2024. Pour ce faire, vous utiliserez l'opérateur "supérieur à", $gt.
db.events.find({
date: { $gt: new Date("2024-06-01") }
})
Ensuite, trouvons tous les événements qui se sont produits au cours du premier semestre 2024, spécifiquement entre le 1er janvier et le 1er juin. Vous pouvez combiner les opérateurs "supérieur ou égal à" ($gte) et "inférieur à" ($lt) pour cela.
db.events.find({
date: {
$gte: new Date("2024-01-01"),
$lt: new Date("2024-06-01")
}
})
La requête retournera les événements "Winter Workshop" et "Spring Meetup". La sortie devrait ressembler à ceci :
[
{
_id: ObjectId("65d392a11c2d3e4f5a6b7c91"),
event_name: 'Winter Workshop',
date: ISODate('2024-01-20T14:30:00.000Z')
},
{
_id: ObjectId("65d392a11c2d3e4f5a6b7c92"),
event_name: 'Spring Meetup',
date: ISODate('2024-04-10T11:15:00.000Z')
}
]
Ces exemples démontrent comment utiliser les opérateurs de comparaison ($gt, $gte, $lt, $lte) pour filtrer efficacement les documents en fonction des champs de date.
Formater la sortie de date avec agrégation
Souvent, vous devez afficher les dates dans un format spécifique et lisible par l'homme. Le framework d'agrégation de MongoDB fournit des outils puissants pour cela. Dans cette étape, vous utiliserez l'opérateur $dateToString pour formater vos champs de date.
Le framework d'agrégation traite les documents à travers un pipeline d'étapes. Nous utiliserons une étape $project pour remodeler nos documents et créer un nouveau champ de date formaté.
Formatons le champ date de nos événements au format AAAA-MM-JJ. Cette requête ne traitera que les documents qui possèdent un champ date.
db.events.aggregate([
{
$project: {
event_name: 1,
formatted_date: {
$dateToString: {
format: "%Y-%m-%d",
date: "$date"
}
}
}
}
])
Décomposons cette commande :
db.events.aggregate([...]): Lance un pipeline d'agrégation sur la collectionevents.$project: Une étape qui remodèle les documents. Nous incluonsevent_nameet créons un nouveau champformatted_date.$dateToString: Un opérateur qui convertit un objet date en chaîne de caractères.format: "%Y-%m-%d": Spécifie le format de sortie.%Yreprésente l'année,%mle mois et%dle jour.date: "$date": Spécifie le champ de date d'entrée du document original. Le préfixe$indique un chemin de champ.
La sortie affichera le nom de l'événement original et la nouvelle chaîne de date formatée. Notez que les documents sans champ date (comme "System Maintenance") seront omis du résultat.
[
{ _id: ObjectId("..."), event_name: 'Conference', formatted_date: '2024-06-15' },
{ _id: ObjectId("..."), event_name: 'Summer Conference', formatted_date: '2024-07-15' },
{ _id: ObjectId("..."), event_name: 'Winter Workshop', formatted_date: '2024-01-20' },
{ _id: ObjectId("..."), event_name: 'Spring Meetup', formatted_date: '2024-04-10' }
]
Vous pouvez également extraire des composants individuels d'une date, tels que l'année ou le mois, en utilisant des opérateurs comme $year et $month.
db.events.aggregate([
{
$project: {
event_name: 1,
year: { $year: "$date" },
month: { $month: "$date" },
day: { $dayOfMonth: "$date" }
}
}
])
Cela vous donne un contrôle granulaire sur la manière dont vous traitez et présentez les informations de date.
Mettre à jour les champs de date
Vos données ne sont pas toujours statiques. Vous pourriez avoir besoin de mettre à jour des champs de date, comme reprogrammer un événement ou ajouter un horodatage de modification. Dans cette étape, vous apprendrez comment mettre à jour des champs de date en utilisant divers opérateurs de mise à jour.
Tout d'abord, reprogrammons l'événement "Conference" à une nouvelle date. Nous utiliserons la méthode updateOne() pour cibler un seul document et l'opérateur $set pour modifier son champ date.
db.events.updateOne(
{ event_name: "Conference" },
{
$set: {
date: new Date("2024-09-01T10:00:00Z"),
status: "Rescheduled"
}
}
)
Maintenant, effectuons une mise à jour en masse. Nous marquerons tous les événements qui se sont produits avant le 1er mai 2024 comme "Archived". Nous ajouterons également un nouveau champ, last_modified, pour enregistrer quand cette mise à jour a eu lieu. La méthode updateMany() modifiera tous les documents correspondants, et l'opérateur $currentDate est parfait pour définir un champ à l'heure actuelle du serveur.
db.events.updateMany(
{ date: { $lt: new Date("2024-05-01") } },
{
$set: { status: "Archived" },
$currentDate: { last_modified: true }
}
)
Vérifions les changements en récupérant tous les documents. La méthode .pretty() est obsolète, nous utiliserons donc simplement find().
db.events.find()
Vous verrez que la "Conference" a une nouvelle date et un nouveau statut. Le "Winter Workshop" et le "Spring Meetup" sont maintenant marqués comme "Archived" et possèdent un horodatage last_modified.
Exemple de sortie pour un événement archivé :
{
"_id" : ObjectId("..."),
"event_name" : "Winter Workshop",
"date" : ISODate("2024-01-20T14:30:00Z"),
"status" : "Archived",
"last_modified" : ISODate("2024-02-19T15:10:00Z")
}
Ces opérations montrent comment vous pouvez modifier précisément les informations relatives aux dates dans vos documents.
Trier les documents par date
La dernière opération fondamentale que vous apprendrez est le tri. Afficher les événements dans un ordre chronologique est une exigence courante. MongoDB facilite le tri des résultats de vos requêtes par n'importe quel champ, y compris les dates.
Pour trier les documents, vous ajoutez la méthode .sort() à une requête find(). La méthode sort() prend un document qui spécifie le champ par lequel trier et l'ordre de tri. Une valeur de 1 indique un ordre croissant (du plus ancien au plus récent), et -1 indique un ordre décroissant (du plus récent au plus ancien).
Récupérons tous les événements triés par leur date dans l'ordre croissant.
db.events.find().sort({ date: 1 })
Cela listera les événements du "Winter Workshop" (le plus ancien) au "Summer Conference" (le plus récent). Les documents sans champ date seront triés en premier s'ils sont inclus dans la requête.
Maintenant, trions les événements dans l'ordre décroissant pour voir d'abord les événements les plus récents.
db.events.find().sort({ date: -1 })
Vous pouvez également combiner le tri avec le filtrage. Par exemple, trouvons tous les événements qui ne sont pas archivés et trions-les par date.
db.events.find({ status: { $ne: "Archived" } }).sort({ date: 1 })
La sortie affichera les événements non archivés dans l'ordre chronologique.
[
{
_id: ObjectId("..."),
event_name: 'System Maintenance',
timestamp: ISODate("...")
},
{
_id: ObjectId("..."),
event_name: 'Project Deadline',
timestamp: ISODate('2024-06-15T18:00:00.000Z')
},
{
_id: ObjectId("..."),
event_name: 'Summer Conference',
date: ISODate('2024-07-15T09:00:00.000Z')
},
{
_id: ObjectId("..."),
event_name: 'Conference',
date: ISODate('2024-09-01T10:00:00.000Z'),
status: 'Rescheduled'
}
]
Le tri est un outil crucial pour présenter des données ordonnées dans le temps de manière significative. Lorsque vous avez terminé, vous pouvez quitter le shell MongoDB en tapant exit ou en appuyant sur Ctrl+D.
Résumé
Dans ce laboratoire, vous avez appris les techniques fondamentales pour travailler avec les dates dans MongoDB. Vous avez commencé par insérer des documents avec des valeurs de date en utilisant différents formats. Vous vous êtes ensuite exercé à interroger des documents basés sur des plages de dates avec des opérateurs de comparaison. Après cela, vous avez exploré le framework d'agrégation pour formater les champs de date afin d'améliorer la lisibilité. Vous avez également appris à mettre à jour les champs de date et à ajouter des horodatages de modification. Enfin, vous avez maîtrisé le tri des collections par date pour présenter les données dans un ordre chronologique. Ces compétences sont essentielles pour tout développeur travaillant avec des données basées sur le temps dans MongoDB.
