9 Jenis Operator Mongodb Yang Perlu Anda Ketahui

Dalam bisnis apa pun, data adalah aset terbesar Anda. Dengan menganalisis data, Anda dapat membuat keputusan tentang tren pelanggan dan prediksi perilaku. Ini meningkatkan profitabilitas bisnis dan pengambilan keputusan yang efektif.

Tanpa perangkat lunak basis data, tugas sederhana seperti menemukan rata-rata semua nilai dalam sistem yang penuh dengan catatan akan membosankan. Untungnya, database telah membuat analisis data menjadi lebih mudah dan cepat dengan fungsi dan operator.

Artikel ini akan menjelaskan beberapa operator yang digunakan dalam perangkat lunak database MongoDB.

Apa Itu Operator MongoDB?

MongoDB adalah perangkat lunak database NoSQL yang mengelola informasi berorientasi dokumen.

Salah satu fitur utama MongoDB adalah kecepatannya. Untuk mengembalikan kueri lebih cepat, MongoDB dapat menggunakan operator untuk melakukan fungsi tertentu.

Operator adalah simbol khusus yang membantu kompiler melakukan tugas matematika atau logika. MongoDB menawarkan beberapa jenis operator untuk berinteraksi dengan database.

Jenis Operator MongoDB

Ada sembilan jenis operator, masing-masing diberi nama sesuai fungsinya. Misalnya, operator logika menggunakan operasi logika. Untuk menjalankannya, Anda perlu menggunakan kata kunci tertentu dan mengikuti sintaksnya. Namun, mereka cukup mudah diikuti!

Di akhir artikel, Anda akan dapat mempelajari dasar-dasar setiap operator dan fungsinya.

Operator Logika

Operator logika sering digunakan untuk menyaring data berdasarkan kondisi yang diberikan. Mereka juga memungkinkan evaluasi banyak kondisi, yang akan kita bahas lebih detail.

Berikut adalah beberapa operator logika yang dapat Anda gunakan:

$dan

Kondisi "dan" melakukan operasi "dan" logis pada larik dua atau lebih ekspresi. Ini memilih dokumen di mana semua kondisi ekspresi terpenuhi.

Ini adalah sintaks standar untuk $and ekspresi:

 { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } Misalnya, jika kita ingin memilih dokumen yang harganya $10 dan kuantitasnya kurang dari 15, kita dapat memasukkan query berikut:

 db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

$atau

Kondisi “atau” melakukan operasi logika “atau” pada larik dua atau lebih ekspresi. Ini memilih dokumen di mana setidaknya salah satu ekspresi benar.

Ini adalah sintaks standar untuk $or ekspresi:

 { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.

Misalnya, jika kita ingin memilih dokumen dengan harga $10 atau jumlah kurang dari 15, kita dapat memasukkan query berikut:

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

Kami tidak harus membatasi ekspresi pada dua kriteria — kami dapat menambahkan lebih banyak. Misalnya, kueri di bawah ini memilih dokumen-dokumen yang harganya sama dengan $10, jumlahnya di bawah 15, atau labelnya tidak bergerak:

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: stationary }] } )

Saat menjalankan klausa ini, MongoDB melakukan pemindaian koleksi atau pemindaian indeks. Jika semua indeks mendukung klausa, maka MongoDB menggunakan indeks untuk memeriksa $or ekspresi. Jika tidak, ia menggunakan pemindaian koleksi sebagai gantinya.

Tetapi jika Anda ingin menguji kriteria di bidang yang sama, Anda mungkin ingin menggunakan operator $in daripada operator $or . Misalnya, jika Anda menginginkan kumpulan dokumen yang jumlahnya 10 atau 20, Anda mungkin harus menjalankan kueri $in bawah ini:

 db.inventory.find ( { quantity: { $in: [20, 50] } } )

Kami akan membahas lebih lanjut tentang operator $in nanti.

$nor

Operator ini melakukan operasi logika "nor" pada array menggunakan satu atau lebih ekspresi. Selanjutnya, ia memilih dokumen yang gagal dalam ekspresi kueri. Dalam istilah yang lebih sederhana, ia melakukan kebalikan dari $or condition.

Ini adalah sintaks umum:

 { $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }

Mari kita pertimbangkan kueri berikut:

 db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )

Kueri ini memilih dokumen yang berisi:

• nilai bidang harga tidak sama dengan $3,99, dan nilai penjualan tidak sama dengan benar; atau
• nilai bidang harga tidak sama dengan $3,99, dan bidang penjualan kosong atau tidak ada; atau
• tidak ada bidang harga, dan bidang penjualan tidak sama dengan benar; atau
• baik bidang harga maupun bidang penjualan tidak diisi atau ada.

$tidak

Operator ini melakukan operasi logika "tidak" pada larik untuk ekspresi yang ditentukan. Kemudian memilih dokumen yang tidak cocok dengan ekspresi kueri. Ini termasuk dokumen yang tidak berisi bidang.

Ini adalah sintaks umum:

 { field: { $not: { <operator-expression> } } }

Misalnya, ambil kueri berikut:

 db.inventory.find( { price: { $not: { $lt: 3.99 } } } )

Kueri ini akan memilih dokumen yang berisi:

• bidang harga yang nilainya lebih besar atau sama dengan $3,99; dan
• bidang harga tidak berpenghuni atau tidak ada.

Operator Perbandingan

Operator perbandingan dapat digunakan untuk membandingkan nilai dalam satu atau lebih dokumen.

