INDEXEDDB DATA-STORAGE WEB-PERFORMANCE OFFLINE-FIRST BROWSER JAVASCRIPT FRONTEND DATABASE-INDEXING DATA-MANAGEMENT SCALABILITY

Strategi Indeks dan Query Lanjutan di IndexedDB: Mengelola Data Skala Besar di Browser

⏱️ 11 menit baca
👨‍💻

Strategi Indeks dan Query Lanjutan di IndexedDB: Mengelola Data Skala Besar di Browser

Sebagai developer web, kita sering berhadapan dengan kebutuhan untuk menyimpan data di sisi klien. Mulai dari preferensi pengguna, cache aset, hingga data aplikasi lengkap agar bisa berjalan offline-first. Untuk kebutuhan ini, localStorage dan sessionStorage memang mudah, tapi punya keterbatasan ukuran dan hanya bisa menyimpan string.

Di sinilah IndexedDB hadir sebagai pahlawan! IndexedDB adalah database transaksional NoSQL berbasis objek yang ada di dalam browser. Ia bisa menyimpan data terstruktur dalam jumlah besar, bahkan hingga puluhan atau ratusan MB (tergantung browser dan kapasitas perangkat pengguna). Ini menjadikannya pilihan ideal untuk aplikasi offline-first, PWA, atau aplikasi yang memproses data lokal dalam skala besar.

Namun, menyimpan data besar saja tidak cukup. Bagaimana jika Anda perlu mencari, memfilter, atau mengurutkan data dari ribuan bahkan jutaan record secara efisien agar aplikasi tetap responsif? Di sinilah strategi indeks dan query lanjutan di IndexedDB menjadi krusial.

Artikel ini akan membawa Anda “deep dive” ke IndexedDB, tidak hanya sekadar menyimpan dan mengambil data, tapi juga bagaimana mengoptimalkannya untuk skenario data skala besar dan query yang kompleks. Mari kita mulai!

1. Pendahuluan: Kenapa IndexedDB dan Kenapa Harus Dioptimalkan?

Bayangkan Anda sedang membangun aplikasi web untuk manajemen proyek yang bisa bekerja offline. Aplikasi ini perlu menyimpan ribuan tugas, ratusan proyek, dan detail pengguna. Atau mungkin Anda membuat aplikasi analitik yang memproses data sensor real-time langsung di browser. Dalam skenario ini, localStorage tidak akan sanggup. IndexedDB adalah solusinya.

IndexedDB menawarkan:

Namun, tanpa optimasi yang tepat, IndexedDB bisa menjadi bottleneck performa. Query yang tidak efisien pada data besar dapat membuat UI “jank” atau bahkan freeze. Oleh karena itu, memahami bagaimana IndexedDB bekerja di balik layar, terutama tentang indeks dan transaksi, adalah kunci.

2. Memahami Struktur Data di IndexedDB: Pondasi yang Kuat

Sebelum kita melangkah lebih jauh, mari kita ulas kembali struktur dasar IndexedDB:

💡 Penting: IndexedDB adalah database NoSQL berbasis objek. Artinya, Anda menyimpan objek JavaScript secara langsung, bukan baris dan kolom seperti di SQL.

Contoh sederhana pembuatan database dan object store:

const DB_NAME = 'ProjectManagementDB';
const DB_VERSION = 1;

let db;

function openDatabase() {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(DB_NAME, DB_VERSION);

    request.onerror = (event) => {
      console.error('Error opening IndexedDB:', event.target.errorCode);
      reject('Database error');
    };

    request.onsuccess = (event) => {
      db = event.target.result;
      console.log('Database opened successfully');
      resolve(db);
    };

    request.onupgradeneeded = (event) => {
      // Ini akan dijalankan jika versi database lebih baru atau database belum ada
      db = event.target.result;

      // Membuat object store 'projects'
      if (!db.objectStoreNames.contains('projects')) {
        const projectStore = db.createObjectStore('projects', { keyPath: 'id' });
        // Kita akan menambahkan indeks di bagian selanjutnya
      }

      // Membuat object store 'tasks'
      if (!db.objectStoreNames.contains('tasks')) {
        const taskStore = db.createObjectStore('tasks', { keyPath: 'id', autoIncrement: true });
        // Kita juga akan menambahkan indeks di sini
      }

      console.log('Database upgrade/creation complete');
    };
  });
}

