插入和查询时间序列数据
您将批量插入测量数据，并使用时间范围和元数据字段筛选条件查询这些数据。
插入和查询时间序列数据 是 CoddyKit 上的免费 MongoDB Academy 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 MongoDB Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 MongoDB Academy 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Inserting Measurements Into Time Series
Inserting into a time series collection uses the exact same insertOne() and insertMany() methods as regular collections. MongoDB inspects the timeField (which must be a BSON Date) and the metaField to place the measurement into the correct internal bucket. The insert API is intentionally identical so existing application code requires minimal changes when adopting time series collections.
const now = new Date()
db.sensorReadings.insertOne({
timestamp: now,
sensorId: 'sensor-42',
temperature: 23.1,
humidity: 58.4,
batteryLevel: 87
})Bulk Inserting Historical Data
When loading historical measurements, always prefer insertMany() over repeated insertOne() calls. MongoDB can batch the data into buckets far more efficiently with bulk operations. For very large datasets (millions of rows), consider using mongoimport or the Node.js driver's bulkWrite() with insertOne operations grouped in batches of 1,000–5,000 documents.
const readings = []
const base = new Date('2024-06-01T00:00:00Z')
for (let i = 0; i < 1440; i++) {
readings.push({
timestamp: new Date(base.getTime() + i * 60000),
sensorId: 'sensor-42',
temperature: 20 + Math.random() * 5,
humidity: 50 + Math.random() * 20
})
}
db.sensorReadings.insertMany(readings)Basic Time-Range Queries
The most common query pattern for time series data is a time-range filter on the timeField using $gte and $lte. MongoDB uses the internal bucket boundaries to skip entire buckets that fall outside the requested range, achieving much better performance than scanning every document. Always include a time filter when querying large time series collections.
// Last 1 hour of readings from one sensor
const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000)
db.sensorReadings.find({
sensorId: 'sensor-42',
timestamp: { $gte: oneHourAgo }
}).sort({ timestamp: 1 })
// Specific day range
db.sensorReadings.find({
timestamp: {
$gte: new Date('2024-06-01T00:00:00Z'),
$lt: new Date('2024-06-02T00:00:00Z')
}
})Filtering on Metadata Fields
Filtering on the metaField is highly optimised — MongoDB stores the meta value at the bucket level and can skip entire buckets belonging to other series without inspecting individual measurements. This makes queries like 'all readings from sensor-42 in the last 6 hours' extremely fast even on collections holding billions of measurements from thousands of sensors.
// Query a specific device
db.sensorReadings.find({
sensorId: 'sensor-42',
timestamp: { $gte: new Date('2024-06-01T00:00:00Z') }
})
// Query multiple devices using $in on the metaField
db.sensorReadings.find({
sensorId: { $in: ['sensor-42', 'sensor-43', 'sensor-44'] },
timestamp: { $gte: new Date('2024-06-01T00:00:00Z') }
})Aggregating Time Series With $match and $group
The aggregation pipeline is the primary tool for computing statistics over time series data. A typical pattern is to $match on the time range and metaField first (so MongoDB can skip irrelevant buckets), then $group to compute averages, minimums, and maximums. Always place $match as the very first stage to enable bucket pruning.
// Average temperature per hour for one sensor
db.sensorReadings.aggregate([
{
$match: {
sensorId: 'sensor-42',
timestamp: { $gte: new Date('2024-06-01T00:00:00Z') }
}
},
{
$group: {
_id: {
year: { $year: '$timestamp' },
month: { $month: '$timestamp' },
day: { $dayOfMonth: '$timestamp' },
hour: { $hour: '$timestamp' }
},
avgTemp: { $avg: '$temperature' },
maxTemp: { $max: '$temperature' },
minTemp: { $min: '$temperature' }
}
},
{ $sort: { '_id.hour': 1 } }
])Using $dateTrunc for Time Bucketing
The $dateTrunc aggregation expression (added in MongoDB 5.0) simplifies grouping measurements into fixed-width time windows. It truncates a date to the nearest unit boundary — for example, truncating to 'hour' groups all measurements within the same hour under the same key. This replaces the verbose multi-field date extraction approach.
// Group readings into 15-minute windows
db.sensorReadings.aggregate([
{
$match: {
sensorId: 'sensor-42',
timestamp: { $gte: new Date('2024-06-01T00:00:00Z') }
}
},
{
$group: {
_id: {
$dateTrunc: {
date: '$timestamp',
unit: 'minute',
binSize: 15
}
},
avgTemp: { $avg: '$temperature' },
count: { $sum: 1 }
}
},
{ $sort: { _id: 1 } }
])Projecting Time Series Results
Use projection to limit the fields returned from time series queries, just as with regular collections. Projecting only the fields you need reduces network transfer and client memory usage. Note that the timeField and metaField are always available for projection, and the _id field can be suppressed with _id: 0.
// Return only timestamp and temperature
db.sensorReadings.find(
{
sensorId: 'sensor-42',
timestamp: { $gte: new Date('2024-06-01T08:00:00Z') }
},
{
_id: 0,
timestamp: 1,
temperature: 1
}
).sort({ timestamp: 1 })Counting and Sampling Measurements
Use countDocuments() with a filter to count measurements in a time range. For large collections, estimatedDocumentCount() provides a fast approximate total using collection metadata. When debugging or building dashboards, $sample in an aggregation pipeline lets you retrieve a random subset of measurements without scanning the full result set.
// Count readings in last 24 hours
const since = new Date(Date.now() - 86400000)
db.sensorReadings.countDocuments({
sensorId: 'sensor-42',
timestamp: { $gte: since }
})
// Random sample of 10 recent measurements
db.sensorReadings.aggregate([
{ $match: { timestamp: { $gte: since } } },
{ $sample: { size: 10 } }
])Node.js Driver: Reading Time Series Data
In a Node.js application, querying time series collections is identical to querying regular collections. Use the standard find() or aggregate() methods on the collection object. Since time series queries often return large result sets, use async iteration over the cursor rather than loading everything into memory with toArray().
const { MongoClient } = require('mongodb')
async function getRecentReadings(client) {
const db = client.db('iot')
const col = db.collection('sensorReadings')
const since = new Date(Date.now() - 3600000) // last hour
const cursor = col.find(
{ sensorId: 'sensor-42', timestamp: { $gte: since } },
{ projection: { _id: 0, timestamp: 1, temperature: 1 } }
).sort({ timestamp: 1 })
for await (const doc of cursor) {
console.log(doc.timestamp, doc.temperature)
}
}Performance: Why Time Range First
The golden rule of querying time series data is: always filter by time range before anything else. MongoDB's bucket pruning only activates when the timeField filter appears in the query. Without it, MongoDB must scan every bucket. Additionally, combine the time filter with the metaField filter to leverage both forms of bucket skipping — time boundaries and series identity.
// GOOD: time + meta filter — fast bucket pruning
db.sensorReadings.find({
sensorId: 'sensor-42', // prune by series
timestamp: { $gte: since }, // prune by time
temperature: { $gt: 30 } // measurement filter applied after pruning
})
// BAD: no time filter — scans all buckets
db.sensorReadings.find({
temperature: { $gt: 30 } // forces full scan
})Monitoring Bucket Utilisation
You can inspect the internal bucket documents using a system namespace: system.buckets.<collectionName>. While you cannot write to this namespace directly, reading it reveals how many buckets exist and how many measurements each bucket holds. This is useful when tuning granularity — ideally each bucket should be close to its maximum fill level (3,600 for 'seconds' granularity).
// Count internal bucket documents
db['system.buckets.sensorReadings'].countDocuments()
// Inspect a sample bucket (internal format)
db['system.buckets.sensorReadings'].findOne()Quick Check
Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.
Lesson Recap
In this lesson you learned: insertMany() with batches is the efficient way to load time series data, filtering by timeField and metaField together enables bucket pruning for fast range queries, and $dateTrunc in aggregation pipelines simplifies grouping measurements into fixed-width time windows. Next up we explore windowed aggregations over time series using $setWindowFields.
常见问题解答
「插入和查询时间序列数据」课时是免费的吗？
是的 — 「插入和查询时间序列数据」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 MongoDB Academy 课程的其余内容，请升级到 CoddyKit PRO。 MongoDB Academy 课程共包含 4 节课。
「插入和查询时间序列数据」这节课中我会学到什么？
您将批量插入测量数据，并使用时间范围和元数据字段筛选条件查询这些数据。 你通过在浏览器中直接运行的动手代码来练习 MongoDB Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 MongoDB Academy 需要有经验吗？
无需任何先前经验。CoddyKit 上的 MongoDB Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。
「插入和查询时间序列数据」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 MongoDB Academy 课中编写并运行代码吗？
能。每节 MongoDB Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。