Di bawah ini adalah contoh kode koleksi inventaris sederhana untuk toko supermarket:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] }, { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] }, { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }, { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Kami akan menggunakan contoh ini sambil merinci setiap operator perbandingan berikutnya.

Sama dengan ($persamaan)

Operator ini mencocokkan nilai yang sama dengan nilai yang diberikan:

 { <field>: { $eq: <value> } }

Misalnya, jika kita ingin mengambil dokumen tertentu dari koleksi inventaris yang memiliki nilai kuantitas yang tepat “20”, kita akan memasukkan perintah berikut:

 db.inventory.find( { qty: { $eq: 20 } } )

Kueri akan mengembalikan yang berikut:

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Lebih besar dari ($gt)

Operator ini cocok jika nilainya lebih besar dari nilai yang diberikan:

 { field: { $gt: value } }

Dalam contoh ini, kami mengambil dokumen yang jumlahnya lebih besar dari 15:

 db.inventory.find({"qty": { $gt: 15}})

Kueri akan mengembalikan yang berikut:

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Kurang dari ($lt)

Operator ini cocok jika nilainya lebih kecil dari nilai yang diberikan:

 { field: { $lt: value } }

Mari kita cari dokumen dengan jumlah kurang dari 25:

 db.inventory.find({"qty": { $lt: 25}})

Kueri akan mengembalikan yang berikut:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Lebih besar atau sama dengan ($gte)

Operator ini cocok ketika nilainya lebih besar dari atau sama dengan nilai yang diberikan:

 { field: { $gte: value } }

Dalam contoh ini, kami mengambil dokumen di mana jumlahnya lebih besar dari atau sama dengan 25:

 db.inventory.find({"qty": { $gte: 25}})

Kueri ini akan mengembalikan yang berikut:

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

Kurang atau sama dengan ($lte)

Operator ini cocok hanya jika nilainya kurang atau sama dengan nilai yang diberikan:

 { field: { $lte: value } }

Mari kita cari dokumen dengan kuantitas di bawah atau sama dengan 25.

 db.inventory.find({"qty": { $lte: 25}})

Kami dapat mengharapkan kueri ini untuk mengembalikan yang berikut:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Dalam ($dalam)

Operator ini mengembalikan dokumen yang cocok dengan nilai yang ditentukan:

 { field: { $in: [<value1>, <value2>, ... <valueN> ] } }

Nilai bidang sama dengan nilai apa pun dalam larik yang ditentukan. Untuk mengambil dokumen dengan nilai "30" dan "15" dalam koleksi inventaris, misalnya, Anda akan melakukan ini:

 db.collection.find({ "qty": { $in: [30, 15]}})

Outputnya akan menjadi:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

Tidak dalam ($nin)

Operator ini mengembalikan dokumen yang tidak cocok dengan nilai yang diberikan. Berikut sintaks dasar dari operator $nin :

 { field: { $nin: [ <value1>, <value2> ... <valueN> ]

$nin memilih dokumen di mana:

• nilai bidang tidak ada dalam larik yang ditentukan; atau
• lapangan tidak ada.

Jika bidang menampung array, itu akan memilih array di mana tidak ada elemen yang ditentukan di bagian nilai yang ada. Misalnya, kami ingin memilih dokumen-dokumen yang jumlahnya tidak sama dengan 20 atau 15.

Selain itu, ini juga cocok dengan dokumen yang tidak memiliki bidang kuantitas:

 db.collection.find({ "qty": { $nin: [ 20, 15 ]}}, {_id: 0})

Outputnya akan menjadi:

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Tidak Sama ($ne)

Operator $ne mengembalikan dokumen di mana nilai yang ditentukan tidak sama:

 { $ne: value } }

Misalnya, kita ingin memilih semua dokumen yang jumlahnya tidak sama dengan 20:

 db.inventory.find( { qty: { $ne: 20 } } )

Outputnya akan menjadi:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Dari output di atas, kita dapat melihat bahwa query akan memilih dokumen yang tidak memiliki field kuantitas.

Operator Elemen

Operator kueri elemen dapat mengidentifikasi dokumen menggunakan bidang dokumen. Operator elemen terdiri dari $exist dan $type .

$ada

Operator ini mencocokkan dokumen yang memiliki bidang tertentu. Operator ini memiliki nilai boolean yang dapat berupa true atau false .

Jika ditetapkan sebagai true , ini cocok dengan dokumen yang berisi bidang tersebut, termasuk dokumen yang nilai bidangnya nol. Jika <boolean> false , maka kueri hanya mengembalikan dokumen yang tidak berisi bidang tersebut.

Berikut sintaks standar:

 { field: { $exists: <boolean> } }

Mari kita ambil contoh di mana kita memiliki kumpulan data untuk larik bernama “bagofmarbles”, di mana setiap kantong berisi kelereng dengan warna berbeda:

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 } { green: 2, blue: 4 } { green: 2 } { blue: 6 }

Katakanlah kita menginginkan kueri yang hanya akan mengembalikan tas tempat kelereng merah ada. Ini berarti kita harus memasukkan nilai boolean sebagai true . Mari lihat:

 db.bagofmarbles.find( { red: { $exists: true } } )

Hasilnya akan terdiri dari dokumen-dokumen yang berisi bidang "merah", meskipun nilainya null . Namun, itu tidak akan terdiri dari dokumen di mana bidang "merah" bahkan tidak ada:

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 }

Jika kita hanya menginginkan tas yang tidak memiliki kelereng merah sebagai bidang, kita dapat memasukkan kueri di bawah ini:

 db.bagofmarbles.find( { red: { $exists: false} }

Hasilnya akan terdiri dari dokumen-dokumen yang tidak mengandung bidang "merah":

 { green: 2, blue: 4 } { green: 2 } { blue: 6 }

$jenis

Operator ini mencocokkan dokumen sesuai dengan jenis bidang yang ditentukan. Ini berguna ketika Anda memiliki data yang sangat tidak terstruktur, atau ketika tipe data tidak dapat diprediksi. Jenis bidang ini adalah jenis BSON yang ditentukan dan dapat ditentukan berdasarkan nomor jenis atau alias.

Ini adalah sintaks umum untuk $type :

 { field: { $type: <BSON type> } }

Katakanlah kita memiliki buku alamat yang berisi dokumen-dokumen di bawah ini:

 db={ addressBook: [ { "_id": 1, address: "2100 Jupiter Spot", zipCode: "9036325" }, { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) }, { "_id": 5, address: "1044 Venus Lane", zipCode: [ "99883637232", "73488976234" ] } ] }

Mengamati dokumen di atas, kode pos memiliki tipe data yang berbeda. Ini termasuk nilai panjang, ganda, bilangan bulat, dan string.

Jika kita hanya menginginkan dokumen yang memiliki tipe data tertentu sebagai kode pos — mari kita ambil string untuk contoh ini — kita harus memasukkan kueri berikut ke dalam kompiler:

 db.addressBook.find({ "zipCode": { $type: "string" } })

Ini akan mengembalikan dokumen-dokumen berikut:

 [ { "_id": 1, "address": "2100 Jupiter Spot", "zipCode": "9036325" }, { "_id": 5, "address": "1044 Venus Lane", "zipCode": [ "99883637232", "73488976234" ] } ]

