0Pricing
MongoDB Academy · Pelajaran

Properti Indeks: Unique, Sparse, Partial, TTL

Peserta didik akan membuat indeks khusus dengan properti unique, sparse, partial, dan TTL untuk menerapkan batasan serta mengotomatiskan pembersihan.

Properti Indeks: Unique, Sparse, Partial, TTL adalah pelajaran MongoDB Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar MongoDB Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus MongoDB Academy mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Index Properties Overview

Beyond the basic B-tree structure, MongoDB indexes support several property modifiers that change how they behave: unique enforces distinctness, sparse skips null entries, partial limits the index to a subset of documents, and TTL automatically expires documents. Each property is set in the options object of createIndex() and serves a specific purpose in production schemas.

Unique Indexes

A unique index guarantees that no two documents in the collection can have the same value for the indexed field. Any insert or update that would produce a duplicate triggers a DuplicateKey error. Unique indexes are commonly used on fields like email, username, or any natural key. The _id index is always unique.

// Unique index on email
db.users.createIndex(
  { email: 1 },
  { unique: true }
);

// First insert succeeds
db.users.insertOne({ email: 'alice@example.com', name: 'Alice' });

// Second insert with same email throws E11000 DuplicateKey
db.users.insertOne({ email: 'alice@example.com', name: 'Bob' });

Unique Compound Indexes

Unique constraints can span multiple fields in a compound index. The uniqueness check applies to the combination of the indexed fields, not each field individually. This is perfect for modelling relationships like 'a user can only follow another user once' without a separate lookup query.

// A user can only 'follow' each other user once
db.follows.createIndex(
  { followerId: 1, followingId: 1 },
  { unique: true }
);

// This succeeds
db.follows.insertOne({ followerId: 'u1', followingId: 'u2' });

// This fails - same pair already exists
db.follows.insertOne({ followerId: 'u1', followingId: 'u2' });

Sparse Indexes

By default, a MongoDB index includes entries for every document, even those where the indexed field is missing (stored as null). A sparse index only includes documents that have the indexed field. This is useful for optional fields that appear in only a small subset of documents—without sparse, every null/missing document would bloat the index unnecessarily.

// Only documents WITH a phoneNumber are indexed
db.users.createIndex(
  { phoneNumber: 1 },
  { sparse: true }
);

// This document is NOT in the index (phoneNumber absent)
db.users.insertOne({ name: 'Alice', email: 'a@b.com' });

// This document IS in the index
db.users.insertOne({ name: 'Bob', phoneNumber: '+1555000' });

Sparse Unique: Optional Unique Fields

Combining sparse: true with unique: true lets you create a unique constraint on an optional field. Without sparse, a unique index would only allow one document to omit the field (since all missing values would be stored as null and null must be unique). Sparse + unique means: if the field exists, it must be distinct; if it's missing, the document is simply excluded from the index.

// Optional unique twitterHandle
db.users.createIndex(
  { twitterHandle: 1 },
  { unique: true, sparse: true }
);

// Multiple users without twitterHandle are all allowed
db.users.insertMany([
  { name: 'Alice' },
  { name: 'Bob' },
  { name: 'Carol', twitterHandle: '@carol' }
]);

Partial Indexes

A partial index indexes only the documents that match a partialFilterExpression. This is more flexible than sparse (which only checks for field existence) because you can specify any filter condition. Partial indexes are smaller and faster to maintain than full indexes when a query always includes a predictable filter on the collection.

// Only index orders that are 'active' - skips completed/cancelled
db.orders.createIndex(
  { userId: 1, createdAt: -1 },
  {
    partialFilterExpression: { status: 'active' },
    name: 'idx_orders_active'
  }
);

// This query hits the partial index because it includes status:active
db.orders.find({ userId: 'u1', status: 'active' })
  .sort({ createdAt: -1 });

Partial Index Query Requirements

MongoDB can use a partial index only when the query guarantees that it requests a subset of the documents covered by the index. In practice, this means your query filter must include the same condition as the partialFilterExpression. Queries that don't include this condition will fall back to a collection scan or another index because the partial index might be missing matching documents.

// Partial index only covers status: 'active'

// USES the partial index (filter includes status: 'active')
db.orders.find({ userId: 'u1', status: 'active' });