// Panggil saat aplikasi dimulai
// openDatabase().then(() => { /* Lanjutkan inisialisasi aplikasi */ });

3. Kekuatan Indeks: Fondasi Query Efisien

Indeks adalah fitur paling penting untuk performa query di IndexedDB. Tanpa indeks, setiap kali Anda mencari data selain berdasarkan keyPath utama, IndexedDB harus melakukan full scan pada object store, yang sangat lambat untuk data besar. Dengan indeks, IndexedDB dapat langsung melompat ke record yang relevan, mirip dengan indeks di buku.

3.1. Membuat Indeks yang Tepat

Anda membuat indeks saat onupgradeneeded dipanggil (ketika database dibuat atau diupgrade).

// Dalam request.onupgradeneeded
const projectStore = db.createObjectStore('projects', { keyPath: 'id' });
// ✅ Indeks untuk mencari project berdasarkan nama
projectStore.createIndex('nameIndex', 'name', { unique: false });
// ✅ Indeks untuk mencari project berdasarkan status (misal: 'active', 'completed')
projectStore.createIndex('statusIndex', 'status', { unique: false });
// ✅ Indeks untuk mencari project berdasarkan tanggal_mulai dan tanggal_akhir
projectStore.createIndex('dateRangeIndex', ['startDate', 'endDate'], { unique: false });

const taskStore = db.createObjectStore('tasks', { keyPath: 'id', autoIncrement: true });
// ✅ Indeks untuk mencari task berdasarkan project_id
taskStore.createIndex('projectIdIndex', 'projectId', { unique: false });
// ✅ Indeks untuk mencari task berdasarkan status dan prioritas
taskStore.createIndex('statusPriorityIndex', ['status', 'priority'], { unique: false });
// ✅ Indeks unik untuk nama task (misal: tidak boleh ada dua task dengan nama yang sama dalam satu project)
taskStore.createIndex('taskNameUniqueIndex', ['projectId', 'name'], { unique: true });

📌 Catatan Penting:

3.2. Kapan Harus Membuat Indeks?

❌ Hindari Terlalu Banyak Indeks: Setiap indeks membutuhkan ruang penyimpanan dan harus diperbarui setiap kali data di object store berubah. Terlalu banyak indeks dapat memperlambat operasi tulis (add, put, delete). Buat indeks hanya untuk properti yang sering digunakan dalam query atau pengurutan.

4. Strategi Query Lanjutan: Menggali Data Lebih Dalam

Setelah indeks dibuat, saatnya menggunakannya untuk query yang powerful.

4.1. Menggunakan IDBKeyRange secara Efektif

IDBKeyRange adalah objek yang mendefinisikan rentang kunci yang akan dicari. Ini jauh lebih efisien daripada mengambil semua data lalu memfilternya secara manual.

async function getTasksByStatusAndPriority(status, priority) {
  const transaction = db.transaction(['tasks'], 'readonly');
  const store = transaction.objectStore('tasks');
  const index = store.index('statusPriorityIndex'); // Menggunakan multi-field index

  // Mencari task dengan status='pending' DAN priority=1
  const keyRange = IDBKeyRange.only([status, priority]);

  const tasks = [];
  return new Promise((resolve, reject) => {
    index.openCursor(keyRange).onsuccess = (event) => {
      const cursor = event.target.result;
      if (cursor) {
        tasks.push(cursor.value);
        cursor.continue();
      } else {
        resolve(tasks);
      }
    };
    transaction.onerror = (event) => reject(event.target.error);
  });
}

async function getProjectsByStartDateRange(start, end) {
  const transaction = db.transaction(['projects'], 'readonly');
  const store = transaction.objectStore('projects');
  const index = store.index('dateRangeIndex');

  // Mencari project yang dimulai antara '2023-01-01' dan '2023-03-31'
  const keyRange = IDBKeyRange.bound([start, ''], [end, '\uffff'], false, false); // '\uffff' adalah karakter unicode terbesar

  const projects = [];
  return new Promise((resolve, reject) => {
    index.openCursor(keyRange).onsuccess = (event) => {
      const cursor = event.target.result;
      if (cursor) {
        projects.push(cursor.value);
        cursor.continue();
      } else {
        resolve(projects);
      }
    };
    transaction.onerror = (event) => reject(event.target.error);
  });
}