Selain itu, ada tipe "angka", yang mencakup semua nilai panjang, bilangan bulat, atau ganda sebagai larik yang berisi elemen dari tipe yang ditentukan:

 db.addressBook.find( { "zipCode" : { $type : "number" } } )

Keluaran:

 [ { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) } ]

Jika dokumen memiliki tipe bidang array, operator $type mengembalikan dokumen di mana setidaknya satu elemen array cocok dengan tipe yang diteruskan ke operator.

Operator Array

MongoDB juga terdiri dari operator array, untuk menanyakan dokumen yang berisi array.

Ada tiga operator utama: $all , $elemMatch dan $size . Kami akan membahas masing-masing secara rinci di bawah ini.

$semua

Operator $all memilih dokumen di mana nilai bidang adalah larik yang berisi elemen yang ditentukan:

 { : { $all: [ <value1> , <value2> ... ] } }

Sebagai contoh, katakanlah kita memiliki koleksi dokumen untuk toko pakaian, dengan inventaris berikut.

 { _id: ObjectId("5234cc89687ea597eabee675"), code: "shirt", tags: [ "sale", "shirt", "button", "y2k", "casual" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 45, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] }, { _id: ObjectId("5234ccb7687ea597eabee677"), code: "pant2", tags: [ "trendy", "shine" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 100, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

Kami ingin mengambil dokumen apa pun (dalam hal ini, pakaian) dari inventaris yang terkait dengan tag "trendi" dan "y2k". Kueri di bawah ini menggunakan operator $all di mana nilai bidang tag adalah larik yang elemennya mencakup "y2k" dan "trendi":

 db.inventory.find( { tags: { $all: [ "y2k", "trendy" ] } } )

Kueri di atas mengembalikan yang berikut:

 { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] } { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

Dari contoh di atas, kita juga menemukan bahwa operator $all menjalankan fungsi yang sama dengan operasi $and .

Atau, kita dapat menggunakan kueri di bawah ini yang akan memberikan output serupa dengan yang di atas:

 db.collection.find({ $and: [ { tags: "y2k" }, { tags: "trendy" } ] })

$elemMatch

Operator $elemMatch mencocokkan dokumen yang berisi bidang array dengan setidaknya satu elemen yang cocok dengan semua kriteria kueri yang ditentukan:

 { : { $elemMatch: { <query1>, <query2>, ... } } }

Meskipun kita dapat menggunakan operator perbandingan seperti $lte dan $gte , jika kita hanya menetapkan satu kondisi kueri di dalam $elemMatch , dan tidak menggunakan operator $not atau $ne , penggunaan $elemMatch dapat diabaikan karena pada dasarnya akan berfungsi fungsi yang sama.

Ada beberapa hal lagi yang perlu diingat saat menggunakan operator ini, terutama:

• Anda tidak dapat menentukan ekspresi $ $where dalam operasi $elemMatch .
• Anda tidak dapat menentukan ekspresi kueri $text dalam operasi $elemMatch .

Misalnya, kami memiliki dokumen berikut dalam koleksi hasil siswa:

 { _id: 1, results: [ 92, 89, 98 ] } { _id: 2, results: [ 85, 99, 99 ] }

Kueri berikut hanya cocok dengan dokumen tersebut di mana larik hasil berisi setidaknya satu elemen yang lebih besar dari atau sama dengan 90 dan kurang dari 95:

 db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })

Kueri kami mengembalikan dokumen berikut, karena elemen 92 lebih besar dari atau sama dengan 90 dan kurang dari 95:

 { "_id" : 1, "results" :[ 92, 89, 98 ] }

$ukuran

Operator $size mengembalikan dokumen-dokumen di mana ukuran array cocok dengan jumlah elemen yang ditentukan dalam argumen:

 { field: { $size: value } }

Berikut ini contohnya:

 db.collection.find( { field: { $size: 2 } });

Ini akan mengembalikan semua dokumen dalam koleksi yang ditentukan di mana bidangnya adalah larik dengan 2 elemen: { field: [ orange, apple] } dan { field: [ blue, red] } , tetapi bukan { field: blue} atau { field: [ raspberry, lemon, grapefruit ] } .

Namun, sementara kami dapat memasukkan nilai spesifik sebagai ukuran, kami tidak dapat menentukan rentang nilai sebagai ukuran.

Operator Geospasial

MongoDB memungkinkan Anda untuk menyimpan data geospasial dalam bentuk tipe GeoJSON. GeoJSON adalah format standar terbuka berdasarkan notasi objek JavaScript yang dapat mewakili fitur geografis dan mendukung atribut non-spasial. Ada dua jenis operator geospasial yang akan kita bicarakan dalam artikel ini: penentu geometri dan pemilih kueri.

$geometri

Operator ini menyebutkan geometri GeoJSON untuk digunakan dengan operator kueri geospasial berikut: $geoIntersects , $geoWithin , $nearSphere , dan $near . $geometry memanfaatkan EPSG:4326 sebagai sistem referensi koordinat default (CRS).

Untuk menyebutkan objek GeoJSON dengan CRS default, Anda dapat memanfaatkan cuplikan berikut untuk $geometry :

 $geometry: { type: "<GeoJSON object type>", coordinates: [ <coordinates> ] }

Untuk menyebutkan poligon GeoJSON cincin tunggal dengan CRS MongoDB yang disesuaikan, Anda dapat menggunakan cuplikan berikut (Anda hanya dapat menggunakan ini untuk $geoWithin dan $geoIntersects ):

 $geometry: { type: "Polygon", coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } }

$poligon

Operator $polygon dapat digunakan untuk menentukan poligon untuk kueri $geoWithin geospasial pada pasangan koordinat lama. Kueri ini kemudian akan mengembalikan pasangan yang termasuk dalam batas poligon. Namun, $polygon tidak akan meminta objek GeoJSON apa pun. Untuk mendefinisikan poligon, Anda perlu menentukan larik titik koordinat sebagai berikut:

 { : { $geoWithin: { $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ] } } }

Di sini, poin terakhir secara implisit terhubung ke yang pertama. Anda dapat menyebutkan poin atau sisi sebanyak yang Anda suka.

