Memulai dengan Query API MongoDB

Sebagai basis data NoSQL yang populer, MongoDB menawarkan cara yang fleksibel dan skalabel untuk mengelola data Anda. Panduan ini adalah titik awal Anda untuk menguasai Query API yang intuitif, yang memungkinkan Anda berinteraksi dengan data menggunakan BSON (Binary JSON) yang dioptimalkan untuk efisiensi dan jenis data. 

Sepanjang artikel ini, kita akan membahas operasi dasar create, read, update, delete (CRUD), menyelami kueri presisi dengan filter dan proyeksi, mengeksplorasi kekuatan pipeline agregasi untuk transformasi data, serta membahas pengindeksan untuk meningkatkan kinerja. Pada akhirnya, Anda akan memiliki dasar yang kuat untuk mengambil dan memanipulasi data secara efisien di koleksi MongoDB Anda.

Konsep Dasar: Operasi CRUD

Tulang punggung interaksi basis data mana pun adalah CRUD: create, read, update, dan delete. Mari kita jelajahi cara melakukan masing-masing di MongoDB.

Membuat data (insert)

Untuk menambahkan dokumen baru ke koleksi, Anda menggunakan metode insert. Dokumen di MongoDB adalah objek mirip JSON.

insertOne()

Metode ini digunakan untuk menambahkan satu dokumen ke koleksi.

// A sample document to insert
const newProduct = {
  name: "Wireless Mouse",
  brand: "Logitech",
  price: 29.99,
  inStock: true
};

// Insert the new document into the 'products' collection
db.products.insertOne(newProduct);

insertMany()

Metode ini menambahkan beberapa dokumen sekaligus, yang jauh lebih efisien dibandingkan memasukkannya satu per satu.

// An array of documents to insert
const newProducts = [
  { name: "Mechanical Keyboard", brand: "Corsair", price: 129.99, inStock: false },
  { name: "Gaming Headset", brand: "Razer", price: 99.99, inStock: true },
  { name: "Webcam", brand: "LogiTech", price: 79.99, inStock: true }
];

// Insert the array of documents into the 'products' collection
db.products.insertMany(newProducts);

Membaca data (find)

Metode find() adalah alat utama Anda untuk mengambil dokumen dari suatu koleksi. Saat Anda memanggil find(), ini tidak langsung mengembalikan semua dokumen. Sebagai gantinya, ia mengembalikan sebuah cursor. Ini adalah cara efisien untuk menangani hasil yang berpotensi besar tanpa harus memuat semuanya ke memori sekaligus.

Panggilan find() yang paling sederhana tidak mengambil argumen dan akan mengembalikan cursor ke setiap dokumen dalam koleksi.

// Find and return a cursor to all documents in the 'products' collection
db.products.find();

Berikut contoh seperti apa objek cursor itu di mongosh (shell MongoDB) dan bagaimana Anda dapat berinteraksi dengannya:

// Find all products and assign the returned cursor to a variable
const productCursor = db.products.find();

// The variable 'productCursor' now holds the cursor object, not the documents themselves.
// To get the documents, you need to iterate over the cursor.

// You can convert the cursor to an array to see all the documents
const allProducts = productCursor.toArray();
console.log(allProducts);

// Or, you can manually iterate through the documents
while (productCursor.hasNext()) {
  const product = productCursor.next();
  console.log(product);
}

Cursor itu sendiri adalah objek dengan berbagai metode seperti toArray(), hasNext(), dan next() yang memungkinkan Anda mengambil dan bekerja dengan dokumen dalam himpunan hasil.

Memperbarui data (update)

Untuk memodifikasi dokumen yang sudah ada, Anda menggunakan metode update. Metode ini menerima dua argumen utama: sebuah filter untuk memilih dokumen yang akan diperbarui dan sebuah operator pembaruan untuk menentukan perubahannya. Operator umum adalah $set, yang menetapkan nilai suatu field.

updateOne()

Metode ini memperbarui dokumen pertama yang cocok dengan filter.

// Update the 'Wireless Mouse' document to set its price to 39.99
db.products.updateOne(
  { name: "Wireless Mouse" }, // Filter to find the document
  { $set: { price: 39.99 } } // Update operator
);

updateMany()

Metode ini memperbarui semua dokumen yang cocok dengan filter yang ditentukan.

// Update all 'LogiTech' brand products to be in stock
db.products.updateMany(
  { brand: "LogiTech" }, // Filter to find the documents
  { $set: { inStock: true } } // Update operator
);

Menghapus data (delete)

Untuk menghapus dokumen, Anda menggunakan metode delete. Ini juga menerima filter untuk menentukan dokumen mana yang akan dihapus.

deleteOne()

Metode ini menghapus dokumen pertama yang cocok dengan filter.

// Delete the 'Webcam' document
db.products.deleteOne({ name: "Webcam" });

deleteMany()

Metode ini menghapus semua dokumen yang cocok dengan filter. Untuk menghapus semua dokumen dalam sebuah koleksi, Anda dapat meneruskan filter kosong {}.

