Front-End & Back-End Development 5

2.6 MongoDB Query Operations

Setelah memahami bagaimana data tersimpan dalam bentuk database, collection, dan document, langkah berikutnya adalah belajar berinteraksi langsung dengan data tersebut melalui query operations.

Di tahap ini, Anda akan mempelajari bagaimana cara mengambil, memfilter, memperbarui, dan menghapus data sesuai kebutuhan aplikasi.

Bayangkan Anda sedang membangun aplikasi e-commerce: pengguna mencari produk, memperbarui stok, atau menghapus pesanan lama. Semua itu dilakukan melalui query. Karena itu, memahami cara kerja query operations bukan hanya soal menulis perintah, tetapi juga soal memahami bagaimana MongoDB menelusuri dan memproses data di balik layar. Dengan menguasainya, Anda akan mampu membuat aplikasi yang lebih efisien, responsif, dan cerdas dalam mengelola data.

2.6.1 Basic Queries di MongoDB Shell

Sebelum kita menulis query yang lebih kompleks, mari kita mulai dengan dasar terlebih dahulu menggunakan MongoDB Shell (mongosh).

MongoDB Shell adalah antarmuka berbasis teks yang memungkinkan Anda berinteraksi langsung dengan database — mirip seperti terminal untuk menjalankan perintah di sistem operasi. Melalui mongosh, Anda bisa membuat database, menambah data, hingga melakukan pencarian dan pembaruan secara langsung.

Langkah-langkah berikut akan membantu Anda memahami bagaimana struktur dan sintaks dasar MongoDB bekerja:

Langkah 1 – Masuk ke Mongo Shell

1. Buka terminal Anda, lalu ketik perintah berikut untuk masuk ke MongoDB Shell.

mongosh

Perintah ini membuka antarmuka tempat Anda bisa mulai menulis perintah MongoDB.

Option b) Masuk DB Compass, lalu pilih database yang diinginkan. Pada langkah terakhir akan ada gambar bagaimana menggunakan query nya di mongodb Compass.

Langkah 2 – Pilih Database

1. Gunakan perintah use untuk berpindah ke database yang ingin Anda kelola. Jika database belum ada, MongoDB akan otomatis membuatnya saat Anda menyimpan data ke dalamnya.

use health-ecommerce

Di contoh ini, kita akan menggunakan database bernama health-ecommerce, yang akan menyimpan data terkait produk kesehatan.

Langkah 3 – Menambahkan Data Sampel

1. Sekarang mari kita tambahkan beberapa data awal ke dalam collection bernama products. Data ini akan menjadi bahan latihan untuk melakukan berbagai jenis query.