Misalnya, kueri berikut akan mengembalikan semua dokumen yang memiliki koordinat yang ada di dalam poligon yang ditentukan oleh [0,0], [1,5], dan [3,3]:

 db.places.find( { loc: { $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] } } } )

$geoDalam

Operator ini dapat digunakan untuk memilih dokumen dengan data geospasial yang benar-benar terkandung dalam bentuk tertentu. Bentuk yang ditentukan dapat berupa multipoligon GeoJSON, poligon GeoJSON (baik multi-cincin atau cincin tunggal), atau bentuk yang dapat ditentukan oleh pasangan koordinat lama.

Operator $geoWithin akan memanfaatkan operator $geometry untuk menyebutkan objek GeoJSON.

Untuk menyebutkan multipoligon atau poligon GeoJSON melalui Sistem Referensi Koordinat (CRS) default, Anda dapat menggunakan sintaks yang disebutkan di bawah ini:

 { : { $geoWithin: { $geometry: { type: <"Polygon" or "MultiPolygon"> , coordinates: [ <coordinates> ] } } } }

Untuk kueri $geoWithin yang menyebutkan geometri GeoJSON dengan area yang lebih besar dari satu belahan bumi, penggunaan CRS default akan mengarah ke kueri untuk geometri pelengkap.

Untuk menyebutkan poligon GeoJSON cincin tunggal dengan CRS MongoDB kustom, Anda dapat memanfaatkan prototipe yang disebutkan di bawah ini dalam ekspresi $geometry :

 { : { $geoWithin: { $geometry: { type: "Polygon" , coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } } } } }

Contoh berikut mengambil semua data loc yang ada sepenuhnya dalam poligon GeoJSON, luas poligon kurang dari luas belahan tunggal:

 db.places.find( { loc: { $geoWithin: { $geometry: { type : "Polygon" , coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ] } } } } )

$kotak

Anda dapat menggunakan $box untuk menentukan persegi panjang untuk kueri $geoWithin geospasial guna menyediakan dokumen yang berada dalam batas persegi panjang, menurut data lokasi berbasis titiknya. Saat Anda menggunakan $geoWithin dengan $box , Anda akan mendapatkan dokumen berdasarkan koordinat kueri. Dalam skenario ini, $geoWithin tidak akan meminta bentuk GeoJSON apa pun.

Untuk memanfaatkan operator $box , Anda perlu menyebutkan sudut kanan atas dan kiri bawah persegi panjang dalam objek array:

 { <location field> : { $geoWithin: { $box: [ [ <bottom left coordinates> ], [ <upper right coordinates> ] ] } } }

Query tersebut di atas akan menghitung jarak dengan memanfaatkan geometri planar (datar). Kueri berikut akan mengembalikan semua dokumen yang ada di dalam kotak yang memiliki titik di: [0,0], [0,30], [30,0], [30,30]:

 db.places.find ( { loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } } } )

$dekatSphere

Anda dapat menggunakan $nearSphere untuk menyebutkan titik di mana kueri geospasial mengembalikan dokumen dari terdekat ke terjauh.

MongoDB menggunakan geometri bola untuk menghitung jarak untuk $nearSphere . Ini akan membutuhkan indeks geospasial sebagai berikut:

1. Indeks 2d untuk data lokasi yang digambarkan sebagai pasangan koordinat lama. Untuk memanfaatkan indeks 2d pada titik GeoJSON, Anda perlu membuat indeks pada bidang koordinat objek GeoJSON.
2. Indeks 2dsphere untuk data lokasi yang digambarkan sebagai titik GeoJSON.

Untuk menyebutkan titik GeoJSON, Anda dapat memanfaatkan sintaks berikut:

 { $nearSphere: { $geometry: { type : "Point", coordinates : [ <longitude>, <latitude> ] }, $minDistance: <distance in meters>, $maxDistance: <distance in meters> } }

Di sini, $minDistance dan $maxDistance bersifat opsional. $minDistance dapat membatasi hasil untuk dokumen-dokumen yang setidaknya jarak tertentu dari pusat. Anda dapat menggunakan $maxDistance untuk kedua indeks.

Sekarang, pertimbangkan kumpulan "tempat" yang terdiri dari dokumen dengan bidang lokasi yang memiliki indeks 2dsphere. Contoh berikut akan mengembalikan titik-titik yang lokasinya minimal 2.000 meter dan paling banyak 6.000 meter dari titik yang Anda pilih, diurutkan dari yang terdekat hingga terjauh:

 db.places.find( { location: { $nearSphere: { $geometry: { type : "Point", coordinates : [ -43.9532, 50.32 ] }, $minDistance: 2000, $maxDistance: 6000 } } } )

$geoIntersects

Operator $geoIntersects memungkinkan Anda untuk memilih dokumen yang data geospasialnya berpotongan dengan objek GeoJSON tertentu (yaitu di mana konvergensi objek tertentu dan data tidak kosong). Ini memanfaatkan operator $geometry untuk menentukan objek GeoJSON.

Untuk menyebutkan multipoligon atau poligon GeoJSON melalui sistem referensi koordinat default (CRS), Anda dapat menggunakan sintaks berikut:

 { <location field>: { $geoIntersects: { $geometry: { type: "<GeoJSON object type>" , coordinates: [ <coordinates> ] } } } }

Contoh berikut akan menggunakan $geoIntersects untuk memilih semua data lokasi yang berpotongan dengan poligon yang dijelaskan oleh larik koordinat:

 db.places.find( { loc: { $geoIntersects: { $geometry: { type: "Polygon" , coordinates: [ [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ] ] } } } } )

$pusat

Operator $center menyebutkan lingkaran untuk kueri $geoWithin yang mengembalikan pasangan koordinat lama yang berada dalam batas lingkaran.

$center tidak mengembalikan objek GeoJSON. Untuk memanfaatkan operator $center , Anda perlu menentukan array yang berisi:

1. Jari-jari lingkaran, yang diukur dalam satuan yang digunakan oleh sistem koordinat.
2. Koordinat grid titik pusat lingkaran.

 { <location field> : { $geoWithin: { $center: [ [ <x> , <y> ] , <radius> ] } } }

Contoh yang disebutkan di bawah ini akan mengembalikan semua dokumen yang memiliki koordinat yang dapat ditemukan di dalam lingkaran yang berpusat pada [2,3] dan dengan radius 40:

 db.places.find( { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } } )

