Cara Menggunakan Pipa Agregasi di MongoDB

Pipa agregasi adalah cara yang disarankan untuk menjalankan kueri kompleks di MongoDB. Jika Anda telah menggunakan MapReduce MongoDB, sebaiknya Anda beralih ke pipeline agregasi untuk komputasi yang lebih efisien.

Apa Itu Agregasi di MongoDB dan Bagaimana Cara Kerjanya?

Pipeline agregasi adalah proses multi-tahap untuk menjalankan tingkat lanjut pertanyaan di MongoDB. Ini memproses data melalui tahapan berbeda yang disebut pipeline. Anda dapat menggunakan hasil yang dihasilkan dari satu tingkat sebagai templat operasi di tingkat lainnya.

Misalnya, Anda dapat meneruskan hasil operasi pencocokan ke tahap lain untuk diurutkan dalam urutan tersebut hingga Anda mendapatkan keluaran yang diinginkan.

Setiap tahapan pipeline agregasi menampilkan operator MongoDB dan menghasilkan satu atau lebih dokumen yang diubah. Bergantung pada kueri Anda, level bisa muncul beberapa kali di alur. Misalnya, Anda mungkin perlu menggunakan

$hitungan atau $sort tahapan operator lebih dari satu kali di seluruh jalur agregasi.

Tahapan Pipa Agregasi

Alur agregasi meneruskan data melalui beberapa tahapan dalam satu kueri. Ada beberapa tahapan dan Anda dapat menemukan detailnya di Dokumentasi MongoDB.

Mari kita definisikan beberapa yang paling umum digunakan di bawah ini.

Tahap $pertandingan

Tahap ini membantu Anda menentukan kondisi pemfilteran tertentu sebelum memulai tahap agregasi lainnya. Anda dapat menggunakannya untuk memilih data pencocokan yang ingin Anda sertakan dalam alur agregasi.

Tahap $grup

Tahap grup memisahkan data menjadi beberapa kelompok berbeda berdasarkan kriteria tertentu menggunakan pasangan nilai kunci. Setiap grup mewakili kunci dalam dokumen keluaran.

Misalnya, pertimbangkan hal berikut penjualan contoh data:

Dengan menggunakan alur agregasi, Anda dapat menghitung jumlah total penjualan dan penjualan teratas untuk setiap bagian produk:

{
 $group: {
 _id: $Section,
 total_sales_count: {$sum: $Sold},
 top_sales: {$max: $Amount},
 }
}

Itu _id: $Bagian pasangan mengelompokkan dokumen keluaran berdasarkan bagiannya. Dengan menentukan jumlah_penjualan teratas Dan penjualan_top bidang, MongoDB membuat kunci baru berdasarkan operasi yang ditentukan oleh agregator; ini bisa jadi $jumlah, $min, $maks, atau $rata-rata.

Tahap $skip

Anda dapat menggunakan $lewati tahap untuk menghilangkan sejumlah dokumen tertentu dalam output. Biasanya terjadi setelah babak penyisihan grup. Misalnya, jika Anda mengharapkan dua dokumen keluaran tetapi melewatkan satu dokumen, agregasi hanya akan mengeluarkan dokumen kedua.

Untuk menambahkan tahap lewati, masukkan $lewati operasi ke dalam pipa agregasi:

...,
{
 $skip: 1
 },

Tahap $sort

Tahap pengurutan memungkinkan Anda menyusun data dalam urutan menurun atau menaik. Misalnya, kita dapat mengurutkan lebih lanjut data pada contoh kueri sebelumnya dalam urutan menurun untuk menentukan bagian mana yang memiliki penjualan tertinggi.

Tambahkan $sort operator ke kueri sebelumnya:

...,
{
 $sort: {top_sales: -1}
 },

Tahap $batas

Operasi batas membantu mengurangi jumlah dokumen keluaran yang Anda inginkan untuk ditampilkan oleh alur agregasi. Misalnya, gunakan $batas operator untuk mendapatkan bagian dengan penjualan tertinggi yang dikembalikan pada tahap sebelumnya:

...,
{
 $sort: {top_sales: -1}
 },
{"$limit": 1}

Di atas hanya mengembalikan dokumen pertama; ini adalah bagian dengan penjualan tertinggi, seperti yang muncul di bagian atas keluaran yang diurutkan.

Tahap $proyek

Itu $proyek stage memungkinkan Anda untuk membentuk dokumen keluaran sesuka Anda. Menggunakan $proyek operator, Anda dapat menentukan bidang mana yang akan disertakan dalam output dan menyesuaikan nama kuncinya.

