MongoDB find(): Panduan Lengkap Pemula untuk Melakukan Query Data

MongoDB adalah database NoSQL populer yang dirancang untuk fleksibilitas dan performa. Tidak seperti database relasional tradisional yang menggunakan tabel terstruktur dan SQL, MongoDB menyimpan data dalam dokumen yang fleksibel mirip JSON. Ini membuatnya ideal bagi pengembang yang bekerja dengan data dinamis atau semi-terstruktur.

Salah satu operasi terpenting yang akan Anda lakukan di MongoDB adalah melakukan query terhadap data, dan metode yang paling umum digunakan untuk ini adalah find(). Baik Anda baru mulai atau ingin meningkatkan kemampuan query, memahami cara kerja find() sangat penting untuk menavigasi dan memanipulasi data MongoDB Anda secara efektif.

Bayangkan Anda sedang menjelajahi database film. Anda ingin menemukan semua film fiksi ilmiah yang dirilis setelah tahun 2000, atau mungkin membuat daftar semua komentar pengguna yang dibuat dalam rentang waktu tertentu. Di sinilah find() unggul.

Dalam artikel ini, Anda akan mempelajari cara menggunakan metode find() untuk mengambil dokumen dari sebuah koleksi, menerapkan filter, memproyeksikan field, mengurutkan hasil, dan mengoptimalkan performa—semuanya sambil bekerja dengan dataset sample_mflix.

Untuk panduan praktik langsung menggunakan MongoDB dalam alur kerja data science, lihat kursus Introduction to MongoDB in Python.

Pengenalan find() di MongoDB

Metode find() adalah cara utama MongoDB untuk mengambil dokumen dari sebuah koleksi. Metode ini mengembalikan sebuah cursor ke dokumen yang cocok dengan query yang ditentukan. Anda kemudian dapat melakukan iterasi atas cursor ini, atau mengonversinya ke array, bergantung pada kebutuhan aplikasi Anda.

Berikut adalah sintaks lengkapnya:

db.collection.find(<query>, <projection>, <options>)

Parameter

• query (opsional): Dokumen yang mendefinisikan kriteria untuk memilih dokumen. Jika Anda menghilangkan parameter ini atau mengoper dokumen kosong ({}), find() akan mengembalikan semua dokumen dalam koleksi.
• projection (opsional): Dokumen yang menentukan field mana yang akan dikembalikan. Anda dapat menyertakan (1) atau mengecualikan (0) field. Secara default, MongoDB mengembalikan semua field, termasuk _id.
• options (opsional): Dokumen tambahan untuk mengonfigurasi perilaku query. Anda dapat mengatur hal seperti urutan sortir, batas paginasi, timeout, dan hint indeks.

Contoh

Agar konsepnya sejelas dan sesederhana mungkin untuk diterapkan, kita akan menggunakan dataset sampel MongoDB Atlas—khususnya database sample_mflix. Dataset ini mencakup koleksi seperti movies, comments, users, dan theaters, yang akan kita rujuk sepanjang artikel untuk mendemonstrasikan setiap contoh.

db.books.find(
  { year: { $gte: 2000 } },              // query: books published in or after 2000
  { title: 1, author: 1, _id: 0 },        // projection: include only title and author
  { sort: { title: 1 }, limit: 5 }       // options: sort by title, return only 5 books
)

Query ini:

• Menyaring buku yang diterbitkan pada tahun 2000 atau setelahnya.
• Mengembalikan hanya field title dan author (mengecualikan _id).
• Mengurutkan hasil secara alfabetis berdasarkan title (A–Z).
• Membatasi output ke lima buku pertama yang cocok.

Gambar 1. Query ini menemukan film yang dirilis setelah 2000, diurutkan berdasarkan judul dan dibatasi hingga lima hasil.

Hasilnya adalah sebuah cursor, yang memuat dokumen yang cocok secara malas (lazy) saat Anda mengiterasinya. Anda dapat menggunakan .toArray() atau .forEach() untuk memproses hasil.

Jika Anda terhubung melalui shell MongoDB (mongosh) dan tidak menetapkan hasilnya ke sebuah variabel, hanya 20 dokumen pertama yang akan ditampilkan secara default. Untuk melihat dokumen tambahan, ketik dan tekan Enter. Proses ini akan terus mengambil batch berikutnya dari cursor.