Operator Proyeksi

Anda dapat menggunakan operator proyeksi untuk menyebutkan bidang yang dikembalikan oleh operasi. Operator proyeksi MongoDB memungkinkan fungsi find() digunakan dengan argumen pemfilteran data. Ini membantu pengguna mengekstrak hanya bidang data yang diperlukan dari dokumen. Jadi, ini memungkinkan Anda untuk memproyeksikan data yang transparan dan ringkas tanpa mempengaruhi kinerja database secara keseluruhan.

$elemMatch (proyeksi)

Operator $elemMatch bertanggung jawab untuk membatasi konten bidang dari hasil kueri agar hanya berisi elemen pertama yang cocok dengan kondisi $elemMatch .

Berikut adalah beberapa hal yang perlu Anda ingat sebelum menggunakan $elemMatch :

• Dari MongoDB 4.4, terlepas dari urutan bidang dalam dokumen, proyeksi $elemMatch dari bidang yang ada mengembalikan bidang setelah penyertaan bidang lain yang ada.
• Baik operator $elemMatch dan $ menggambarkan elemen pertama yang cocok dari array berdasarkan kondisi yang ditentukan. Operator $ akan memproyeksikan elemen larik pertama yang cocok dari setiap dokumen dalam koleksi berdasarkan beberapa kondisi dari pernyataan kueri, sedangkan operator proyeksi $elemMatch mengambil argumen kondisi eksplisit. Ini memungkinkan Anda memproyeksikan berdasarkan kondisi yang tidak ada dalam kueri, atau jika Anda perlu memproyeksikan berdasarkan berbagai bidang dalam dokumen tersemat larik.

Anda juga harus mengetahui batasan berikut sebelum menggunakan operator $elemMatch pada data Anda:

• Anda tidak dapat menyebutkan ekspresi kueri $text dalam operator $elemMatch .
• db.collection.find() operasi pada tampilan tidak mendukung operator proyeksi $elemMatch .

Contoh berikut pada operator proyeksi $elemMatch mengasumsikan kumpulan schools dengan dokumen berikut:

 { _id: 1, zipcode: "63108", students: [ { name: "mark", school: 102, age: 9 }, { name: "geoff", school: 101, age: 13 }, { name: "frank", school: 104, age: 12 } ] } { _id: 2, zipcode: "63110", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 3, zipcode: "63108", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 4, zipcode: "63110", students: [ { name: "jim", school: 103, age: 9 }, { name: "michael", school: 103, age: 12 }, ] }

Dalam contoh ini, operasi find() kueri untuk semua dokumen dengan nilai bidang kode pos adalah 63110. Proyeksi $elemMatch hanya akan mengembalikan elemen pertama yang cocok dari larik students di mana bidang school memiliki nilai 103:

 db.schools.find( { zipcode: "63110" }, { students: { $elemMatch: { school: 103 } } } ) This is what the result would look like: { "_id" : 2, "students" : [ { "name" : "harry", "school" : 103, "age" : 14 } ] } { "_id" : 4, "students" : [ { "name" : "jim", "school" : 103, "age" : 9 } ] }

$slice (proyeksi)

Operator proyeksi $slice dapat digunakan untuk menentukan jumlah elemen dalam larik yang akan dikembalikan dalam hasil kueri:

 db.collection.find( <query> , { <arrayField> : { $slice: <number> } } );

Bisa juga diekspresikan seperti ini:

 db.collection.find( <query> , { <arrayField> : { $slice: [ <number> , <number> ] } } );

Untuk mendemonstrasikan hal yang sama, Anda dapat membuat contoh kumpulan tweet dengan dokumen berikut:

 db.posts.insertMany([ { _id: 1, title: "Nuts are not blueberries.", comments: [ { comment: "0. true" }, { comment: "1. blueberries aren't nuts."} ] }, { _id: 2, title: "Coffee please.", comments: [ { comment: "0. Indubitably" }, { comment: "1. Cuppa tea please" }, { comment: "2. frappucino" }, { comment: "3. Mocha latte" }, { comment: "4. whatever" } ] } ])

Operasi berikut akan menggunakan operator proyeksi $slice pada larik tweets untuk mengembalikan larik dengan dua elemen pertamanya. Jika array berisi kurang dari dua elemen, semua elemen dalam array dikembalikan:

 db.posts.find( {}, { comments: { $slice: 2 } } )

Operasi itu akan mengembalikan dokumen-dokumen berikut:

 { "_id" : 1, "title" : "Nuts are not blueberries.", "comments" : [ { "comment" : "0. true" }, { "comment" : "1. blueberries aren't nuts." } ] } { "_id" : 2, "title" : "Coffee please.", "comments" : [ { "comment" : "0. Indubitably" }, { "comment" : "1. Cuppa tea please" } ] }

$ (proyeksi)

Operator $ posisional membatasi konten larik untuk mengembalikan elemen pertama yang cocok dengan kondisi kueri larik tersebut. Anda dapat menggunakan $ dalam dokumen proyeksi metode find() atau metode findOne() bila Anda hanya memerlukan satu elemen larik tertentu dalam dokumen yang dipilih.

Seperti inilah sintaks untuk operator $ :

 db.collection.find( { <array>: <condition> ... }, { "<array>.$": 1 } ) db.collection.find( { <array.field>: <condition> ...}, { "<array>.$": 1 } )

Dalam contoh ini, koleksi students terdiri dari dokumen-dokumen berikut:

 { "_id" : 1, "semester" : 2, "grades" : [ 75, 67, 93 ] } { "_id" : 2, "semester" : 2, "grades" : [ 60, 68, 72 ] } { "_id" : 3, "semester" : 2, "grades" : [ 95, 82, 67 ] } { "_id" : 4, "semester" : 3, "grades" : [ 89, 95, 70 ] } { "_id" : 5, "semester" : 3, "grades" : [ 68, 98, 82 ] } { "_id" : 6, "semester" : 3, "grades" : [ 65, 70, 76 ] }

Dalam kueri berikut, proyeksi { "grades.$": 1 } hanya mengembalikan elemen pertama yang lebih besar dari atau sama dengan 89 untuk bidang grades :

 db.students.find( { semester: 2, grades: { $gte: 89 } }, { "grades.$": 1 } )

