Travailler avec les dates de MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à travailler avec les dates dans MongoDB, notamment à insérer des valeurs de date, à interroger des plages de dates, à formater la sortie de date, à mettre à jour des champs de date et à trier par date. Vous allez explorer diverses méthodes pour insérer des dates, telles que l'utilisation de la date actuelle, la création d'une date spécifique et l'utilisation d'un horodatage en millisecondes. De plus, vous allez apprendre à interroger des plages de dates, à formater la sortie de date, à mettre à jour des champs de date et à trier les données par date. Ce laboratoire offre une vue d'ensemble complète des fonctionnalités liées aux dates de MongoDB.

Insérer des valeurs de date

Dans cette étape, vous allez apprendre à insérer des valeurs de date dans MongoDB à l'aide de la console MongoDB (mongosh). Les dates sont un type de données essentiel dans les bases de données, et MongoDB fournit des moyens puissants de travailler avec elles.

Commençons par démarrer la console MongoDB :

mongosh

Maintenant, créons une base de données pour nos expériences de date :

use datelab

MongoDB vous permet d'insérer des dates de plusieurs manières. Nous allons explorer trois méthodes courantes :

1. Utiliser la date actuelle :

db.events.insertOne({
    event_name: "Lab Start",
    timestamp: new Date()
})

2. Créer une date spécifique :

db.events.insertOne({
    event_name: "Conference",
    date: new Date("2024-06-15T10:30:00Z")
})

3. Utiliser l'horodatage en millisecondes :

db.events.insertOne({
    event_name: "Project Deadline",
    timestamp: new Date(1718476800000)
})

Vérifions les documents insérés :

db.events.find()

Sortie exemple :

[
  {
    _id: ObjectId("..."),
    event_name: 'Lab Start',
    timestamp: 2024-02-15T12:34:56.789Z
  },
  {
    _id: ObjectId("..."),
    event_name: 'Conference',
    date: 2024-06-15T10:30:00.000Z
  },
  {
    _id: ObjectId("..."),
    event_name: 'Project Deadline',
    timestamp: 2024-06-15T00:00:00.000Z
  }
]

Analysons les méthodes d'insertion de date :

• new Date() crée un horodatage pour le moment présent
• new Date("YYYY-MM-DDTHH:mm:ssZ") crée une date et une heure spécifiques
• new Date(milliseconds) crée une date à partir d'un horodatage Unix en millisecondes

Interroger des plages de dates

Dans cette étape, vous allez apprendre à interroger des plages de dates dans MongoDB. Reprenant l'étape précédente, nous utiliserons la base de données datelab pour démontrer diverses requêtes de plage de dates.

Commençons par nous assurer que nous sommes dans la bonne base de données et vérifions nos documents existants :

use datelab
db.events.find()

Maintenant, ajoutons plus d'événements pour créer un ensemble de données plus intéressant :

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

Explorons différentes façons d'interroger des plages de dates :

1. Trouver les événements après une date spécifique :

db.events.find({
    date: { $gt: new Date("2024-06-01") }
})

2. Trouver les événements entre deux dates :

db.events.find({
    date: {
        $gte: new Date("2024-01-01"),
        $lt: new Date("2024-06-01")
    }
})

3. Utiliser des opérateurs de comparaison avec des dates :

db.events.find({
    date: {
        $gte: new Date("2024-01-01"),
        $lte: new Date("2024-12-31")
    }
})

Explication des opérateurs de requête :

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

Sortie exemple :

[
  {
    _id: ObjectId("..."),
    event_name: 'Winter Workshop',
    date: 2024-01-20T14:30:00.000Z
  },
  {
    _id: ObjectId("..."),
    event_name: 'Spring Meetup',
    date: 2024-04-10T11:15:00.000Z
  }
]

Formater la sortie de date

Dans cette étape, vous allez apprendre à formater la sortie de date dans MongoDB à l'aide de diverses méthodes. Nous continuerons à utiliser la base de données datelab des étapes précédentes.

Commençons par nous assurer que nous sommes dans la bonne base de données :

use datelab

MongoDB fournit plusieurs façons de formater les dates. Nous allons explorer différentes techniques de formatage :

1. Utiliser l'opérateur d'agrégation $dateToString :

db.events.aggregate([
    {
        $project: {
            event_name: 1,
            formatted_date: {
                $dateToString: {
                    format: "%Y-%m-%d %H:%M:%S",
                    date: "$date"
                }
            }
        }
    }
])

2. Extraire des composants de date spécifiques :

db.events.aggregate([
    {
        $project: {
            event_name: 1,
            year: { $year: "$date" },
            month: { $month: "$date" },
            day: { $dayOfMonth: "$date" },
            hour: { $hour: "$date" }
        }
    }
])

3. Créer des formats de date personnalisés :

db.events.aggregate([
    {
        $project: {
            event_name: 1,
            custom_format: {
                $dateToString: {
                    format: "%B %d, %Y at %I:%M %p",
                    date: "$date"
                }
            }
        }
    }
])

Spécificateurs de formatage de date :

• %Y : Année sur 4 chiffres
• %m : Mois sous forme de nombre à deux chiffres
• %d : Jour du mois
• %H : Heure (horloge 24h)
• %I : Heure (horloge 12h)
• %M : Minutes
• %S : Secondes
• %p : Indicateur AM/PM

Sortie exemple :

[
  {
    _id: ObjectId("..."),
    event_name: 'Summer Conference',
    formatted_date: '2024-07-15 09:00:00',
    year: 2024,
    month: 7,
    day: 15,
    hour: 9,
    custom_format: 'July 15, 2024 at 09:00 AM'
  }
]