db.products.insertMany([

{

category: "Vitamin",

price: 85000,

stock: 50

{

category: "Vitamin",

price: 120000,

stock: 30

{

category: "Supplement",

price: 200000,

stock: 25

{

category: "Medical Equipment",

price: 75000,

stock: 60

}

]);

Perintah insertMany() digunakan untuk menambahkan beberapa dokumen sekaligus ke dalam collection. Setiap dokumen berisi informasi lengkap tentang satu produk, seperti nama, kategori, harga, dan stok.

Setelah langkah ini, Anda memiliki empat produk yang siap digunakan untuk latihan berbagai query operation seperti mencari, memfilter, mengurutkan, memperbarui, dan menghapus data.

2.6.2 Find - Mengambil Data

Setelah kita memiliki data di dalam koleksi, langkah berikutnya adalah mengambil data tersebut menggunakan perintah find().

Perintah ini adalah salah satu yang paling sering digunakan dalam MongoDB karena berfungsi untuk membaca dan menampilkan dokumen yang tersimpan di dalam collection.

Konsep dasarnya sederhana: Anda memberi tahu MongoDB apa yang ingin dicari, dan MongoDB akan menampilkan dokumen yang sesuai dengan kriteria tersebut.

1. Ambil Semua Data

Jika Anda ingin melihat seluruh isi collection tanpa filter apa pun, gunakan:

db.products.find();

Perintah ini menampilkan semua dokumen yang tersimpan di products.

Biasanya, langkah ini dilakukan untuk memastikan data sudah masuk dengan benar atau untuk eksplorasi awal isi database.

2. Find Data dengan Filter

MongoDB memungkinkan Anda melakukan pencarian lebih spesifik menggunakan filter.

Filter ditulis dalam format objek { field: value }, mirip seperti JSON.

Contoh: ambil semua produk dengan kategori “Vitamin”.

db.products.find({ category: "Vitamin" });

Perintah di atas akan menampilkan semua dokumen yang memiliki field category bernilai "Vitamin".

3. Filter Berdasarkan Kondisi Angka

Anda bisa menambahkan operator untuk membuat pencarian lebih fleksibel, misalnya mencari harga di bawah 100.000:

// Products dengan harga < 100000

db.products.find({ price: { $lt: 100000 } });

$lt berarti less than (lebih kecil dari).

Begitu juga sebaliknya, Anda bisa mencari stok lebih besar dari 40:

// Products dengan stock > 40

db.products.find({ stock: { $gt: 40 } });

$gt berarti greater than (lebih besar dari).

Operator Perbandingan Lainnya:

MongoDB menyediakan banyak operator pembanding untuk berbagai kebutuhan:

4. Menggabungkan Kondisi dengan Operator Logika

Dalam kasus nyata, sering kali Anda perlu menggabungkan beberapa kondisi sekaligus. Misalnya, Anda ingin mencari produk berkategori Vitamin dan berharga di bawah 100.000:

// AND - Products category Vitamin DAN price < 100000

db.products.find({

category: "Vitamin",

price: { $lt: 100000 },

});

Jika Anda ingin mencari produk yang berkategori Vitamin atau berharga di bawah 80.000, gunakan operator $or:

// OR - Products category Vitamin ATAU price < 80000

db.products.find({

$or: [{ category: "Vitamin" }, { price: { $lt: 80000 } }],

});

Dan untuk kondisi yang lebih kompleks, misalnya:

Produk kategori Vitamin dengan harga < 100.000, atau

Produk dengan stok lebih dari 50,

Anda bisa menulis:

// Complex - (Vitamin DAN price < 100k) ATAU (Stock > 50)

db.products.find({

$or: [

{ category: "Vitamin", price: { $lt: 100000 } },

{ stock: { $gt: 50 } },

});

intinya:

Perintah find() adalah jantung dari pencarian data di MongoDB. Dengan memahami berbagai operator seperti $lt, $gt, $or, dan $in, Anda dapat menyusun query yang efisien dan fleksibel sesuai kebutuhan sistem atau analisis data Anda.

2.6.3 Projection - Menampilkan Field Tertentu

Dalam banyak kasus, Anda tidak selalu memerlukan seluruh data dari setiap dokumen. Misalnya, ketika menampilkan daftar produk di halaman depan toko online, Anda mungkin hanya butuh nama produk dan harga, bukan semua informasi seperti stok, kategori, atau tanggal pembuatan. Di sinilah fitur projection di MongoDB sangat membantu. Projection digunakan untuk mengatur field mana saja yang ingin ditampilkan dalam hasil query.

Caranya sederhana: tambahkan objek kedua di dalam perintah find(), berisi nama-nama field yang ingin ditampilkan dengan nilai 1 (true) untuk menampilkan, atau 0 (false) untuk menyembunyikan.

Contoh Menampilkan Field Tertentu

Misalnya, Anda hanya ingin menampilkan name dan price dari semua produk:

// Hanya tampilkan name dan price

db.products.find({}, { name: 1, price: 1 })

Artinya:

{} → tidak ada filter (ambil semua dokumen)

{ name: 1, price: 1 } → hanya tampilkan field name dan price

Hasilnya akan tampak seperti ini:

// Output:

[

{ _id: ..., name: "Vitamin C", price: 85000 },

{ _id: ..., name: "Vitamin D", price: 120000 }

]

Secara default, MongoDB tetap menampilkan field _id karena merupakan identifier unik untuk setiap dokumen.

Menyembunyikan Field _id

Jika Anda tidak ingin menampilkan _id, cukup tambahkan _id: 0 dalam projection:

// Sembunyikan _id

db.products.find({}, { name: 1, price: 1, _id: 0 })

hasilnya :

// Output (tanpa _id):

[

{ name: "Vitamin C", price: 85000 },

{ name: "Vitamin D", price: 120000 }

]

Dengan menyembunyikan _id, tampilan data menjadi lebih bersih dan fokus pada informasi yang dibutuhkan saja.

Kapan Projection Digunakan?

Projection sangat berguna dalam berbagai situasi, seperti:

Menampilkan ringkasan data di antarmuka pengguna (misal: hanya nama dan harga produk)
Menghemat bandwidth dan memori, karena hanya data relevan yang diambil dari server
Melindungi informasi sensitif, dengan tidak menampilkan field seperti email, password, atau token

Jadi, bisa disimpulkan bahwa projection membantu Anda mengontrol output data dengan menampilkan hanya informasi penting yang dibutuhkan. Dengan cara ini, aplikasi menjadi lebih efisien, cepat, dan aman.

2.6.4 Sort - Mengurutkan Data

Dalam praktik pengambilan data, sering kali Anda tidak hanya ingin menampilkan hasil pencarian, tetapi juga mengurutkannya dengan cara tertentu, misalnya dari harga termurah ke termahal, atau berdasarkan abjad nama produk.

MongoDB menyediakan fitur sort() untuk membantu Anda mengatur urutan hasil query agar lebih terstruktur dan mudah dibaca. Fungsi sort() bekerja dengan sangat sederhana: Anda menentukan field yang ingin diurutkan, lalu berikan nilai:

1 → Ascending urutan naik, misalnya dari kecil ke besar atau A–Z)
-1 → Descending (urutan turun, misalnya dari besar ke kecil atau Z–A)

Contoh 1: Urutkan Berdasarkan Harga

Menampilkan semua produk dari harga termurah ke termahal:

// Sort by price ascending (murah ke mahal)

db.products.find().sort({ price: 1 });

Keterangan:

price → field yang digunakan untuk mengurutkan
1 → artinya ascending (harga kecil ke besar)

Hasilnya akan menampilkan daftar produk dalam urutan harga paling murah hingga paling mahal.

Contoh 2: Urutkan Berdasarkan Harga dari Mahal ke Murah

// Sort by price descending (mahal ke murah)

db.products.find().sort({ price: -1 });

Keterangan:

-1 → descending (harga besar ke kecil)
Cocok digunakan saat Anda ingin menampilkan produk premium terlebih dahulu

Contoh 3: Urutkan Berdasarkan Beberapa Field

Anda juga dapat mengurutkan berdasarkan lebih dari satu field.

Misalnya, urutkan produk berdasarkan kategori secara alfabetis, lalu urutkan berdasarkan harga dalam setiap kategori:

// Sort by category (A-Z), then price (murah ke mahal)

db.products.find().sort({ category: 1, price: 1 });

```

Artinya :

MongoDB akan mengelompokkan produk berdasarkan category (A–Z)
Di dalam setiap kategori, produk akan diurutkan berdasarkan price (murah ke mahal)

Tips Praktis:

Gunakan sort untuk meningkatkan pengalaman pengguna (misalnya menampilkan produk terlaris atau termurah lebih dulu).
Sort dapat digabung dengan filter (find) dan pagination (limit & skip) agar hasil lebih relevan dan efisien.
Untuk dataset besar, pastikan field yang diurutkan memiliki index agar proses sorting lebih cepat.

Jadi, dapat disimpulkan bahwa sort() adalah fitur sederhana namun sangat penting dalam MongoDB. Dengan menggunakannya secara tepat, Anda dapat menampilkan data dengan urutan logis, membantu pengguna memahami informasi dengan lebih cepat, dan menjaga performa aplikasi tetap efisien.

2.6.5 Limit & Skip - Pagination

Dalam praktik pengambilan data di database, sering kali kita tidak ingin menampilkan seluruh hasil pencarian sekaligus. Misalnya, sebuah toko online memiliki ribuan produk — tentu tidak efisien jika semua produk ditampilkan dalam satu halaman.

Di sinilah konsep pagination (penyajian data per halaman) digunakan agar data lebih mudah dibaca, tampilan tetap ringan, dan pengguna bisa menjelajah hasil secara bertahap. MongoDB menyediakan dua metode utama untuk mendukung pagination, yaitu limit() dan skip().

1. limit() — Membatasi Jumlah Data yang Ditampilkan

Metode limit() digunakan untuk mengambil sejumlah data tertentu saja dari hasil pencarian. Contoh:

// Ambil 2 produk pertama

db.products.find().limit(2);

Penjelasan:

Perintah di atas menampilkan 2 produk pertama dari hasil query.
Cocok digunakan ketika Anda ingin membatasi jumlah data yang ditampilkan di satu halaman, misalnya 10 item per halaman.

2. skip() — Melewati Beberapa Data Awal

Sementara itu, skip() berfungsi untuk melewati sejumlah data pertama sebelum mulai menampilkan hasil berikutnya.

// Skip 2 produk pertama, ambil sisanya

db.products.find().skip(2);

Penjelasan:

Artinya, MongoDB akan melewati 2 data pertama dan menampilkan sisanya.
Biasanya digunakan bersama limit() untuk menentukan posisi data yang ingin ditampilkan di halaman tertentu.

3. Kombinasi limit() dan skip() — Membangun Pagination

Pagination biasanya diimplementasikan dengan menggabungkan kedua metode ini. Contohnya, jika Anda ingin menampilkan data per halaman dengan jumlah item tertentu:

// Pagination: Page 2, 2 items per page

const page = 2;

const itemsPerPage = 2;

db.products

.find()

.skip((page - 1) * itemsPerPage)

.limit(itemsPerPage);

Penjelasan langkah demi langkah:

page = nomor halaman yang ingin ditampilkan.
Misalnya page = 2 berarti Anda ingin menampilkan halaman kedua.
itemsPerPage = jumlah data per halaman, misalnya 2 produk per halaman.
Rumus (page - 1) * itemsPerPage menentukan berapa data yang dilewati sebelum menampilkan data berikutnya.

Jadi pada contoh di atas:

(2 - 1) * 2 = 2 → MongoDB melewati 2 produk pertama
Lalu menampilkan 2 produk berikutnya (produk ke-3 dan ke-4)

Tips Praktis:

Gunakan pagination untuk efisiensi tampilan dan performa.
Tanpa limit, query besar bisa membebani sistem dan memperlambat loading.
Tambahkan sort() sebelum pagination, agar urutan data tetap konsisten antar halaman.
Gunakan index pada field yang sering difilter atau diurutkan untuk mempercepat query.

Digunakan untuk membatasi jumlah data (Limit) dan melewati sejumlah data (Skip), biasanya untuk fitur halaman (pagination).

2.6.6 Update - Mengubah Data

Setelah Anda bisa menambahkan dan menampilkan data, langkah berikutnya adalah mengubah data yang sudah ada. Di dunia nyata, kebutuhan untuk memperbarui data sering terjadi. Misalnya:

Harga produk berubah,
Stok barang bertambah atau berkurang,
Informasi kategori atau tag produk diperbarui.

MongoDB menyediakan dua metode utama untuk melakukan perubahan ini:

updateOne() dan updateMany().

1. updateOne() — Mengubah Satu Data

Gunakan metode ini jika Anda hanya ingin memperbarui satu dokumen tertentu. Contoh:

db.products.updateOne(

{ name: "Vitamin C 1000mg" }, // Filter

{ $set: { price: 95000 } } // Update

);

Penjelasan:

Bagian pertama { name: "Vitamin C 1000mg" } adalah kriteria pencarian, MongoDB akan mencari produk dengan nama tersebut.
Bagian kedua { $set: { price: 95000 } } berisi perintah pembaruan, yaitu mengganti nilai field price menjadi 95000.
$set adalah operator update yang paling umum digunakan untuk menetapkan nilai baru pada field tertentu.

Jadi, kalau sebelumnya harga produk “Vitamin C 1000mg” Rp85.000, setelah dijalankan, nilainya otomatis diperbarui menjadi Rp95.000.

2. updateMany() — Mengubah Banyak Data Sekaligus

Jika Anda ingin memperbarui lebih dari satu dokumen dengan kriteria yang sama, gunakan updateMany(). Contoh:

db.products.updateMany(

{ category: "Vitamin" },

{ $set: { inStock: true } }

);

Penjelasan:

MongoDB akan mencari semua produk dengan kategori Vitamin,
Lalu memperbarui field inStock menjadi true untuk semuanya.
Cocok digunakan saat Anda perlu memperbarui status, kategori, atau field serupa pada banyak data sekaligus.

3. Operator Update Lain yang Sering Digunakan

Selain $set, MongoDB menyediakan berbagai update operator untuk memperbarui data secara dinamis, tanpa perlu menulis ulang seluruh dokumen.

Insight:

Menggunakan update operator jauh lebih efisien dibanding menghapus dan menambahkan ulang data. Dengan cara ini, Anda menjaga konsistensi data dan menghemat resource database.

2.6.7 Delete - Menghapus Data

Sekarang, bagaimana kalau data tersebut sudah tidak relevan dan ingin dihapus? MongoDB menyediakan dua perintah:

deleteOne() → untuk menghapus satu dokumen,
deleteMany() → untuk menghapus beberapa dokumen sekaligus.

1. Menghapus Satu Data

// Delete ONE document

db.products.deleteOne({ name: "Vitamin C 1000mg" });

MongoDB akan mencari satu produk dengan nama tersebut dan menghapusnya.

Jika ada lebih dari satu dokumen yang cocok, hanya satu yang dihapus.

2. Menghapus Banyak Data

// Delete MANY documents

db.products.deleteMany({ category: "Vitamin" });

Semua produk dengan kategori “Vitamin” akan dihapus dari koleksi.

3. Menghapus Semua Data (Gunakan dengan Hati-hati!)

// Delete ALL documents (hati-hati!)

db.products.deleteMany({});

Perintah ini akan menghapus seluruh dokumen di koleksi products.

Biasanya hanya digunakan untuk kebutuhan testing atau reset database — jangan dilakukan di production!

Tips Aman:

Selalu lakukan pengecekan (find()) sebelum menjalankan deleteMany().
Gunakan filter yang spesifik agar tidak menghapus data penting secara tidak sengaja.
Backup data sebelum menjalankan operasi delete besar.

2.6.8 MongoDB Query Practice

Bagian ini bertujuan melatih keterampilan Anda dalam menjalankan query dasar hingga lanjutan di MongoDB menggunakan Mongo Shell (mongosh). Melalui latihan ini, Anda akan memahami cara melakukan operasi seperti insert, find, update, dan delete secara langsung di database. Tujuan akhirnya adalah memastikan Anda terbiasa berinteraksi dengan data secara praktis, cepat, dan terstruktur sebelum menerapkannya dalam kode program.

Pengantar praktik ini dirancang untuk memberi Anda pengalaman langsung dalam memanipulasi data di MongoDB. Anda akan mulai dengan menjalankan perintah dasar melalui mongosh, sehingga dapat memahami bagaimana struktur data bekerja dan bagaimana setiap perintah memengaruhi isi collection. Setelah menguasai dasar tersebut, Anda akan melanjutkan ke query yang lebih kompleks, seperti penggunaan filter ganda, penyortiran, dan pembatasan hasil. Alur ini membantu Anda memahami fondasi penggunaan MongoDB sebelum mengimplementasikannya dalam aplikasi backend.

Langkah-langkah Praktik :

Langkah 1 – Practice langsung di Mongo Shell (mongosh):

Buka mongosh, lalu praktikkan query dasar berikut untuk membuat dan memodifikasi data:

use health-ecommerce

// Insert

db.products.insertOne({

category: "Supplement",

price: 75000,

stock: 40

})

// Find

db.products.find({ category: "Supplement" })

// Update

db.products.updateOne(

{ name: "Zinc Supplement 50mg" },

{ $set: { price: 80000 } }

)

// Delete

db.products.deleteOne({ name: "Zinc Supplement 50mg" })

Latihan ini membantu Anda memahami sintaks dasar MongoDB dan bagaimana setiap operasi memanipulasi data secara langsung.

Langkah 2 – Coba Query Lanjutan:

Setelah memahami dasar, lanjutkan dengan query yang lebih kompleks untuk penyaringan dan penyortiran data:

// Find products: category Vitamin AND price < 100000

db.products.find({

category: "Vitamin",

price: { $lt: 100000 },

});

// Sort by price descending, limit 3

db.products.find().sort({ price: -1 }).limit(3);

Langkah ini membantu Anda mengenali pola pencarian data dengan filter ganda, sorting, dan pembatasan hasil.

Tips:

Latihan di mongosh terlebih dahulu
Gunakan mongosh untuk mencoba berbagai perintah dan memahami struktur data secara langsung tanpa harus membuat skrip program.
Gunakan MongoDB Compass untuk visualisasi data
Compass membantu Anda melihat isi collection serta memeriksa hasil query melalui tampilan grafis yang intuitif.
Biasakan membaca pesan error dengan cermat
Pesan error biasanya memberikan petunjuk penting, seperti field yang salah, tipe data tidak sesuai, atau kendala koneksi database.

2.7 MongoDB Query vs Mongoose ODM

Dalam pengembangan aplikasi menggunakan MongoDB, ada dua cara utama untuk berinteraksi dengan database: query native MongoDB dan menggunakan Mongoose ODM (Object Data Modeling). Keduanya memiliki fungsi yang sama, yaitu mengelola data di MongoDB. Namun berbeda dari sisi cara kerja, kemudahan, dan fitur tambahan seperti validasi serta struktur data.

2.7.1 Apa Itu ODM?

Sebelum masuk ke perbandingan, mari pahami dulu apa itu ODM. ODM (Object Data Modeling) adalah library yang membantu pengembang bekerja dengan MongoDB secara lebih mudah, terstruktur, dan aman. Dengan ODM, data dari database dapat dimodelkan ke dalam bentuk objek JavaScript sehingga lebih terorganisir dan memiliki validasi otomatis.

Mari kita analogikan seperti berikut ini:

MongoDB Native = seperti mengemudi mobil manual → kontrol penuh, tapi butuh lebih banyak usaha.
Mongoose ODM = seperti mengemudi mobil matic → lebih mudah, ada fitur bantuan, dan aman dari kesalahan dasar.

Secara singkat bisa kita simpulkan bahwa mongoose adalah ODM paling populer untuk Node.js yang digunakan secara luas dalam berbagai proyek production.

2.7.2 Perbandingan – Native vs ODM

Setelah memahami konsep dasar ODM, sekarang mari kita lihat perbandingan konkret antara MongoDB Native Query dan Mongoose ODM. Kita akan menggunakan contoh kasus sederhana: menyimpan, mencari, dan memperbarui data produk dalam database “health-ecommerce”. Melalui contoh-contoh ini, Anda akan melihat bagaimana kedua pendekatan tersebut bekerja, serta apa kelebihan dan kekurangannya.

Contoh 1: Insert Data

Tujuan: Memahami perbedaan cara memasukkan data (insert) antara MongoDB Native dan Mongoose.

Skenarionya, kita ingin menambahkan produk baru bernama “Vitamin C 1000mg” ke koleksi products.

A. MongoDB Native Query:

Pendekatan ini berinteraksi langsung dengan database tanpa lapisan tambahan. Tidak ada validasi otomatis, sehingga data apa pun bisa dimasukkan.

const { MongoClient } = require("mongodb");

const client = new MongoClient("mongodb://localhost:27017");

async function insertProduct() {

await client.connect();

const db = client.db("health-ecommerce");

const products = db.collection("products");

const result = await products.insertOne({

category: "Vitamin",

price: 85000,

stock: 50,

});

console.log("Inserted ID:", result.insertedId);

await client.close();

}

B. Mongoose ODM:

Di sisi lain, Mongoose menggunakan schema untuk memastikan struktur dan tipe data konsisten. Ini membuat data lebih terjamin validasinya.

const mongoose = require("mongoose");

// Define Schema dulu

const productSchema = new mongoose.Schema({

category: { type: String, required: true },

price: { type: Number, required: true, min: 0 },

stock: { type: Number, default: 0 },

});

const Product = mongoose.model("Product", productSchema);

async function insertProduct() {

await mongoose.connect("mongodb://localhost:27017/health-ecommerce");

const product = await Product.create({

category: "Vitamin",

price: 85000,

stock: 50,

});

console.log("Created:", product);

}

Perbedaan utama:

Native: Langsung memasukkan data tanpa validasi.
Mongoose: Menggunakan schema dengan validasi otomatis (contoh: harga tidak boleh negatif).

Contoh 2: Find Data

Tujuan: Melihat perbedaan cara mencari data menggunakan filter (query).

Skenarionya, kita ingin menampilkan semua produk dengan kategori “Vitamin” dan harga di bawah Rp100.000.

A. MongoDB Native:

const products = await db

.collection("products")

.find({

category: "Vitamin",

price: { $lt: 100000 },

})

.toArray();

B. Mongoose ODM:

const products = await Product.find({

category: "Vitamin",

price: { $lt: 100000 },

});

Perbedaan utama:

Native mengembalikan plain object (data mentah),
Mongoose mengembalikan instance dari model yang kaya fitur (seperti .save(), .populate() atau .validate()).

Bisa dibilang, Mongoose lebih cocok untuk data yang perlu diolah lebih lanjut dalam aplikasi karena objeknya kaya fitur.

Contoh 3: Update dengan Validasi

Tujuan: Menunjukkan perbedaan perilaku saat memperbarui data yang tidak valid (misalnya harga negatif).

Skenarionya, kita ingin memperbarui harga produk “Vitamin C” menjadi nilai negatif (yang seharusnya tidak valid).

A. MongoDB Native:

// Bisa update dengan data invalid!

await products.updateOne(

{ name: "Vitamin C" },

{ $set: { price: -50000 } } // ❌ Price negatif!

);

// Berhasil! Nggak ada yang cegah

B. Mongoose ODM:

// Mongoose validate dulu!

await Product.findOneAndUpdate(

{ name: "Vitamin C" },

{ price: -50000 }, // ❌ Price negatif!

{ runValidators: true }

);

// Error: Validation failed! Price must be >= 0

Perbedaan Utama:

MongoDB Native tetap menerima nilai negatif karena tidak ada validasi.
Mongoose menolak perubahan tersebut karena schema memeriksa validitas setiap data.

Bisa dibilang, Mongoose memberikan keamanan tambahan terhadap kesalahan logika atau input data yang tidak sesuai standar bisnis.

2.7.3 Tabel Perbandingan Lengkap

2.7.4 Compare Native vs Mongoose (Practice)

Bagian ini bertujuan membantu Anda memahami perbedaan cara kerja MongoDB Native dan Mongoose dalam melakukan operasi CRUD yang sama. Melalui perbandingan langsung, Anda dapat melihat bagaimana MongoDB Native bekerja tanpa aturan validasi bawaan, sedangkan Mongoose menyediakan struktur data yang lebih teratur melalui schema validation. Pemahaman ini penting agar Anda dapat menentukan pendekatan yang tepat sesuai kebutuhan aplikasi.

Pada bagian ini, Anda akan mempelajari bagaimana sebuah operasi yang sama dapat menghasilkan perilaku berbeda ketika dijalankan menggunakan MongoDB Native dan Mongoose. MongoDB Native memberikan keleluasaan penuh tanpa validasi, sehingga cocok untuk operasi cepat atau scripting. Di sisi lain, Mongoose menambahkan aturan melalui schema, membuatnya lebih kuat untuk aplikasi berskala besar yang memerlukan konsistensi data. Dengan melihat kedua pendekatan secara berdampingan, Anda akan memperoleh gambaran yang lebih jelas dalam memilih teknologi yang sesuai.

Langkah-langkah:

1. Install dependencies: npm install mongodb mongoose

npm install mongodb mongoose

2. Buat script perbandingan di file baru, misalnya compare.js:

const { MongoClient } = require("mongodb");

async function insertWithNative() {

const client = new MongoClient("mongodb://localhost:27017");

await client.connect();

const db = client.db("comparison-test");

const result = await db.collection("products").insertOne({

price: -1000, // ❌ Price negatif, tapi berhasil insert!

});

console.log("Native: Inserted (no validation)");

await client.close();

}

3. Buat versi Mongoose:

const { MongoClient } = require("mongodb");

async function insertWithNative() {

const client = new MongoClient("mongodb://localhost:27017");

await client.connect();

const db = client.db("comparison-test");

const result = await db.collection("products").insertOne({

price: -1000, // ❌ Price negatif, tapi berhasil insert!

});

console.log("Native: Inserted (no validation)");

await client.close();

}

4. Jalankan keduanya dan bandingkan hasilnya.

Hasil Akhir:

MongoDB Native berhasil menyimpan data invalid tanpa validasi.
Mongoose menolak data invalid dengan pesan error karena memiliki schema validation

Tips:

Gunakan MongoDB Native untuk kebutuhan cepat atau operasi data dalam jumlah besar.
Gunakan Mongoose jika aplikasi memerlukan struktur data, validasi, dan logika bisnis yang konsisten.
Biasakan memeriksa hasil operasi untuk memastikan data sesuai harapan.
Lakukan validasi schema untuk menjaga kualitas dan keamanan data

Kesimpulan

MongoDB Query Operations memungkinkan Anda mengambil, memfilter, memperbarui, dan menghapus data dari sebuah collection menggunakan sintaks yang menyerupai JavaScript. Operasi dasar seperti find(), insertOne(), updateOne(), dan deleteOne() menjadi fondasi penting dalam pengelolaan data. Dengan dukungan operator seperti $gt, $lt, $and, dan $or, Anda dapat menyusun pencarian data yang kompleks secara efisien.

Pemahaman tentang cara menyusun query yang efektif sangat penting karena query adalah jembatan utama antara aplikasi dan database. Dengan kemampuan mengoptimalkan query, Anda dapat memastikan aplikasi berjalan cepat, akurat, dan responsif dalam memenuhi kebutuhan pengguna.