Criando uma coleção de séries temporais
Você criará uma coleção de séries temporais, especificando as opções timeField, metaField e de granularidade.
Criando uma coleção de séries temporais é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de MongoDB Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de MongoDB Academy inclui 4 aulas no total.
Introdução às collections de séries temporais
O MongoDB 5.0 introduziu collections nativas de séries temporais — um tipo especializado de collection otimizado para armazenar e consultar medições que mudam ao longo do tempo. Os casos de uso comuns incluem leituras de sensores de IoT, métricas de aplicações, cotações financeiras e dados de monitoramento de servidores. Diferentemente das collections comuns, as collections de séries temporais usam internamente um formato de armazenamento colunar, reduzindo significativamente o espaço ocupado e melhorando o desempenho das consultas com filtros por intervalo de tempo.
Campos principais: timeField, metaField e granularidade
Toda collection de séries temporais exige três opções principais ao ser criada. O timeField é o campo do documento que contém o carimbo de data e hora (deve ser uma data BSON). O metaField identifica a série — por exemplo, o ID de um sensor ou o nome de um dispositivo. A indicação de granularidade ('seconds', 'minutes' ou 'hours') informa ao MongoDB com que frequência as medições chegam, permitindo otimizar internamente o tamanho dos buckets.
Criação com o comando createCollection
Use db.createCollection() com um objeto de opções timeseries para criar uma collection de séries temporais. Não é possível converter uma collection comum existente em uma collection de séries temporais — é necessário criá-la do zero. A collection aparecerá em show collections com um indicador especial de tipo timeseries.
db.createCollection('sensorReadings', {
timeseries: {
timeField: 'timestamp',
metaField: 'sensorId',
granularity: 'seconds'
}
})A granularidade afeta o tamanho dos buckets
A opção de granularidade controla como o MongoDB agrupa as medições em documentos de bucket internos. Com 'seconds', os buckets abrangem uma hora (3.600 medições por bucket). Com 'minutes', abrangem 24 horas. Com 'hours', abrangem 30 dias. Escolher a granularidade incorreta resulta em mais documentos de bucket e em uma compressão pior — sempre corresponda a granularidade à taxa real de chegada dos seus dados.
// Sensor sends data every second — use 'seconds'
db.createCollection('iotData', {
timeseries: {
timeField: 'ts',
metaField: 'device',
granularity: 'seconds'
}
})
// Aggregated hourly metric — use 'hours'
db.createCollection('hourlyMetrics', {
timeseries: {
timeField: 'ts',
metaField: 'service',
granularity: 'hours'
}
})Formato dos documentos para inserções em séries temporais
Os documentos inseridos em uma collection de séries temporais devem incluir o timeField como uma data BSON válida. O valor de metaField identifica a série à qual essa medição pertence (por exemplo, o ID de um dispositivo). Todos os outros campos são chamados de campos de medição e podem conter qualquer valor BSON. O MongoDB rejeitará documentos cujo timeField esteja ausente ou não seja uma data.
// Valid time series document
{
timestamp: new Date(), // timeField — must be a Date
sensorId: 'sensor-42', // metaField — identifies the series
temperature: 23.7, // measurement field
humidity: 55.2, // measurement field
pressure: 1013.4 // measurement field
}Inserção de uma ou várias medições
Insira dados em uma collection de séries temporais exatamente como faria em uma collection comum — usando insertOne() ou insertMany(). O MongoDB gerencia automaticamente a criação interna dos buckets. É uma boa prática agrupar as inserções com insertMany() ao carregar dados históricos, pois isso distribui o custo de criação dos buckets entre muitas medições.
// Insert a single measurement
db.sensorReadings.insertOne({
timestamp: new Date('2024-06-01T10:00:00Z'),
sensorId: 'sensor-42',
temperature: 22.5,
humidity: 60.1
})
// Bulk insert historical data
db.sensorReadings.insertMany([
{ timestamp: new Date('2024-06-01T10:01:00Z'), sensorId: 'sensor-42', temperature: 22.6, humidity: 60.0 },
{ timestamp: new Date('2024-06-01T10:02:00Z'), sensorId: 'sensor-42', temperature: 22.4, humidity: 60.3 }
])Adição de expiração automática com expireAfterSeconds
As collections de séries temporais permitem a expiração automática de dados por meio da opção expireAfterSeconds. Depois de definida, a thread TTL em segundo plano do MongoDB exclui buckets inteiros quando todas as medições neles são mais antigas que o limite. Isso é mais eficiente do que um índice TTL comum, pois documentos de bucket internos inteiros são removidos de uma vez, em vez de documentos de medição individuais.
// Create with 90-day TTL
db.createCollection('sensorReadings', {
timeseries: {
timeField: 'timestamp',
metaField: 'sensorId',
granularity: 'minutes'
},
expireAfterSeconds: 60 * 60 * 24 * 90 // 90 days
})Consulta a collections de séries temporais
As consultas em collections de séries temporais são idênticas às consultas find() comuns. O MongoDB usa automaticamente a estrutura interna de buckets para ignorar buckets irrelevantes ao filtrar por intervalo de tempo. Filtrar pelo metaField também é altamente eficiente. Evite consultar apenas campos de medição sem um filtro de tempo ou de meta, pois isso força uma varredura completa da collection em todos os buckets.
// Query last 24 hours for a specific sensor
const since = new Date(Date.now() - 24 * 60 * 60 * 1000)
db.sensorReadings.find({
sensorId: 'sensor-42',
timestamp: { $gte: since }
}).sort({ timestamp: 1 })Atualização da granularidade após a criação
Você pode aumentar a granularidade de uma collection de séries temporais existente (por exemplo, de 'seconds' para 'minutes') usando o comando collMod. No entanto, não é possível reduzi-la — o MongoDB retornará um erro se você tentar passar de 'minutes' para 'seconds'. Também é possível atualizar a configuração expireAfterSeconds por meio de collMod, sem recriar a collection.
// Increase granularity from seconds to minutes
db.runCommand({
collMod: 'sensorReadings',
timeseries: { granularity: 'minutes' }
})
// Update expireAfterSeconds to 30 days
db.runCommand({
collMod: 'sensorReadings',
expireAfterSeconds: 60 * 60 * 24 * 30
})Limitações e restrições
As collections de séries temporais têm algumas restrições importantes em comparação com collections comuns. Não é possível fragmentar uma collection de séries temporais usando apenas o timeField — é necessário um componente metaField com hash. As atualizações e exclusões são limitadas: antes do MongoDB 5.1, só eram permitidas exclusões por metaField ou por intervalo de tempo. Além disso, as collections de séries temporais não oferecem suporte a índices exclusivos, índices esparsos ou collections limitadas.
Verificação do tipo e das opções da collection
Depois de criar uma collection de séries temporais, inspecione-a usando db.getCollectionInfos() para confirmar que as opções timeseries foram armazenadas corretamente. Você também pode executar db.sensorReadings.stats() para ver as estatísticas de armazenamento, incluindo o número de documentos de bucket internos que o MongoDB mantém nos bastidores.
// Inspect time series collection metadata
db.getCollectionInfos({ name: 'sensorReadings' })
// Check storage stats
db.sensorReadings.stats()Verificação rápida
Teste sua compreensão dos conceitos de MongoDB e bancos de dados NoSQL apresentados nesta lição.
Recapitulação da lição
Nesta lição, você aprendeu que: as collections de séries temporais usam um formato colunar de buckets para cargas de trabalho com alta compressão e muitas operações de acréscimo, três opções principais (timeField, metaField e granularidade) controlam como as medições são organizadas e agrupadas em buckets, e expireAfterSeconds permite a limpeza automática eficiente de dados antigos no nível do bucket. A seguir, vamos explorar em detalhes a inserção e a consulta de dados de séries temporais.
Aprenda JavaScript com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Criando uma coleção de séries temporais” é grátis?
Sim — o texto completo de “Criando uma coleção de séries temporais” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de MongoDB Academy, atualize para CoddyKit PRO. O curso de MongoDB Academy inclui 4 aulas no total.
O que vou aprender em “Criando uma coleção de séries temporais”?
Você criará uma coleção de séries temporais, especificando as opções timeField, metaField e de granularidade. Você pratica MongoDB Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar MongoDB Academy?
Nenhuma experiência prévia é necessária. MongoDB Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Criando uma coleção de séries temporais”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de MongoDB Academy?
Sim. Cada aula de MongoDB Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Criando uma coleção de séries temporais
- Inserindo e consultando dados de séries temporais
- Agregações em janela sobre séries temporais
- Expiração automática de dados com expireAfterSeconds