Operasi ini mengembalikan dokumen-dokumen berikut:

 {"_id": 3, "grades": [95] }

Operator Evaluasi

Anda dapat memanfaatkan operator evaluasi MongoDB untuk mengukur keseluruhan struktur data atau bidang individual di dalam dokumen.

Mari kita lihat beberapa operator evaluasi MongoDB yang umum.

$mod

Anda dapat menggunakan operator ini untuk mencocokkan dokumen di mana nilai bidang yang ditentukan sama dengan sisanya setelah dibagi dengan nilai yang ditentukan:

 { field: { $mod: [ divisor, remainder ] } }

Katakanlah Anda memiliki tabel mobil milik berbagai merek yang Anda miliki di showroom Anda. Kueri berikut akan memberi Anda semua merek mobil yang nomor stoknya kelipatan 250.

 db.cars.find ( { qty: { $mod: [ 250,0 ] } } )

$jsonSchema

$jsonSchema memungkinkan Anda mencocokkan dokumen yang cocok dengan skema JSON yang ditentukan. Implementasi skema JSON MongoDB mencakup penambahan kata kunci bsonType , yang memungkinkan Anda menggunakan semua tipe BSON dalam operator $jsonSchema .

bsonType dapat menerima alias string yang sama dengan yang Anda gunakan untuk operator type . Seperti inilah sintaks $jsonSchema akan terlihat:

 { $jsonSchema: <JSON Schema object> }

Di sini, objek skema JSON diformat berdasarkan draf standar skema JSON 4:

 { <keyword1>: <value1>, ... }

Berikut adalah contoh untuk mendemonstrasikan cara $jsonSchema :

 { $jsonSchema: { required: [ "name", "major", "gpa", "address" ], properties: { name: { bsonType: "string", description: "must be a string and is required" }, address: { bsonType: "object", required: [ "zipcode" ], properties: { "street": { bsonType: "string" }, "zipcode": { bsonType: "string" } } } } } }

Anda juga dapat menggunakan $jsonSchema dalam validator dokumen untuk menerapkan skema yang ditentukan pada operasi pembaruan dan penyisipan:

 db.createCollection(<collection> , { validator: { $jsonSchema: <schema> } } ) db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } )

Ingatlah bahwa ada beberapa hal yang tidak didukung oleh operator $jsonSchema :

1. Tipe bilangan bulat. Anda perlu memanfaatkan tipe BSON long atau int dengan kata kunci bsonType.
2. Kata kunci tidak dikenal.
3. Menautkan properti dan hypermedia skema JSON, bersama dengan penggunaan referensi JSON dan pointer JSON.

$teks

Operator $text akan mencari teks di dalam konten bidang yang ditentukan, diindeks dengan indeks teks:

 { $text: { $search: <string>, $language: <string>, $caseSensitive: <boolean>, $diacriticSensitive: <boolean> } }

Dalam contoh ini, cuplikan kode berikut akan menyaring tabel untuk menyaring mobil yang memiliki teks "Porsche" di dalamnya:

 db.cars.find( { $text: { $search: "Porsche" } } )

$regex

Operator $regex menawarkan kemampuan ekspresi reguler untuk mencocokkan pola string dalam kueri. MongoDB memanfaatkan ekspresi reguler yang kompatibel dengan Perl:

 {<field> : /pattern/ <options>}

Contoh berikut akan membantu menyaring semua mobil yang memiliki string "$78900" di dalamnya:

 db.cars.find( { price: { $regex: /$78900/ } } )

$expr

Operator $expr memungkinkan Anda memanfaatkan ekspresi agregasi dalam bahasa kueri:

 { $expr: { <expression> } }

Anda juga dapat menggunakan $expr untuk membuat ekspresi kueri yang membandingkan bidang dari dokumen yang sama dalam tahap $match . If the $match stage happens to be the part of a $lookup stage, $expr can compare fields with the help of let variables.

$where

You can leverage the $where operator to either pass a string containing a full JavaScript function or a JavaScript expression to the query system. The $where operator provides greater flexibility but needs the database to process the JavaScript function or expression for every document in the collection. You can reference this document in the JavaScript function or expression by using either obj or this .

Here's an example of the syntax:

 { $where: <string|JavaScript Code> }

There are a few key considerations to keep in mind before we dive into an example while using the $where operator:

• You should only use the $where query operator to top-level documents. The $where query operator won't function in a nested document, like in a $elemMatch query.
• Generally, you should use $where only when you cannot express your query via another operator. If you have to use $where , make sure you include at least one other standard query operator to filter the result set. Using $where independently requires a collection scan for proper execution.

Here's an example to illustrate this:

 db.cars.find( { $where: function() { return (hex_md5(this.name)== "9a43e617b50cd379dca1bc6e2a8") } } );

Bitwise Operators

Bitwise operators return data based on bit position conditions. Simply put, they are used to match numeric or binary values in which any bit from a set of bit positions has a value of 1 or 0.

$bitsAllSet

This operator will match all the documents where all of the bit positions provided by the query are set (ie 1) in the field:

{ <field> : { $bitsAllSet: <numeric bitmask> } }

 { <field> : { $bitsAllSet: < BinData bitmask> } }

 { <field> : { $bitsAllSet: [ <position1> , <position2> , ... ] } }

Nilai bidang harus berupa instance BinData atau numerik untuk $bitsAllSet agar sesuai dengan dokumen saat ini.

Dalam contoh berikut, kami memanfaatkan koleksi dengan dokumen berikut:

 db.collection.save({ _id: 1, a: 54, binaryValueofA: "00110110" }) db.collection.save({ _id: 2, a: 20, binaryValueofA: "00010100" }) db.collection.save({ _id: 3, a: 20.0, binaryValueofA: "00010100" }) db.collection.save({ _id: 4, a: BinData(0, "Zg=="), binaryValueofA: "01100110" })

Kueri yang disebutkan di bawah ini akan menggunakan operator $bitsAllSet untuk menguji apakah bidang a memiliki bit yang ditetapkan pada posisi 1 dan posisi 5, di mana bit paling tidak signifikan akan berada pada posisi 0:

 db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } }

Kueri ini akan cocok dengan dokumen berikut:

 { "_id" : 1, "a" : 54, "binaryValueofA" : "00110110" } { "_id" : 4, "a" : BinData(0,"Zg=="), "binaryValueofA" : "01100110" }

