MongoDB Academy · บทเรียน

การสร้างคอลเลกชันอนุกรมเวลา

ผู้เรียนจะสร้างคอลเลกชันอนุกรมเวลา โดยระบุตัวเลือก timeField, metaField และระดับความละเอียด

บทเรียน 1 จาก 413 ขั้นตอน

การสร้างคอลเลกชันอนุกรมเวลา เป็นบทเรียน MongoDB Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน MongoDB Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส MongoDB Academy มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

Introduction to Time Series Collections

MongoDB 5.0 introduced native time series collections — a specialised collection type optimised for storing and querying measurements that change over time. Common use cases include IoT sensor readings, application metrics, financial ticks, and server monitoring data. Unlike regular collections, time series collections use a columnar storage format internally, dramatically reducing storage space and improving query performance on time-range filters.

Key Fields: timeField, metaField, granularity

Every time series collection requires three key options when created. The timeField is the document field that holds the timestamp (must be a BSON Date). The metaField identifies the series — for example, a sensor ID or device name. The granularity hint ('seconds', 'minutes', or 'hours') tells MongoDB how frequently measurements arrive, allowing it to optimise bucket sizing internally.

Creating With createCollection Command

Use db.createCollection() with a timeseries option object to create a time series collection. You cannot convert an existing regular collection to time series — you must create it fresh. The collection will appear in show collections with a special timeseries type indicator.

db.createCollection('sensorReadings', {
  timeseries: {
    timeField: 'timestamp',
    metaField: 'sensorId',
    granularity: 'seconds'
  }
})

Granularity Affects Bucket Sizing

The granularity option controls how MongoDB groups measurements into internal bucket documents. With 'seconds', buckets span one hour (3,600 measurements per bucket). With 'minutes', buckets span 24 hours. With 'hours', buckets span 30 days. Choosing the wrong granularity means more bucket documents and worse compression — always match granularity to your actual data arrival rate.

// 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'
  }
})

Document Shape for Time Series Inserts

Documents inserted into a time series collection must include the timeField as a proper BSON Date. The metaField value identifies which series this measurement belongs to (e.g., a device ID). All other fields are called measurement fields and can hold any BSON value. MongoDB will reject documents where the timeField is missing or not a Date.

// 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
}

Inserting Single and Multiple Measurements

Insert into a time series collection exactly as you would a regular collection — using insertOne() or insertMany(). MongoDB handles the internal bucketing automatically. It is best practice to batch inserts with insertMany() when loading historical data, as this amortises the overhead of bucket creation across many measurements.

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

Adding Automatic Expiration With expireAfterSeconds

Time series collections support automatic data expiration via the expireAfterSeconds option. Once set, MongoDB's background TTL thread deletes entire buckets when all measurements in the bucket are older than the threshold. This is more efficient than a regular TTL index because entire internal bucket documents are dropped at once rather than individual measurement documents.

// Create with 90-day TTL
db.createCollection('sensorReadings', {
  timeseries: {
    timeField: 'timestamp',
    metaField: 'sensorId',
    granularity: 'minutes'
  },
  expireAfterSeconds: 60 * 60 * 24 * 90  // 90 days
})

Querying Time Series Collections

Queries on time series collections look identical to regular find() queries. MongoDB automatically uses the internal bucket structure to skip irrelevant buckets when filtering by time range. Filtering on the metaField is also highly efficient. Avoid querying only on measurement fields without a time or meta filter, as this forces a full collection scan across all 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 })

Updating the Granularity After Creation

You can increase the granularity of an existing time series collection (e.g., from 'seconds' to 'minutes') using the collMod command. However, you cannot decrease it — MongoDB will return an error if you try to move from 'minutes' back to 'seconds'. Updating the expireAfterSeconds setting is also possible via collMod without recreating the 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
})

Limitations and Restrictions

Time series collections have a few important restrictions compared to regular collections. You cannot shard a time series collection on the timeField alone — a hashed metaField component is required. Updates and deletes are limited: before MongoDB 5.1, only deletes by metaField or time range were supported. Additionally, time series collections do not support unique indexes, sparse indexes, or capped collections.

Verifying Collection Type and Options

After creating a time series collection, inspect it using db.getCollectionInfos() to confirm the timeseries options are correctly stored. You can also run db.sensorReadings.stats() to see storage statistics, including the number of internal bucket documents MongoDB is maintaining behind the scenes.

// Inspect time series collection metadata
db.getCollectionInfos({ name: 'sensorReadings' })

// Check storage stats
db.sensorReadings.stats()

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: time series collections use a columnar bucket format for high-compression append-heavy workloads, three key options (timeField, metaField, granularity) control how measurements are organised and bucketed, and expireAfterSeconds enables efficient automatic purging of old data at the bucket level. Next up we explore inserting and querying time series data in depth.

เริ่มต้นได้ฟรี

เรียนรู้ JavaScript ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
30
บทเรียน
120

คำถามที่พบบ่อย

บทเรียน “การสร้างคอลเลกชันอนุกรมเวลา” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การสร้างคอลเลกชันอนุกรมเวลา” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส MongoDB Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส MongoDB Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การสร้างคอลเลกชันอนุกรมเวลา”

ผู้เรียนจะสร้างคอลเลกชันอนุกรมเวลา โดยระบุตัวเลือก timeField, metaField และระดับความละเอียด คุณปฏิบัติ MongoDB Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน MongoDB Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน MongoDB Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การสร้างคอลเลกชันอนุกรมเวลา” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน MongoDB Academy นี้ได้ไหม

ได้ บทเรียน MongoDB Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การสร้างคอลเลกชันอนุกรมเวลา
  2. การแทรกและการค้นหาข้อมูลอนุกรมเวลา
  3. การรวมข้อมูลแบบหน้าต่างบนอนุกรมเวลา
  4. การหมดอายุข้อมูลโดยอัตโนมัติด้วย expireAfterSeconds
← กลับไปที่ MongoDB Academy