> Catatan: Hal di atas adalah perilaku khusus shell, bukan keterbatasan MongoDB. Pada sebagian besar driver MongoDB (misalnya, Node.js, Python, Java), pemanggilan .toArray() atau iterasi atas cursor secara otomatis mengambil semua hasil yang cocok. Perilaku cursor dapat bervariasi tergantung lingkungan dan bahasa yang Anda gunakan.

Gambar 2. Query ini mengambil semua film, mengembalikan hanya field _id dan menggunakan cursor untuk mengambil hasil tambahan.

Jika Anda baru mengenal database NoSQL, kursus Introduction to NoSQL menawarkan konsep dasar yang melengkapi tutorial ini.

Menulis Query Pertama Anda

Melanjutkan contoh film, misalkan Anda ingin mengambil semua film dalam genre Sci-Fi. Berikut caranya:

db.movies.find({ genres: "Sci-Fi" })

Sekarang, Anda hanya menginginkan film yang dirilis pada atau setelah tahun 2000:

db.movies.find({ year: { $gte: 2000 } })

Dan jika Anda menginginkan keduanya? Gabungkan kondisi:

db.movies.find({ genres: "Sci-Fi", year: { $gte: 2000 } })

Atau, Anda bisa menulisnya secara eksplisit menggunakan $and:

db.movies.find({ $and: [ { genres: "Sci-Fi" }, { year: { $gte: 2000 } } ] })

Kedua query mengembalikan hasil yang sama—dokumen dengan genre Sci-Fi dan tahun rilis 2000 atau lebih baru. Bentuk pertama lebih ringkas dan lebih disukai saat field-nya berbeda.

Gambar 3. Ini adalah berbagai cara menulis query yang menghasilkan hasil yang sama.

Gunakan find() seperti corong filter—setiap kondisi mempersempit hasil Anda.

Menggunakan Operator Perbandingan dan Logika

Sekarang, mari tinjau cara menggunakan operator perbandingan dan logika untuk meningkatkan level query Anda.

Operator perbandingan

• $eq, $ne: sama dengan, tidak sama dengan
• $gt, $gte, $lt, $lte: lebih besar/kecil dari (atau sama dengan)
• $in, $nin: ada atau tidak ada dalam array

Bayangkan Anda melacak pesanan pelanggan dan ingin pesanan antara $100 dan $500:

db.orders.find({ total: { $gte: 100, $lte: 500 } })

Operator logika

• $and, $or, $nor, $not

Sekarang, bayangkan Anda ingin menampilkan produk di kategori "Books" atau berharga di bawah $20. Berikut contoh querynya:

db.products.find({ $or: [ { category: "Books" }, { price: { $lt: 20 } } ] })

Melakukan query pada field bersarang

Anda dapat mengakses field bersarang menggunakan notasi titik:

db.customers.find({ "address.city": "Chicago" })

Memproyeksikan Field

Proyeksi memungkinkan Anda mengembalikan hanya yang diperlukan, yang dapat secara signifikan meningkatkan performa dan kejelasan.

db.movies.find({}, { directors: 1, languages: 1, _id: 0 })

Penting: Saat menentukan proyeksi, MongoDB mengharuskan Anda memilih antara dua mode: Menyertakan field tertentu (1) atau mengecualikan field tertentu (0). Anda tidak dapat mencampur kedua gaya dalam proyeksi yang sama, kecuali untuk field _id, yang dapat dikecualikan meskipun field lain disertakan.

✅ Valid (hanya penyertaan):

db.movies.find({}, { directors: 1, languages: 1 })

✅ Valid (hanya pengecualian):

db.movies.find({}, { directors: 0, _id: 0 })

❌ Tidak valid (campuran penyertaan dan pengecualian):

db.movies.find({}, { directors: 1, languages: 0 }) // Not allowed

Satu-satunya pengecualian adalah field _id, yang dapat Anda kecualikan meskipun menyertakan field lain:

db.movies.find({}, { directors: 1, _id: 0 }) // Allowed

Gambar 4. Contoh ini menunjukkan error yang muncul akibat mencampur penyertaan dan pengecualian field dalam satu proyeksi, yang tidak diizinkan MongoDB, kecuali untuk `_id`.

Mengurutkan, Membatasi, dan Melewati Hasil

Saat bekerja dengan dataset besar, menampilkan hanya sebagian data kepada pengguna pada satu waktu adalah hal yang umum—teknik ini dikenal sebagai paginasi. Misalnya, aplikasi streaming mungkin menampilkan 10 film per halaman alih-alih memuat ribuan sekaligus. Ini tidak hanya meningkatkan performa tetapi juga memperbaiki pengalaman pengguna.