// Contoh penggunaan
// getTasksByStatusAndPriority('pending', 1).then(tasks => console.log('Pending High Priority Tasks:', tasks));
// getProjectsByStartDateRange('2023-01-01', '2023-03-31').then(projects => console.log('Projects in Q1:', projects));

Parameter IDBKeyRange:

4.2. Paginasi Data Besar

Untuk data yang sangat besar, mengambil semua record sekaligus akan memakan memori dan waktu. Paginasi adalah solusinya. Anda bisa menggunakan cursor.continue(key) atau cursor.advance(count) untuk melewati record.

async function getPaginatedTasks(projectId, pageSize, lastTaskId = null) {
  const transaction = db.transaction(['tasks'], 'readonly');
  const store = transaction.objectStore('tasks');
  const index = store.index('projectIdIndex');

  const tasks = [];
  let count = 0;

  return new Promise((resolve, reject) => {
    const request = index.openCursor(IDBKeyRange.only(projectId));

    request.onsuccess = (event) => {
      const cursor = event.target.result;
      if (cursor) {
        // Jika ada lastTaskId, lanjutkan dari sana
        if (lastTaskId && cursor.value.id <= lastTaskId) {
          cursor.continue(lastTaskId); // Lanjutkan dari keyPath utama (id)
          return;
        }

        if (count < pageSize) {
          tasks.push(cursor.value);
          count++;
          cursor.continue();
        } else {
          resolve(tasks);
        }
      } else {
        resolve(tasks);
      }
    };
    transaction.onerror = (event) => reject(event.target.error);
  });
}

// Contoh penggunaan paginasi
// getPaginatedTasks('project-abc', 10).then(tasks => {
//   console.log('First 10 tasks for project-abc:', tasks);
//   // Untuk halaman berikutnya, gunakan ID task terakhir
//   const lastId = tasks.length > 0 ? tasks[tasks.length - 1].id : null;
//   if (lastId) {
//     getPaginatedTasks('project-abc', 10, lastId).then(nextTasks => console.log('Next 10 tasks:', nextTasks));
//   }
// });

🎯 Tips Paginasi:

5. Optimasi Transaksi untuk Operasi Massal

IndexedDB bersifat transaksional. Ini berarti sekelompok operasi (add, put, delete) akan berjalan sebagai satu unit. Jika ada satu operasi yang gagal, seluruh transaksi akan dibatalkan (rollback).

5.1. Mode Transaksi

// Transaksi readwrite untuk menambahkan/mengupdate beberapa item
async function addOrUpdateMultipleTasks(tasks) {
  const transaction = db.transaction(['tasks'], 'readwrite');
  const store = transaction.objectStore('tasks');

  return new Promise((resolve, reject) => {
    transaction.oncomplete = () => resolve('All tasks processed');
    transaction.onerror = (event) => reject(event.target.error);

    tasks.forEach(task => {
      store.put(task); // put akan menambah jika belum ada, update jika sudah ada
    });
  });
}

// Contoh penggunaan
// const newTasks = [
//   { id: 't101', projectId: 'p1', name: 'Design homepage', status: 'pending', priority: 1 },
//   { id: 't102', projectId: 'p1', name: 'Implement login', status: 'completed', priority: 2 }
// ];
// addOrUpdateMultipleTasks(newTasks).then(msg => console.log(msg));

5.2. Batching Writes

Saat melakukan operasi tulis massal (misalnya mengimpor data dari API), sangat penting untuk menggabungkan semua operasi dalam satu transaksi readwrite. Membuat transaksi terpisah untuk setiap item akan sangat memperlambat performa karena overhead transaksi.

❌ Buruk (banyak transaksi)

// Ini akan sangat lambat untuk data besar!
async function addTasksInefficiently(tasks) {
  for (const task of tasks) {
    const transaction = db.transaction(['tasks'], 'readwrite');
    const store = transaction.objectStore('tasks');
    await new Promise((resolve, reject) => {
      store.add(task).onsuccess = resolve;
      transaction.onerror = reject;
    });
  }
}

✅ Baik (satu transaksi)

async function addTasksEfficiently(tasks) {
  const transaction = db.transaction(['tasks'], 'readwrite');
  const store = transaction.objectStore('tasks');

  return new Promise((resolve, reject) => {
    transaction.oncomplete = () => resolve('All tasks added efficiently');
    transaction.onerror = (event) => reject(event.target.error);

    tasks.forEach(task => {
      store.add(task);
    });
  });
}

5.3. Menghindari Blocking Main