Cómo trabajar con fechas en MongoDB

Introducción

En este laboratorio, aprenderá a trabajar con fechas en MongoDB, incluyendo la inserción de valores de fecha, la consulta de rangos de fechas, el formato de la salida de fechas, la actualización de campos de fecha y la clasificación por fecha. Explorará varios métodos para insertar fechas, como utilizar la fecha actual, crear una fecha específica y utilizar un timestamp en milisegundos. Además, aprenderá a consultar rangos de fechas, formatear la salida de fechas, actualizar campos de fecha y ordenar datos por fecha. Este laboratorio ofrece una panorámica general de cómo trabajar con las funcionalidades relacionadas con las fechas de MongoDB.

Insertar valores de fecha

En este paso, aprenderá a insertar valores de fecha en MongoDB utilizando la shell de MongoDB (mongosh). Las fechas son un tipo de datos esencial en las bases de datos, y MongoDB ofrece maneras poderosas de trabajar con ellas.

Primero, iniciemos la shell de MongoDB:

mongosh

Ahora, creemos una base de datos para nuestras experimentaciones con fechas:

use datelab

MongoDB le permite insertar fechas de varias maneras. Exploraremos tres métodos comunes:

Utilizando la fecha actual:

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

Creando una fecha específica:

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

Utilizando el timestamp en milisegundos:

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

Verifiquemos los documentos insertados:

db.events.find()

Salida de ejemplo:

[
  {
    _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
  }
]

Analicemos los métodos de inserción de fechas:

new Date() crea un timestamp para el momento actual
new Date("YYYY-MM-DDTHH:mm:ssZ") crea una fecha y hora específicas
new Date(milliseconds) crea una fecha a partir de un timestamp Unix en milisegundos

Consultar rangos de fechas

En este paso, aprenderá a consultar rangos de fechas en MongoDB. A partir del paso anterior, utilizaremos la base de datos datelab para demostrar varias consultas de rangos de fechas.

Primero, asegúrese de estar en la base de datos correcta y verifique nuestros documentos existentes:

use datelab
db.events.find()

Ahora, agregemos más eventos para crear un conjunto de datos más interesante:

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

Explore diferentes maneras de consultar rangos de fechas:

Encuentre eventos después de una fecha específica:

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

Encuentre eventos entre dos fechas:

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

Usando operadores de comparación con fechas:

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

Explicación de los operadores de consulta:

$gt: Mayor que
$gte: Mayor o igual que
$lt: Menor que
$lte: Menor o igual que

Salida de ejemplo:

[
  {
    _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
  }
]

Formatear la salida de fechas

En este paso, aprenderá a formatear la salida de fechas en MongoDB utilizando varios métodos. Continuaremos utilizando la base de datos datelab de los pasos anteriores.

Primero, asegúrese de estar en la base de datos correcta:

use datelab

MongoDB ofrece varias maneras de formatear fechas. Exploraremos diferentes técnicas de formato:

Utilizando el operador de agregación $dateToString:

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

Extraer componentes específicos de la fecha:

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

Crear formatos de fecha personalizados:

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

Especificadores de formato de fecha:

%Y: Año de 4 dígitos
%m: Mes como número de dos dígitos
%d: Día del mes
%H: Hora (reloj de 24 horas)
%I: Hora (reloj de 12 horas)
%M: Minutos
%S: Segundos
%p: Indicador de AM/PM

Salida de ejemplo:

[
  {
    _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'
  }
]

Actualizar campos de fecha

En este paso, aprenderá a actualizar campos de fecha en MongoDB. Continuaremos utilizando la base de datos datelab de los pasos anteriores y exploraremos varias técnicas de actualización de fechas.

Primero, asegúrese de estar en la base de datos correcta:

use datelab

Comencemos agregando algunos más eventos con los que trabajar:

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

Ahora, explore diferentes maneras de actualizar campos de fecha:

Actualizar la fecha de un solo documento:

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

Actualizar múltiples documentos utilizando operaciones de fecha:

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

Incrementar la fecha utilizando $currentDate:

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

Verifiquemos nuestras actualizaciones:

db.events.find()

Salida de ejemplo:

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

Operadores de actualización clave:

$set: Reemplazar valores de campo
$currentDate: Actualizar con el timestamp actual
$inc: Incrementar valores numéricos
$unset: Eliminar campos

Ordenar por fecha

En este último paso, aprenderá a ordenar documentos por fecha en MongoDB. Continuaremos utilizando la base de datos datelab de los pasos anteriores y exploraremos varias técnicas de clasificación.

Primero, asegúrese de estar en la base de datos correcta:

use datelab

Agregemos algunos más eventos para crear un conjunto de datos diverso:

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

Ahora, explore diferentes maneras de ordenar documentos por fecha:

Ordenar eventos en orden ascendente (desde el más antiguo hasta el más reciente):

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

Ordenar eventos en orden descendente (desde el más reciente hasta el más antiguo):

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

Combinar la clasificación con el filtrado:

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

Clasificación avanzada con múltiples criterios:

db.events.find().sort({
    category: 1,  // Ordenar por categoría primero
    date: -1      // Luego por fecha en orden descendente
})

Verifiquemos nuestros resultados de clasificación:

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

Salida de ejemplo:

[
  {
    _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'
  }
]

Puntos clave de clasificación:

1: Orden ascendente
-1: Orden descendente
Se puede ordenar por múltiples campos
Funciona con fechas, cadenas, números

Resumen

En este laboratorio, aprendió cómo insertar valores de fecha en MongoDB utilizando varios métodos, incluyendo utilizar la fecha actual, crear una fecha específica y utilizar un timestamp en milisegundos. También exploró la consulta de rangos de fechas, el formateo de la salida de fechas, la actualización de campos de fecha y la clasificación por fecha. Estas técnicas son esenciales para trabajar con datos temporales en aplicaciones de MongoDB.

El laboratorio cubrió conceptos clave como la creación de una base de datos, la inserción de documentos con campos de fecha, la consulta de datos basados en rangos de fechas, el formateo de la salida de fechas, la actualización de campos relacionados con fechas y la clasificación de datos por fecha. Estas habilidades son fundamentales para construir aplicaciones que requieren trabajar con fechas y timestamps en una base de datos de MongoDB.

Trabajar con fechas en MongoDB

Introducción

Insertar valores de fecha

Consultar rangos de fechas

Formatear la salida de fechas

Actualizar campos de fecha

Ordenar por fecha

Resumen