Di MongoDB, paginasi dicapai menggunakan kombinasi sort(), limit(), dan skip().

SQL vs. MongoDB: Perbandingan dasar

Jika Anda berasal dari latar belakang SQL, berikut cara perbandingan konsep paginasi umum:

Query dasar di SQL: 

SELECT * FROM movies WHERE year >= 2000

Hal yang sama dapat diekspresikan di MongoDB sebagai berikut:

db.movies.find({ year: { $gte: 2000 } })

Pemilihan field di SQL: 

SELECT title, year FROM movies

Pemilihan field di MongoDB: 

db.movies.find({}, { title: 1, year: 1, _id: 0 })

Sekarang, mari lihat beberapa contoh lagi operasi query umum:

Pengurutan:

• SQL: ORDER BY title ASC
• MongoDB: .sort({ title: 1 })

Pembatasan:

• SQL: LIMIT 10
• MongoDB: .limit(10)

Melewati:

• SQL: OFFSET 10
• MongoDB: .skip(10)

Memahami kesetaraan ini dapat membantu pengguna SQL bertransisi lebih mudah ke sistem query berbasis dokumen MongoDB.

Mengurutkan hasil

Pengurutan membantu Anda menata hasil berdasarkan field tertentu—misalnya, untuk mengurutkan film berdasarkan judul secara alfabetis:

db.movies.find().sort({ title: 1 }) // ascending (A–Z)

• 1 berarti urutan naik (A–Z, 0–9)
• -1 berarti urutan turun (Z–A, 9–0)

Membatasi hasil

Kembalikan hanya sejumlah hasil tertentu—misalnya, 10 pertama:

db.movies.find().limit(10)

Ini berguna saat membuat daftar “Top 10” atau tampilan awal.

Melewati hasil

Gunakan ini untuk melewati dokumen. Sering digunakan bersama limit() untuk paginasi:

db.movies.find().skip(10).limit(10)

Ini melewati 10 dokumen pertama dan mengembalikan 10 berikutnya, secara efektif menampilkan Halaman 2 ketika pageSize = 10.

Rumus paginasi:

skip = (pageNumber - 1) * pageSize

> Catatan: Menggunakan skip() untuk paginasi yang dalam (misalnya, skip(10000)) bisa tidak efisien, karena MongoDB tetap memindai dan membuang dokumen yang dilewati. Untuk performa lebih baik pada dataset besar, pertimbangkan paginasi berbasis rentang menggunakan field yang diindeks seperti _id.

Contoh gabungan: Halaman 3, 10 film per halaman, diurutkan berdasarkan judul

db.movies.find()
  .sort({ title: 1 })
  .skip(20)
  .limit(10)

Pola ini juga berguna untuk fitur seperti “muat lebih banyak” atau gulir tanpa batas.

Gambar 5. Query ini mengambil halaman ketiga dari hasil (10 film per halaman), diurutkan berdasarkan judul.

Bekerja Dengan Cursor

Metode find() mengembalikan sebuah cursor—penunjuk ke himpunan hasil. Anda dapat mengiterasinya:

const cursor = db.movies.find({ type: "movie" });
cursor.forEach(doc => print(doc.name));

Atau mengonversinya menjadi array:

const results = db.collection.find().toArray();

Gambar 6. Setelah memanggil `find()`, Anda menerima sebuah cursor. Anda dapat menggunakannya untuk mengiterasi dokumen atau mengonversi seluruh himpunan hasil menjadi sebuah array.

> Catatan: Objek cursor tersedia di mongosh atau kode melalui driver (misalnya, Node.js, Python). Alat GUI seperti MongoDB Compass menangani cursor secara internal. Anda tidak akan mengakses atau mengiterasinya secara langsung.

Opsi Lanjutan Cursor

Untuk menyetel query dengan lebih halus, Anda dapat menggunakan metode cursor tambahan:

db.users.find({ age: { $gte: 30 } })
  .sort({ name: 1 })
  .limit(10)
  .skip(5)
  .maxTimeMS(200)
  .hint({ age: 1 })

• maxTimeMS(ms): membatalkan query jika memakan waktu terlalu lama
• hint(): memaksa MongoDB menggunakan indeks tertentu
• batchSize(n): mengontrol jumlah dokumen per batch