Misalnya, keluaran sampel tanpa $proyek panggung terlihat seperti ini:

Mari kita lihat seperti apa tampilannya $proyek panggung. Untuk menambahkan $proyek ke pipa:

...,
{
 "$project": {
 "_id": 0,
 "Section": "$_id",
 "TotalSold": "$total_sales_count",
 "TopSale": "$top_sales",
 }
 }

Karena sebelumnya kita telah mengelompokkan data berdasarkan bagian produk, data di atas mencakup setiap bagian produk dalam dokumen keluaran. Ini juga memastikan bahwa jumlah penjualan agregat dan fitur penjualan teratas dalam output sebagai Total Terjual Dan Penjualan Teratas.

Hasil akhirnya jauh lebih bersih dibandingkan dengan yang sebelumnya:

Tahap $bersantai

Itu $bersantai stage memecah array dalam dokumen menjadi dokumen individual. Ambil yang berikut ini Pesanan datanya, misalnya:

Menggunakan $bersantai tahap untuk mendekonstruksi item array sebelum menerapkan tahapan agregasi lainnya. Misalnya, melepas gulungan item array masuk akal jika Anda ingin menghitung total pendapatan untuk setiap produk:

db.Orders.aggregate(
[
 {
 "$unwind": "$items"
 },
 {
 "$group": {
 "_id": "$items.product",
 "total_revenue": { "$sum": { "$multiply": ["$items.quantity", "$items.price"] } }
 }
 },
 {
 "$sort": { "total_revenue": -1 }
 },
 {
 "$project": {
 "_id": 0,
 "Product": "$_id",
 "TotalRevenue": "$total_revenue",
 }
 }
])

Berikut hasil kueri agregasi di atas:

Cara Membuat Pipa Agregasi di MongoDB

Meskipun alur agregasi mencakup beberapa operasi, tahapan yang ditampilkan sebelumnya memberi Anda gambaran tentang cara menerapkannya dalam alur, termasuk kueri dasar untuk masing-masing operasi.

Menggunakan yang sebelumnya penjualan contoh data, mari kita bahas beberapa tahapan yang dibahas di atas secara keseluruhan untuk mendapatkan gambaran yang lebih luas tentang jalur agregasi:

db.sales.aggregate([
 {
 "$match": {
 "Sold": { "$gte": 5 }
 }
 },
 {
 "$group": {
 "_id": "$Section",
 "total_sales_count": { "$sum": "$Sold" },
 "top_sales": { "$max": "$Amount" },

 }
 },
 {
 "$sort": { "top_sales": -1 }
 },
 {"$skip": 0},
 {
 "$project": {
 "_id": 0,
 "Section": "$_id",
 "TotalSold": "$total_sales_count",
 "TopSale": "$top_sales",
 }
 }

])

Hasil akhirnya terlihat seperti yang pernah Anda lihat sebelumnya:

Pipa Agregasi vs. Pengurangan Peta

Hingga penghentiannya dimulai pada MongoDB 5.0, cara konvensional untuk mengumpulkan data di MongoDB adalah melalui MapReduce. Meskipun MapReduce memiliki aplikasi yang lebih luas selain MongoDB, ini kurang efisien dibandingkan pipeline agregasi, sehingga memerlukan skrip pihak ketiga untuk menulis peta dan mengurangi fungsi secara terpisah.

Sebaliknya, pipeline agregasi khusus untuk MongoDB saja. Namun ini memberikan cara yang lebih bersih dan efisien untuk mengeksekusi kueri yang kompleks. Selain kesederhanaan dan skalabilitas kueri, tahapan pipeline unggulan membuat keluaran lebih dapat disesuaikan.

Masih banyak lagi perbedaan antara pipa agregasi dan MapReduce. Anda akan melihatnya saat beralih dari MapReduce ke alur agregasi.

Jadikan Kueri Big Data Efisien di MongoDB

Kueri Anda harus seefisien mungkin jika Anda ingin menjalankan penghitungan mendalam pada data kompleks di MongoDB. Alur agregasi ideal untuk kueri tingkat lanjut. Daripada memanipulasi data dalam operasi terpisah, yang sering kali mengurangi performa, agregasi memungkinkan Anda mengemas semuanya ke dalam satu pipeline berperforma tinggi dan mengeksekusinya satu kali.

Meskipun alur agregasi lebih efisien dibandingkan MapReduce, Anda dapat membuat agregasi lebih cepat dan efisien dengan mengindeks data Anda. Hal ini membatasi jumlah data yang perlu dipindai MongoDB selama setiap tahap agregasi.