// DOES NOT USE the partial index (query might return completed orders)
db.orders.find({ userId: 'u1' });
// MongoDB must use full scan or a different index here

TTL Indexes: Automatic Expiry

A TTL (Time-To-Live) index is a special single-field index on a date field that tells MongoDB to automatically delete documents after a specified number of seconds. A background thread runs every 60 seconds and removes expired documents. TTL indexes are perfect for session data, cache entries, audit logs, and any data with a natural shelf life.

// Automatically delete sessions 24 hours after 'createdAt'
db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 86400 } // 86400 = 24 * 60 * 60
);

// Insert a session - it will auto-delete after 24h
db.sessions.insertOne({
  userId: 'u1',
  token: 'abc123',
  createdAt: new Date()
});

TTL on a Specific Expiry Field

Instead of a fixed duration from creation, you can set expireAfterSeconds: 0 and store the exact expiry timestamp in the indexed date field. MongoDB will delete each document at the moment the stored date passes. This gives you per-document control over expiry, useful for subscription end dates, JWT token expiry, or scheduled job cleanup.

// Delete each document at its own 'expiresAt' time
db.tokens.createIndex(
  { expiresAt: 1 },
  { expireAfterSeconds: 0 }
);

// This token expires in 1 hour
const oneHourFromNow = new Date(Date.now() + 3600 * 1000);
db.tokens.insertOne({
  userId: 'u1',
  value: 'tok_xyz',
  expiresAt: oneHourFromNow
});

TTL Limitations to Know

TTL indexes have a few important restrictions: the indexed field must be a BSON date (not a string); TTL indexes cannot be compound; the background cleanup thread runs approximately every 60 seconds so there is a small delay between expiry time and actual deletion; and TTL indexes do not apply to capped collections. The 60-second delay is usually acceptable but matters for high-precision use cases.

// TTL only works on ISODate fields, not strings
// WRONG - will NOT expire:
db.logs.insertOne({ ts: '2024-01-01T00:00:00Z' });

// CORRECT - will expire:
db.logs.insertOne({ ts: new Date('2024-01-01T00:00:00Z') });

// Also, TTL cannot be compound:
// This is INVALID:
db.logs.createIndex({ ts: 1, userId: 1 }, { expireAfterSeconds: 3600 });

Choosing the Right Index Property

Use unique to enforce natural keys and prevent duplicates. Use sparse when a field is optional and present in only a minority of documents. Use partial when queries always include a known filter condition and you want a leaner index. Use TTL to automate data expiry without application-level cron jobs. These properties can be combined: unique + sparse is common for optional unique identifiers.

// Summary of all four property types

// Unique
db.users.createIndex({ email: 1 }, { unique: true });

// Sparse
db.users.createIndex({ phone: 1 }, { sparse: true });

// Partial
db.orders.createIndex({ userId: 1 }, { partialFilterExpression: { status: 'pending' } });

// TTL
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 });

Quick Check

Test your understanding of MongoDB index properties from this lesson.

Lesson Recap

In this lesson you learned: unique indexes enforce distinctness on one or multiple fields, sparse indexes skip documents that lack the indexed field, partial indexes index only documents matching a filter expression, and TTL indexes automatically delete expired documents. Next up we learn to read explain() output to diagnose slow queries.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Properti Indeks: Unique, Sparse, Partial, TTL” gratis?

Ya — teks lengkap “Properti Indeks: Unique, Sparse, Partial, TTL” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus MongoDB Academy, upgrade ke CoddyKit PRO. Kursus MongoDB Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Properti Indeks: Unique, Sparse, Partial, TTL”?

Peserta didik akan membuat indeks khusus dengan properti unique, sparse, partial, dan TTL untuk menerapkan batasan serta mengotomatiskan pembersihan. Kamu berlatih MongoDB Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai MongoDB Academy?

Tidak diperlukan pengalaman sebelumnya. MongoDB Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Properti Indeks: Unique, Sparse, Partial, TTL” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran MongoDB Academy ini?

Ya. Setiap pelajaran MongoDB Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Cara Kerja Indeks B-Tree MongoDB
  2. Membuat Indeks Satu Bidang dan Gabungan
  3. Properti Indeks: Unique, Sparse, Partial, TTL
  4. Membaca Keluaran explain() untuk Mendiagnosis Kueri
← Kembali ke MongoDB Academy