$bitsAllClear

Operator $bitsAllClear akan mencocokkan dokumen di mana semua posisi bit yang disediakan oleh kueri jelas atau 0 :

 { <field> : { $bitsAllClear: <numeric bitmask> } }

 { <field> : { $bitsAllClear: < BinData bitmask> } }

 { <field> : { $bitsAllClear: [ <position1> , <position2> , ... ] } }

Kami akan menggunakan contoh yang digunakan untuk $bitsAllSet di sini untuk mendemonstrasikan penggunaan $bitsAllClear . Kueri berikut akan menggunakan operator ini untuk memeriksa apakah bidang a memiliki bit yang jelas pada posisi 1 dan 5:

 db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )

Kueri ini akan cocok dengan dokumen berikut:

 { "_id" : 2, "a" : 20, "binaryValueofA" : "00010100" } { "_id" : 3, "a" : 20, "binaryValueofA" : "00010100" }

Operator Meta

Ada berbagai pengubah kueri yang memungkinkan Anda mengubah perilaku atau keluaran kueri di MongoDB. Antarmuka driver mungkin menyediakan metode kursor yang membungkusnya untuk Anda gunakan.

$petunjuk

MongoDB tidak lagi menggunakan $hint sejak v3.2. Namun, operator ini mungkin masih tersedia untuk driver MongoDB seperti Go, Java, Scala, Ruby, Swift, dll. Ini dapat memaksa pengoptimal kueri untuk memanfaatkan indeks tertentu untuk memenuhi kueri, yang kemudian dapat disebutkan baik oleh dokumen atau oleh nama indeks.

Anda juga dapat menggunakan operator $hint untuk menguji strategi pengindeksan dan kinerja kueri. Misalnya, ambil operasi berikut:

 db.users.find().hint( { age: 1 } )

Operasi ini akan mengembalikan semua dokumen dalam koleksi yang disebut users dengan memanfaatkan indeks pada bidang age .

Anda juga dapat menyebutkan petunjuk dengan menggunakan salah satu formulir berikut:

 db.users.find()._addSpecial( "$hint", { age : 1 } ) db.users.find( { $query: {}, $hint: { age : 1 } } )

Jika filter indeks ada untuk bentuk kueri, MongoDB akan mengabaikan $hint .

$komentar

Operator $comment memungkinkan Anda untuk melampirkan komentar ke kueri dalam konteks apa pun yang mungkin $query . Karena komentar menyebar ke log profil, menambahkan komentar dapat memudahkan untuk menafsirkan dan melacak profil Anda.

Anda dapat memanfaatkan $comment dengan salah satu dari tiga cara berikut:

 db.collection.find( { <query> } )._addSpecial( "$comment", <comment> ) db.collection.find( { <query> } ).comment( <comment> ) db.collection.find( { $query: { <query> }, $comment: <comment> } )

Jika Anda ingin melampirkan komentar ke ekspresi kueri dalam konteks lain, seperti dengan db.collection.update() , manfaatkan operator kueri $comment alih-alih operator meta.

$maks

Anda dapat menyebutkan nilai $max untuk menentukan batas atas eksklusif untuk indeks tertentu guna membatasi hasil find() . Operator ini akan menentukan batas atas untuk semua kunci dari urutan tertentu dalam indeks.

Mongosh memberi Anda metode pembungkus max() berikut:

 db.collection.find( { <query> } ).max( { field1: <max value> , ... fieldN: <max valueN> } )

Anda juga dapat menyebutkan $max dengan dua bentuk berikut:

 db.collection.find( { <query> } )._addSpecial( "$max", { field1: <max value1> , ... fieldN: <max valueN> } ) db.collection.find( { $query: { <query> }, $max: { field1: <max value1> , ... fieldN: <max valueN> } } )

Misalnya, jika Anda ingin menentukan batas atas eksklusif, perhatikan operasi berikut pada koleksi bernama koleksi yang berisi indeks { age: 1 } :

 db.collection.find( { <query> } ).max( { age: 100 } ).hint( { age: 1 } )

Operasi ini akan membatasi kueri ke dokumen-dokumen di mana usia bidang kurang dari 100 dan memaksa rencana kueri yang akan memindai indeks { age: 1 } dari minKey ke 100.

$jelaskan

Operator ini akan memberi Anda informasi tentang rencana kueri. Ini mengembalikan dokumen yang menjelaskan indeks dan proses yang digunakan untuk mengembalikan kueri. Ini bisa berguna saat mencoba mengoptimalkan kueri.

Anda dapat menyebutkan operator $explain dalam salah satu formulir berikut:

 db.collection.find()._addSpecial( "$explain", 1 ) db.collection.find( { $query: {}, $explain: 1 } )

Praktik Terbaik untuk Operator MongoDB

Di bagian ini, kita akan melihat beberapa praktik terbaik saat menggunakan operator MongoDB ini.

Penyematan dan Referensi

Embedding adalah perpanjangan alami dari pemodelan data. Ini memungkinkan Anda untuk menghindari penggabungan aplikasi, yang dapat mengurangi pembaruan dan kueri.

Anda dapat menyematkan data dengan hubungan 1:1 dalam satu dokumen. Yang mengatakan, data dengan hubungan banyak:1 di mana "banyak" objek muncul dengan dokumen induknya juga bisa menjadi kandidat yang baik.

Menyimpan jenis data ini dalam dokumen yang sama terdengar seperti pilihan yang bijaksana. Namun, penyematan memberikan kinerja yang lebih baik untuk operasi baca dengan jenis lokalitas data ini.

Model data tersemat juga dapat membantu pengembang memperbarui data terkait dalam satu operasi tulis. Ini berfungsi karena penulisan dokumen tunggal bersifat transaksional.

Anda harus mempertimbangkan untuk menggunakan referensi untuk skenario berikut:

• Saat Anda memperbarui segmen dokumen dan itu terus bertambah panjang, sementara sisa dokumen statis.
• Ketika sebuah dokumen diakses tetapi berisi data yang jarang digunakan. Menyematkan hanya akan meningkatkan persyaratan dalam memori, jadi referensi lebih masuk akal.
• Ketika ukuran dokumen melebihi batas dokumen 16MB MongoDB. Ini dapat terjadi ketika memodelkan banyak:1 hubungan (misalnya, employee:department ).