Sedang mempersiapkan wawancara? Jelajahi Top 25 Pertanyaan dan Jawaban Wawancara MongoDB untuk menguji pemahaman Anda tentang konsep inti seperti find().

Indeks dan Optimasi Performa

Indeks ibarat contekan—membantu MongoDB mengambil dokumen lebih cepat.

Membuat indeks

db.movies.createIndex({ type: 1 })

Menggunakan .explain()

db.users.find({ type: "movie" }).explain()

Ini mengungkap apakah indeks digunakan dan seberapa efisien query Anda.

Tanpa indeks:

Gambar 7. Jalankan `explain()` pada query sebelum membuat indeks.

Membuat indeks: 

Gambar 8. Buat indeks sederhana pada field type.

Dengan indeks: 

Gambar 9. Jalankan query yang sama dengan `explain()`, kini menggunakan indeks.

Anda dapat melihat bahwa tahap yang sebelumnya CollScan (memindai koleksi) menjadi Fetch + IXSCAN, yang pada dasarnya menggunakan indeks + mencari data lain yang bukan bagian dari indeks (karena kita mengembalikan semuanya).

Menggunakan MongoDB Compass untuk Memvisualisasikan Query

Jika Anda lebih menyukai alat visual, MongoDB Compass adalah klien GUI resmi. Alat ini memungkinkan Anda untuk:

• Membangun query secara visual menggunakan filter.
• Pratinjau dokumen dan indeks.
• Mengoptimalkan dan memvalidasi performa query.

Anda bahkan dapat beralih ke "JSON view" untuk menyalin/menempelkan query ke dalam kode Anda.

Menggunakan Atlas + AI untuk Membuat Query

Jika Anda menggunakan MongoDB Atlas, Anda dapat memanfaatkan Atlas Search dengan pembuat query bertenaga AI.

Cukup ketik prompt bahasa alami seperti:

"Tampilkan semua pelanggan dari Brasil yang melakukan pesanan di atas $100 pada bulan lalu."

Atlas menyarankan query MongoDB yang sesuai menggunakan find() atau $search. Ini sangat membantu meningkatkan produktivitas, terutama saat Anda tidak yakin dengan sintaksnya.

Gambar 10. Gunakan Compass untuk membuat query dari bahasa alami.

Jebakan Umum dan Cara Menghindarinya

• Melakukan query pada field yang tidak diindeks → Menyebabkan performa lambat
• Himpunan hasil besar → Gunakan paginasi (limit + skip)
• Proyeksi yang tidak efisien → Selalu proyeksikan hanya field yang diperlukan
• Ketidakcocokan tipe → Pastikan tipe field cocok (misalnya, angka vs. string)
• Mencampur penyertaan dan pengecualian dalam proyeksi → Tidak diizinkan, kecuali untuk _id

Membandingkan MongoDB find() dengan SQL

Jika Anda berasal dari latar belakang SQL, memahami bagaimana find() di MongoDB dibandingkan dengan query SQL yang familier dapat mempermudah transisi. Berikut perbandingan umum operasi yang sering digunakan:

Seperti yang Anda lihat, sintaks MongoDB lebih menyerupai JavaScript dan ekspresif dalam format JSON, sementara SQL lebih deklaratif dan terstruktur. Mengetahui kesetaraan ini akan membantu Anda lebih cepat merasa familiar di MongoDB.

Ringkasan dan Praktik Terbaik

• Pikirkan find() sebagai filter data Anda—gabungkan kondisi untuk hasil yang presisi.
• Selalu proyeksikan hanya field yang diperlukan demi kejelasan dan performa.
• Gunakan indeks untuk menghindari pemindaian lambat.
• Gunakan Compass jika Anda menyukai umpan balik visual dan iterasi lebih cepat.
• Manfaatkan asisten AI di MongoDB Atlas untuk membuat query lebih cepat.
• Jelajahi opsi lanjutan cursor untuk kontrol hasil yang lebih detail.

Baik Anda membangun dasbor startup, alat analitik data, atau back end e-commerce, menguasai find() akan membuat pengalaman Anda dengan MongoDB lebih mulus, cepat, dan efektif.

Pantau terus untuk wawasan MongoDB lainnya di artikel mendatang!

Ingin memvalidasi keterampilan MongoDB Anda? Baca Panduan Lengkap Sertifikasi MongoDB untuk menjelajahi opsi Anda.