// Delete all documents that are not in stock
db.products.deleteMany({ inStock: false });

Pengambilan Presisi: Query Filter

Query filter adalah inti dari kekuatan MongoDB. Filter adalah argumen pertama dalam metode find() dan update dan memungkinkan Anda memilih dengan tepat dokumen mana yang ingin Anda kerjakan.

Operator perbandingan

Operator ini memungkinkan Anda membandingkan nilai suatu field dengan nilai tertentu.

$eq (sama dengan)

Ini menemukan dokumen di mana suatu field sama dengan sebuah nilai.

// Find all products that are made by 'Razer'
db.products.find({ brand: { $eq: "Razer" } });
// This can be simplified to:
// db.products.find({ brand: "Razer" });

$gt dan $gte (lebih besar dari, lebih besar dari atau sama dengan)

Ini menemukan dokumen di mana nilai field lebih besar dari ($gt) atau lebih besar dari atau sama dengan ($gte) nilai tertentu.

// Find all products with a price greater than 100
db.products.find({ price: { $gt: 100 } });

$lt dan $lte (kurang dari, kurang dari atau sama dengan)

Ini menemukan dokumen di mana nilai field kurang dari ($lt) atau kurang dari atau sama dengan ($lte) nilai tertentu.

// Find all products with a price less than or equal to 50
db.products.find({ price: { $lte: 50 } });

$ne (tidak sama dengan)

$ne menemukan dokumen di mana suatu field tidak sama dengan nilai tertentu.

// Find all products that are NOT made by 'LogiTech'
db.products.find({ brand: { $ne: "LogiTech" } });

$in dan $nin (ada dalam array, tidak ada dalam array)

Ini menemukan dokumen di mana nilai field ada dalam ($in) atau tidak ada dalam ($nin) array nilai yang ditentukan.

// Find all products from 'Razer' or 'Corsair'
db.products.find({ brand: { $in: ["Razer", "Corsair"] } });

Operator logika

Operator logika menggabungkan beberapa kondisi untuk membuat kueri kompleks.

$and

$and menggabungkan kondisi kueri dengan logika AND. Semua kondisi harus benar.

// Find all products with a price greater than 50 AND are in stock
db.products.find({ $and: [{ price: { $gt: 50 } }, { inStock: true }] });
// This can be simplified by just listing the conditions:
// db.products.find({ price: { $gt: 50 }, inStock: true });

$or

Ini menggabungkan kondisi kueri dengan logika OR. Setidaknya satu kondisi harus benar.

// Find all products with a brand of 'Corsair' OR a price less than 40
db.products.find({ $or: [{ brand: "Corsair" }, { price: { $lt: 40 } }] });

Operator elemen dan evaluasi 

Operator ini memberikan fleksibilitas lebih untuk pemfilteran.

$exists

$exists mencocokkan dokumen yang memiliki field tertentu.

// Find all documents that have an 'inStock' field
db.products.find({ inStock: { $exists: true } });

$regex

Ini memungkinkan Anda menggunakan regular expression untuk pencocokan pola pada field string.

// Find all product names that start with 'Wireless'
db.products.find({ name: { $regex: /^Wireless/ } });

Membentuk Hasil: Proyeksi

Saat Anda melakukan operasi find(), Anda dapat memilih untuk menerima hanya sebagian field pada setiap dokumen. Ini disebut projection dan ini adalah argumen kedua yang Anda berikan ke find(). Ini membantu mengurangi jumlah data yang ditransfer dan diproses.

Menyertakan field

Anda dapat menentukan field mana yang dikembalikan dengan menyetel nilainya ke 1.

// Find all products and return only the 'name' and 'price' fields
db.products.find({}, { name: 1, price: 1 });

Mengecualikan field

Sebaliknya, Anda dapat menentukan field mana yang disembunyikan dengan menyetel nilainya ke 0.

// Find all products and hide the 'inStock' field
db.products.find({}, { inStock: 0 });

Field _id selalu dikembalikan secara default kecuali Anda secara eksplisit mengecualikannya.

Field _id

Untuk menyembunyikan field _id, Anda harus secara eksplisit menyetelnya ke 0.

// Find all products, returning only 'name' and 'price', and hiding '_id'
db.products.find({}, { _id: 0, name: 1, price: 1 });

Transformasi Data Lanjutan: Aggregation Pipeline

Agregasi adalah kerangka kerja yang kuat untuk pemrosesan data di MongoDB. Aggregation pipeline terdiri dari serangkaian tahap yang memproses dokumen dan meneruskan hasil dari satu tahap ke tahap berikutnya.

$match

Tahap $match memfilter dokumen berdasarkan query filter, mirip seperti pada find(). Ini sering menjadi tahap pertama untuk mengurangi jumlah dokumen yang akan diproses.

// Find all products with a brand of 'LogiTech'
db.products.aggregate([
  { $match: { brand: "LogiTech" } }
]);

$group

