Introdução
Neste laboratório, você aprenderá a trabalhar com datas no MongoDB. Você praticará a inserção de documentos com valores de data, a consulta de documentos dentro de intervalos de datas específicos, a formatação de campos de data para exibição, a atualização de campos de data existentes e a ordenação de coleções por data. Este laboratório fornece um guia abrangente e prático para as funcionalidades relacionadas a datas do MongoDB, que são essenciais para gerenciar dados de séries temporais, agendamento e aplicações de logging.
Inserir Documentos com Valores de Data
Nesta primeira etapa, você se conectará ao servidor MongoDB e inserirá vários documentos contendo valores de data. Isso formará a base para as consultas e operações que você realizará nas etapas posteriores.
Primeiro, abra o shell do MongoDB executando o comando mongosh em seu terminal. Isso o conectará à instância MongoDB em execução.
mongosh
Uma vez dentro do shell, você verá um prompt como test>. Vamos mudar para um novo banco de dados chamado datelab. Se o banco de dados não existir, o MongoDB o criará para você quando você inserir dados pela primeira vez.
use datelab
Agora, você inserirá três documentos em uma nova coleção chamada events. Cada documento representará um evento e incluirá uma data. O MongoDB armazena datas como objetos BSON Date, que você pode criar usando o construtor new Date().
Insira os seguintes documentos um por um. O primeiro usa uma string de data ISO-8601, o segundo usa a data e hora atuais, e o terceiro usa um timestamp Unix em milissegundos.
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)
})
Após inserir os documentos, você pode verificar se eles foram adicionados corretamente usando o método find(), que recupera todos os documentos da coleção.
db.events.find()
Sua saída deve ser semelhante a esta, embora os valores de _id e o timestamp para "System Maintenance" sejam diferentes para você.
[
{
_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')
}
]
Você agora inseriu com sucesso documentos com valores de data. Na próxima etapa, você aprenderá a consultar esses documentos com base em suas datas.
Consultar Documentos por Intervalo de Datas
Com dados em sua coleção, você agora pode realizar consultas para encontrar documentos que se enquadram em intervalos de datas específicos. Este é um requisito comum para aplicações que lidam com eventos agendados, logs ou dados sensíveis ao tempo.
Primeiro, vamos adicionar mais eventos à nossa coleção para tornar as consultas mais interessantes. Usaremos o método insertMany() para adicionar três documentos de uma vez.
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")
}
])
Agora você tem um total de seis eventos. Vamos encontrar todos os eventos que ocorreram após 1º de junho de 2024. Para fazer isso, você usará o operador "maior que", $gt.
db.events.find({
date: { $gt: new Date("2024-06-01") }
})
Em seguida, vamos encontrar todos os eventos que ocorreram na primeira metade de 2024, especificamente entre 1º de janeiro e 1º de junho. Você pode combinar os operadores "maior ou igual a" ($gte) e "menor que" ($lt) para isso.
db.events.find({
date: {
$gte: new Date("2024-01-01"),
$lt: new Date("2024-06-01")
}
})
A consulta retornará os eventos "Winter Workshop" e "Spring Meetup". A saída deve ser semelhante a esta:
[
{
_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')
}
]
Esses exemplos demonstram como usar operadores de comparação ($gt, $gte, $lt, $lte) para filtrar efetivamente documentos com base em campos de data.
Formatar Saída de Data com Agregação
Frequentemente, você precisa exibir datas em um formato específico e legível por humanos. O framework de agregação do MongoDB fornece ferramentas poderosas para isso. Nesta etapa, você usará o operador $dateToString para formatar seus campos de data.
O framework de agregação processa documentos através de um pipeline de estágios. Usaremos um estágio $project para remodelar nossos documentos e criar um novo campo de data formatado.
Vamos formatar o campo date de nossos eventos no formato AAAA-MM-DD. Esta consulta processará apenas os documentos que possuem um campo date.
db.events.aggregate([
{
$project: {
event_name: 1,
formatted_date: {
$dateToString: {
format: "%Y-%m-%d",
date: "$date"
}
}
}
}
])
Vamos detalhar este comando:
db.events.aggregate([...]): Inicia um pipeline de agregação na coleçãoevents.$project: Um estágio que remodela documentos. Incluímos oevent_namee criamos um novo campoformatted_date.$dateToString: Um operador que converte um objeto de data em uma string.format: "%Y-%m-%d": Especifica o formato de saída.%Yé o ano,%mé o mês e%dé o dia.date: "$date": Especifica o campo de data de entrada do documento original. O prefixo$indica um caminho de campo.
A saída mostrará o nome do evento original e a nova string de data formatada. Observe que documentos sem um campo date (como "System Maintenance") serão omitidos do resultado.
[
{ _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' }
]
Você também pode extrair componentes individuais de uma data, como o ano ou o mês, usando operadores como $year e $month.
db.events.aggregate([
{
$project: {
event_name: 1,
year: { $year: "$date" },
month: { $month: "$date" },
day: { $dayOfMonth: "$date" }
}
}
])
Isso lhe dá controle granular sobre como você processa e apresenta informações de data.
Atualizar Campos de Data
Seus dados nem sempre são estáticos. Você pode precisar atualizar campos de data, como reagendar um evento ou adicionar um timestamp de modificação. Nesta etapa, você aprenderá como atualizar campos de data usando vários operadores de atualização.
Primeiro, vamos reagendar o evento "Conference" para uma nova data. Usaremos o método updateOne() para direcionar um único documento e o operador $set para alterar seu campo date.
db.events.updateOne(
{ event_name: "Conference" },
{
$set: {
date: new Date("2024-09-01T10:00:00Z"),
status: "Rescheduled"
}
}
)
Agora, vamos realizar uma atualização em massa. Marcaremos todos os eventos que ocorreram antes de 1º de maio de 2024 como "Archived". Também adicionaremos um novo campo, last_modified, para registrar quando essa atualização ocorreu. O método updateMany() modificará todos os documentos correspondentes, e o operador $currentDate é perfeito para definir um campo com a hora atual do servidor.
db.events.updateMany(
{ date: { $lt: new Date("2024-05-01") } },
{
$set: { status: "Archived" },
$currentDate: { last_modified: true }
}
)
Vamos verificar as alterações recuperando todos os documentos. O método .pretty() está obsoleto, então usaremos apenas find().
db.events.find()
Você verá que o "Conference" tem uma nova data e status. O "Winter Workshop" e o "Spring Meetup" agora estão marcados como "Archived" e possuem um timestamp last_modified.
Exemplo de saída para um evento arquivado:
{
"_id" : ObjectId("..."),
"event_name" : "Winter Workshop",
"date" : ISODate("2024-01-20T14:30:00Z"),
"status" : "Archived",
"last_modified" : ISODate("2024-02-19T15:10:00Z")
}
Essas operações mostram como você pode modificar precisamente informações relacionadas a datas em seus documentos.
Ordenar Documentos por Data
A última operação fundamental que você aprenderá é a ordenação. Exibir eventos em ordem cronológica é um requisito comum. O MongoDB facilita a ordenação dos resultados de suas consultas por qualquer campo, incluindo datas.
Para ordenar documentos, você anexa o método .sort() a uma consulta find(). O método sort() recebe um documento que especifica o campo pelo qual ordenar e a ordem de classificação. Um valor de 1 indica ordem ascendente (do mais antigo para o mais recente), e -1 indica ordem descendente (do mais recente para o mais antigo).
Vamos recuperar todos os eventos ordenados por sua date em ordem ascendente.
db.events.find().sort({ date: 1 })
Isso listará os eventos do "Winter Workshop" (mais antigo) ao "Summer Conference" (mais recente). Documentos sem um campo date serão ordenados primeiro se estiverem incluídos na consulta.
Agora, vamos ordenar os eventos em ordem descendente para ver os eventos mais recentes primeiro.
db.events.find().sort({ date: -1 })
Você também pode combinar a ordenação com a filtragem. Por exemplo, vamos encontrar todos os eventos que não foram arquivados e ordená-los por data.
db.events.find({ status: { $ne: "Archived" } }).sort({ date: 1 })
A saída mostrará os eventos não arquivados em ordem cronológica.
[
{
_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'
}
]
A ordenação é uma ferramenta crucial para apresentar dados ordenados por tempo de forma significativa. Quando terminar, você pode sair do shell do MongoDB digitando exit ou pressionando Ctrl+D.
Resumo
Neste laboratório, você aprendeu as técnicas fundamentais para trabalhar com datas no MongoDB. Você começou inserindo documentos com valores de data usando diferentes formatos. Em seguida, praticou a consulta de documentos com base em intervalos de datas usando operadores de comparação. Depois disso, você explorou o framework de agregação para formatar campos de data para melhor legibilidade. Você também aprendeu como atualizar campos de data e adicionar timestamps de modificação. Finalmente, você dominou a ordenação de coleções por data para apresentar dados em ordem cronológica. Essas habilidades são essenciais para qualquer desenvolvedor que trabalhe com dados baseados em tempo no MongoDB.