Periksa Profil dan Pola Kueri

Bagi sebagian besar pengembang, langkah pertama dalam mengoptimalkan kinerja adalah memahami pola kueri yang sebenarnya dan yang diharapkan. Setelah Anda mengetahui pola kueri aplikasi dengan cukup baik, Anda dapat membuat model data dan memilih indeks yang sesuai.

Pengembang MongoDB memiliki akses ke berbagai alat canggih yang memungkinkan mereka meningkatkan kinerja. Namun bukan berarti profil dan pola kueri dapat diabaikan.

Misalnya, satu cara mudah untuk meningkatkan kinerja adalah dengan menganalisis pola kueri Anda dan memahami di mana Anda dapat menyematkan data. Cara lain untuk meningkatkan kinerja MongoDB setelah mengidentifikasi pola kueri utama Anda meliputi:

• Memastikan bahwa Anda memiliki indeks pada bidang apa pun yang Anda tanyakan.
• Menyimpan hasil sub-kueri yang sering pada dokumen untuk mengurangi beban baca.
• Lihatlah log Anda untuk melihat kueri yang lambat, lalu periksa indeks Anda.

Tinjau Pengindeksan dan Pemodelan Data

Saat membuat model data, Anda akan memutuskan bagaimana memodelkan hubungan antar data. Memilih kapan untuk menyematkan dokumen versus membuat referensi di seluruh dokumen terpisah dalam koleksi yang berbeda, misalnya, adalah contoh pertimbangan khusus aplikasi.

Keuntungan utama dari dokumen JSON adalah memungkinkan pengembang memodelkan data berdasarkan persyaratan aplikasi. Subdokumen dan larik bersarang membantu Anda memodelkan hubungan kompleks antara data dengan memanfaatkan dokumen teks sederhana.

Anda juga dapat menggunakan MongoDB untuk memodelkan yang berikut ini:

• data geospasial
• Struktur tabular, datar, dan kolumnar
• Pasangan nilai kunci sederhana
• Data deret waktu
• Tepi dan simpul dari struktur data grafik yang terhubung dan sejenisnya

Memantau Sharding dan Replikasi

Replikasi dapat menjadi sangat penting untuk meningkatkan kinerja karena meningkatkan ketersediaan data melalui penskalaan horizontal. Replikasi dapat menghasilkan kinerja yang lebih baik dan keamanan yang lebih melalui redundansi.

Pemantauan kinerja bisa merepotkan karena membutuhkan sumber daya dan waktu tambahan untuk memastikan kelancaran fungsi. Anda dapat memanfaatkan alat pemantauan kinerja yang tersedia di pasar yang memenuhi kebutuhan spesifik Anda.

Misalnya, Kinsta APM dapat mengambil informasi cap waktu tentang kueri database MySQL situs WordPress Anda, proses PHP, panggilan HTTP eksternal, dan banyak lagi. Anda juga dapat menggunakan alat gratis ini untuk men-debug:

• Panggilan API yang panjang
• Permintaan URL eksternal yang panjang
• Kueri basis data lambat untuk beberapa nama.

Di MongoDB, replikasi dapat dicapai melalui set replika yang memungkinkan pengembang menyalin data dari node atau server utama di beberapa sekunder. Ini memungkinkan replikasi Anda menjalankan beberapa kueri pada sekunder sebagai lawan dari primer, menghindari pertengkaran dan mengarah ke penyeimbangan beban yang lebih baik.

Cluster sharded di MongoDB adalah cara lain untuk berpotensi meningkatkan kinerja. Mirip dengan replikasi, sharding dapat digunakan untuk mendistribusikan kumpulan data besar di beberapa server.

Dengan memanfaatkan kunci pecahan, pengembang dapat menyalin pecahan atau potongan data di beberapa server. Server-server ini dapat bekerja sama untuk menggunakan semua data.

Sharding memiliki keuntungan yang adil, termasuk penskalaan horizontal untuk penulisan/pembacaan, ketersediaan yang lebih tinggi, dan peningkatan kapasitas penyimpanan.

Tentukan Penggunaan Memori

MongoDB melakukan yang terbaik ketika set kerja aplikasi (yaitu data dan indeks yang sering diakses) sesuai dengan memori tanpa masalah. Sementara faktor lain sangat penting untuk kinerja, ukuran RAM adalah yang paling penting untuk ukuran instans.

Saat set kerja aplikasi sesuai dengan RAM, aktivitas baca dari disk harus rendah. Tetapi jika set kerja Anda melebihi RAM dari server atau ukuran instance, aktivitas baca akan mulai meningkat.

Jika Anda melihat ini terjadi, Anda mungkin dapat memecahkan masalah dengan pindah ke instance yang lebih besar yang memiliki lebih banyak memori.

Tempatkan Bidang Multi-Nilai di Akhir

Jika Anda mengindeks beberapa bidang, dan salah satu bidang yang ingin Anda kueri menggunakan salah satu operator "multi-nilai" itu, maka Anda harus meletakkannya di akhir indeks. Anda perlu mengurutkan indeks sehingga bidang kueri untuk nilai pasti didahulukan dan operator "multi-nilai" muncul terakhir di indeks.

Pengecualian untuk ini adalah penyortiran terhadap bidang. Tempatkan ini di antara bidang "multi-nilai" dan bidang yang tepat untuk memotong jumlah penyortiran dalam memori yang diperlukan.

Ringkasan

Untuk MongoDB, kecepatan adalah nama permainannya. Untuk mengembalikan kueri dengan cepat, MongoDB memanfaatkan operator untuk menjalankan tugas matematika atau logika. Sederhananya, memahami operator MongoDB adalah kunci untuk menguasai MongoDB.

Artikel ini menyoroti beberapa operator utama MongoDB yang dapat Anda gunakan pada data Anda seperti operator perbandingan, operator logika, operator meta, dan operator proyeksi, untuk beberapa nama. Ini juga membantu Anda memahami bagaimana Anda dapat menggunakan operator MongoDB dan praktik terbaik yang memungkinkan Anda mendapatkan yang terbaik dari mereka.

Di antara semua operator, mana yang paling sering Anda gunakan, dan mengapa? Bagikan di komentar di bawah — kami akan senang mendengar pendapat Anda!