Mettre à jour les champs de date

Dans cette étape, vous allez apprendre à mettre à jour les champs de date dans MongoDB. Nous continuerons à utiliser la base de données datelab des étapes précédentes et explorerons diverses techniques de mise à jour de date.

Commençons par nous assurer que nous sommes dans la bonne base de données :

use datelab

Commençons par ajouter quelques événements supplémentaires avec lesquels travailler :

db.events.insertMany([
    {
        event_name: "Tech Conference",
        date: new Date("2024-08-20T10:00:00Z"),
        status: "Planned"
    },
    {
        event_name: "Developers Meetup",
        date: new Date("2024-09-15T14:30:00Z"),
        status: "Pending"
    }
])

Maintenant, explorons différentes façons de mettre à jour les champs de date :

1. Mettre à jour la date d'un seul document :

db.events.updateOne(
    { event_name: "Tech Conference" },
    {
        $set: {
            date: new Date("2024-09-01T10:00:00Z"),
            status: "Confirmed"
        }
    }
)

2. Mettre à jour plusieurs documents en utilisant des opérations de date :

db.events.updateMany(
    { date: { $lt: new Date("2024-07-01") } },
    {
        $set: {
            status: "Historical",
            updated_at: new Date()
        }
    }
)

3. Incrémenter la date en utilisant $currentDate :

db.events.updateOne(
    { event_name: "Developers Meetup" },
    {
        $currentDate: {
            last_modified: true
        },
        $inc: {
            "event_duration.days": 1
        }
    }
)

Vérifions nos mises à jour :

db.events.find()

Sortie exemple :

[
  {
    _id: ObjectId("..."),
    event_name: 'Tech Conference',
    date: 2024-09-01T10:00:00.000Z,
    status: 'Confirmed'
  },
  {
    _id: ObjectId("..."),
    event_name: 'Developers Meetup',
    date: 2024-09-15T14:30:00.000Z,
    status: 'Pending',
    last_modified: ISODate("2024-02-15T12:34:56.789Z")
  }
]

Opérateurs de mise à jour clés :

• $set : Remplace les valeurs de champ
• $currentDate : Met à jour avec le timestamp actuel
• $inc : Incrémente les valeurs numériques
• $unset : Supprime les champs

Trier par date

Dans cette étape finale, vous allez apprendre à trier des documents par date dans MongoDB. Nous continuerons à utiliser la base de données datelab des étapes précédentes et explorerons diverses techniques de tri.

Commençons par nous assurer que nous sommes dans la bonne base de données :

use datelab

Ajoutons quelques événements supplémentaires pour créer un ensemble de données diversifié :

db.events.insertMany([
    {
        event_name: "AI Summit",
        date: new Date("2024-10-15T09:00:00Z"),
        category: "Technology"
    },
    {
        event_name: "Blockchain Workshop",
        date: new Date("2024-05-22T14:30:00Z"),
        category: "Finance"
    },
    {
        event_name: "Cloud Computing Expo",
        date: new Date("2024-03-10T11:15:00Z"),
        category: "IT"
    }
])

Maintenant, explorons différentes façons de trier des documents par date :

1. Trier les événements par ordre croissant (du plus ancien au plus récent) :

db.events.find().sort({ date: 1 })

2. Trier les événements par ordre décroissant (du plus récent au plus ancien) :

db.events.find().sort({ date: -1 })

3. Combiner le tri avec le filtrage :

db.events.find({
    category: "Technology"
}).sort({ date: 1 })

4. Tri avancé avec plusieurs critères :

db.events.find().sort({
    category: 1,  // Trier par catégorie en premier
    date: -1      // Puis par date dans l'ordre décroissant
})

Vérifions les résultats de notre tri :

db.events.find({}, {
    event_name: 1,
    date: 1,
    category: 1
}).sort({ date: 1 })

Sortie exemple :

[
  {
    _id: ObjectId("..."),
    event_name: 'Cloud Computing Expo',
    date: 2024-03-10T11:15:00.000Z,
    category: 'IT'
  },
  {
    _id: ObjectId("..."),
    event_name: 'Blockchain Workshop',
    date: 2024-05-22T14:30:00.000Z,
    category: 'Finance'
  },
  {
    _id: ObjectId("..."),
    event_name: 'AI Summit',
    date: 2024-10-15T09:00:00.000Z,
    category: 'Technology'
  }
]

Points clés sur le tri :

• 1 : Ordre croissant
• -1 : Ordre décroissant
• Peut trier par plusieurs champs
• Fonctionne avec des dates, des chaînes, des nombres

Sommaire

Dans ce laboratoire, vous avez appris à insérer des valeurs de date dans MongoDB à l'aide de diverses méthodes, notamment en utilisant la date actuelle, en créant une date spécifique et en utilisant un timestamp en millisecondes. Vous avez également exploré l'interrogation de plages de dates, le formatage de la sortie de date, la mise à jour des champs de date et le tri par date. Ces techniques sont essentielles pour travailler avec des données temporelles dans les applications MongoDB.

Le laboratoire a couvert des concepts clés tels que la création d'une base de données, l'insertion de documents avec des champs de date, l'interrogation de données sur la base de plages de dates, le formatage de la sortie de date, la mise à jour de champs liés à la date et le tri de données par date. Ces compétences sont fondamentales pour construire des applications qui nécessitent de travailler avec des dates et des timestamps dans une base de données MongoDB.