Tahap $group mengelompokkan dokumen berdasarkan ekspresi _id yang ditentukan dan dapat melakukan berbagai operasi akumulator, seperti menghitung jumlah atau rata-rata suatu field.

// Group products by brand and calculate the total number of products for each brand
db.products.aggregate([
  { $group: { _id: "$brand", totalProducts: { $sum: 1 } } }
]);

$project

Tahap $project membentuk ulang setiap dokumen dalam aliran, mirip dengan proyeksi pada find(). Anda dapat menambahkan field baru, menghapus yang ada, dan memanipulasi data.

// Project a new field 'nameAndPrice' for each document
db.products.aggregate([
  { $project: { name: 1, price: 1, nameAndPrice: { $concat: ["$name", " (", "$price", ")"] } } }
]);

$sort

Tahap $sort menyusun ulang dokumen berdasarkan field yang ditentukan. Nilai 1 untuk urutan menaik, dan -1 untuk menurun.

// Sort all products by price in descending order
db.products.aggregate([
  { $sort: { price: -1 } }
]);

$limit dan $skip

Tahap ini digunakan untuk paginasi. $skip membuang sejumlah dokumen dari awal pipeline, dan $limit membatasi jumlah dokumen yang diteruskan ke tahap berikutnya.

// Skip the first 10 products and then return the next 5
db.products.aggregate([
  { $skip: 10 },
  { $limit: 5 }
]);

Contoh pipeline sederhana

Berikut contoh lengkap yang menunjukkan bagaimana tahap-tahap ini bekerja bersama.

// Find the average price of all products that are currently in stock,
// grouped by brand.
db.products.aggregate([
  { $match: { inStock: true } }, // Filter for products in stock
  { $group: { _id: "$brand", averagePrice: { $avg: "$price" } } } // Group and calculate average price
]);

Meningkatkan Kinerja: Pengindeksan

Indeks adalah struktur data khusus yang menyimpan porsi kecil dan mudah ditelusuri dari data koleksi. Indeks secara signifikan meningkatkan kinerja kueri dengan memungkinkan MongoDB dengan cepat menemukan dan mengambil dokumen tanpa memindai seluruh koleksi.

createIndex()

Anda membuat indeks pada field yang sering Anda kueri atau urutkan.

// Create a single-field index on the 'brand' field
db.products.createIndex({ brand: 1 });

Angka 1 menunjukkan urutan menaik untuk indeks. Anda dapat menggunakan -1 untuk urutan menurun, yang bisa bermanfaat untuk kueri yang mengurutkan ke arah tersebut.

Membuat indeks pada field seperti brand akan membuat kueri yang memfilter berdasarkan brand (mis., db.products.find({ brand: "Razer" })) berjalan jauh lebih cepat, terutama saat koleksi Anda berkembang.

Pertimbangan saat memilih field untuk diindeks

Biasanya Anda harus membuat indeks pada field yang sering digunakan dalam kueri, seperti yang ada di filter find() atau tahap $match pada agregasi.

• Kardinalitas: Field dengan banyak nilai unik (kardinalitas tinggi), seperti alamat email pengguna, adalah kandidat yang sangat baik untuk indeks.
• Selektivitas kueri: Field yang mengembalikan subset dokumen yang kecil untuk kueri tertentu juga merupakan kandidat yang bagus.
• Pengurutan: Jika Anda sering mengurutkan hasil kueri berdasarkan field tertentu, membuat indeks pada field tersebut akan membuat operasi pengurutan jauh lebih cepat.

Dampak pada kueri

Indeks memiliki dampak besar pada kinerja. Kueri dengan indeks sering kali jauh lebih cepat dibandingkan kueri yang sama tanpa indeks.

// Conceptual illustration of performance difference

// Without an index on 'brand':
// MongoDB performs a full collection scan, checking every document.
// This is slow, especially with millions of documents.
db.products.find({ brand: "Razer" });

// With an index on 'brand':
// MongoDB uses the index to quickly locate and return only the matching documents.
// This is very fast.
db.products.find({ brand: "Razer" });

Untuk mengoptimalkan kueri lebih lanjut, Anda dapat menggunakan metode db.collection.explain() untuk menganalisis kinerja kueri dan melihat bagaimana indeks digunakan.

Kesimpulan: Perjalanan Anda Menuju Kemahiran MongoDB

Anda baru saja menyelesaikan kursus kilat tentang Query API MongoDB! Sekarang Anda tahu cara melakukan operasi CRUD inti, menggunakan filter yang kuat untuk mengambil data spesifik, membentuk keluaran dengan proyeksi, dan mentransformasi data dengan pipeline agregasi. Anda juga memiliki pemahaman dasar tentang pengindeksan untuk meningkatkan kinerja.

Panduan ini memberikan landasan yang solid, dan cara terbaik untuk menguasai konsep ini adalah dengan mempraktikkannya. Saya mendorong Anda untuk bereksperimen dengan berbagai kueri dan menjelajahi dokumentasi lengkap untuk menemukan operator dan fitur lanjutan lainnya. Selamat ngoding!