Apa itu ekspresi di mongodb?

Ekspresi Reguler sering digunakan dalam semua bahasa untuk mencari pola atau kata dalam string apa pun. MongoDB juga menyediakan fungsionalitas ekspresi reguler untuk pencocokan pola string menggunakan operator $regex. MongoDB menggunakan PCRE (Perl Compatible Regular Expression) sebagai bahasa ekspresi reguler

Nội dung chính Show

Menggunakan ekspresi regex
Menggunakan Ekspresi regex dengan Case Insensitive
Menggunakan regex untuk Elemen Array
Mengoptimalkan Kueri Ekspresi Reguler
Manakah ekspresi agregasi yang digunakan dalam MongoDB?
Mengapa kita menggunakan $$ di MongoDB?
Apa itu $$ root di MongoDB?
Bagaimana cara menanyakan banyak nilai di MongoDB?

Tidak seperti pencarian teks, kita tidak perlu melakukan konfigurasi atau perintah apa pun untuk menggunakan ekspresi reguler

Asumsikan kita telah memasukkan dokumen ke dalam database bernama posts seperti yang ditunjukkan di bawah ini −

> db.posts.insert(
{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}
WriteResult({ "nInserted" : 1 })

Menggunakan ekspresi regex

Permintaan regex berikut mencari semua posting yang berisi string tutorialspoint di dalamnya −

> db.posts.find({post_text:{$regex:"tutorialspoint"}}).pretty()
{
	"_id" : ObjectId("5dd7ce28f1dd4583e7103fe0"),
	"post_text" : "enjoy the mongodb articles on tutorialspoint",
	"tags" : [
		"mongodb",
		"tutorialspoint"
	]
}
{
	"_id" : ObjectId("5dd7d111f1dd4583e7103fe2"),
	"post_text" : "enjoy the mongodb articles on tutorialspoint",
	"tags" : [
		"mongodb",
		"tutorialspoint"
	]
}
>

Permintaan yang sama juga dapat ditulis sebagai -

>db.posts.find({post_text:/tutorialspoint/})

Menggunakan Ekspresi regex dengan Case Insensitive

Untuk membuat case pencarian tidak sensitif, kami menggunakan parameter $options dengan nilai $i. Perintah berikut akan mencari string yang memiliki kata tutorialspoint, terlepas dari huruf kecil atau huruf kapital −

>db.posts.find({post_text:{$regex:"tutorialspoint",$options:"$i"}})

Salah satu hasil yang dikembalikan dari kueri ini adalah dokumen berikut yang berisi kata tutorialspoint dalam berbagai kasus −

{
   "_id" : ObjectId("53493d37d852429c10000004"),
   "post_text" : "hey! this is my post on TutorialsPoint", 
   "tags" : [ "tutorialspoint" ]
}

Menggunakan regex untuk Elemen Array

Kita juga bisa menggunakan konsep regex pada field array. Ini khususnya sangat penting saat kami menerapkan fungsi tag. Jadi, jika Anda ingin mencari semua posting yang memiliki tag yang dimulai dari kata tutorial (baik tutorial atau tutorial atau tutorialspoint atau tutorial php), Anda dapat menggunakan kode berikut −

>db.posts.find({tags:{$regex:"tutorial"}})

Mengoptimalkan Kueri Ekspresi Reguler

Jika bidang dokumen diindeks, kueri akan menggunakan manfaatkan nilai yang diindeks agar cocok dengan ekspresi reguler. Ini membuat pencarian menjadi sangat cepat dibandingkan dengan ekspresi reguler yang memindai seluruh koleksi
Jika ekspresi reguler adalah ekspresi awalan, semua kecocokan dimaksudkan untuk dimulai dengan karakter string tertentu. Untuk e. g. , jika ekspresi regex adalah ^tut, maka kueri harus mencari hanya string yang dimulai dengan tut

Kecuali beberapa operator dasar ($and, $or, $lt, $gt, dll. ), sebelum MongoDB 3. 6 Anda hanya dapat menggunakan beberapa operator ekspresi canggih pada hasil kueri melalui saluran agregasi. Dalam praktiknya, ini berarti bahwa MongoDB. kueri find() tidak dapat memanfaatkan banyak fitur server yang kuat
Dalam 3. 6 ke atas, dukungan untuk operator kueri baru bernama ““ telah ditambahkan ke MongoDB. operasi find(). Ini memungkinkan kueri memanfaatkan operator yang tidak tersedia yang sebelumnya hanya tersedia dalam agregasi
Pengguna yang terbiasa dengan kerangka kerja agregasi akan mengingat bahwa ekspresi/kondisi dalam agregasi dievaluasi berdasarkan per dokumen. Agregasi memungkinkan bidang dokumen untuk digunakan sebagai variabel dalam persyaratan (dengan mengawali nama bidang dengan tanda dolar). Yang baru. find() $expr operator menambahkan fleksibilitas dan kekuatan yang sama ke. find(), dan mungkin yang lebih penting dalam artikel ini. . findAndModify() perintah
Saya berharap dapat menunjukkan bagaimana fungsionalitas baru ini menciptakan beberapa alur kerja aplikasi yang sangat kuat dan efisien di MongoDB
Aplikasi Contoh Kami
Dalam contoh ini, anggaplah kita sedang merancang aplikasi inventaris toko berdasarkan MongoDB. Antara lain, salah satu fungsi utama aplikasi inventaris toko adalah untuk memperbarui item saat dijual. Pada artikel ini, kami akan fokus pada tindakan ini saja
Setiap item dalam sistem inventaris disimpan dalam satu dokumen MongoDB yang berisi
1. “itemId” numerik
2. String "nama".
3. Berapa kali barang telah terjual ("terjual")
4. Total persediaan yang tersedia (“total”). Yang penting, setiap item mungkin memiliki persediaan total berbeda yang tersedia
Contoh dokumen koleksi "item".
JavaScript
1
2
3
4
5
6
7
8
> db. item. findOne()
{
"_id" . ObjectId("5a85d32f8a734d82e8bcb5b5"),
"itemId" . 123456,
"nama" . "barang yang sangat keren",
"total" . 10,
"terjual" . 0
}
Beberapa harapan tambahan adalah
1. Saat aplikasi memanggil alur kerja "barang terjual" jika semua barang terjual dokumen kosong (atau "null") harus dikembalikan ke aplikasi
2. Jika barang masih tersedia, jumlah barang yang terjual harus ditambah dan dokumen yang diperbarui dikembalikan ke aplikasi
Pra-3. 6. Contoh 1
Sebelum 3. 6, cara umum untuk menangani alur kerja "barang terjual" aplikasi contoh kami adalah dengan menggunakan a. operasi findAndModify(). SEBUAH. findAndModify() melakukan persis seperti yang disarankan. menemukan dokumen dan memodifikasi dokumen yang cocok dengan cara yang Anda tentukan
Dalam contoh ini, kami. operasi findAndModify() harus berisi kueri untuk "itemId" persis yang kami jual dan dokumen yang diperbarui untuk memberi tahu MongoDB untuk menambah jumlah item yang terjual selama kueri
Secara default,. findAndModify() mengembalikan dokumen SEBELUM modifikasi/pembaruan dilakukan. Dalam contoh kami, kami menginginkan hasil dari SETELAH pembaruan, jadi kami juga akan menambahkan opsi boolean "baru" (disetel ke benar) untuk mengembalikan dokumen yang diperbarui
Di shell MongoDB ini. operasi findAndModify() untuk “itemId” 123456 akan terlihat seperti ini
JavaScript
1
2
3
4
5
db. item. temukanDanModifikasi({
  kueri. { itemId. 123456 },
  perbarui. { $termasuk. { terjual. 1 } },
  baru. benar
})
Tapi ada masalah. “itemId” 123456 hanya memiliki sepuluh item yang tersedia
JavaScript
1
2
3
4
5
> db. item. temukan(
    { itemId. 123456 },
    { _id. 0, total. 1 }
  )
{ "total" . 10 }
Bagaimana jika kita menjalankan ini. findAndModify() lebih dari 10 kali?
Di sini kita dapat melihat setelah menjalankan kueri sebanyak 11 kali, jumlah 11 "terjual" kita salah
JavaScript
1
2
3
4
5
> db. item. temukan(
    { itemId. 123456 },
    { _id. 0, terjual. 1 }
  )
{ "terjual" . 11 }
Jika SEMUA item dalam sistem inventaris memiliki total 10 item, ini akan sangat sederhana; . operasi findAndModify() hanya dapat dimodifikasi untuk mempertimbangkan bahwa "dijual" harus kurang dari ($lt) 10
JavaScript
1
2
3
4
5
6
7
8
9
10
db. item. temukanDanModifikasi({
  kueri. {
    itemId. 123456,
    terjual. { $lt. 10 }
  },
  perbarui. {
    $termasuk. { terjual. 1 }
  },
  baru. benar
})
Tapi ini juga tidak cukup baik
Dalam contoh kami, setiap dokumen memiliki jumlah "total" dan "terjual" sendiri. Kami tidak dapat mengandalkan setiap item yang memiliki sepuluh item yang tersedia, setiap item mungkin memiliki "total" yang berbeda
Pra-3. 6. Contoh #2
Di pra-3. 6 dunia, tidak ada terlalu banyak cara untuk mengatasi masalah yang kami temukan dalam pendekatan pertama kami, selain memecah logika database menjadi dua panggilan berbeda dan membuat aplikasi menjalankan beberapa logika pada hasil di tengah. Mari kita coba sekarang
Inilah yang akan terlihat seperti alur kerja "barang terjual" baru ini
1. SEBUAH. find() kueri untuk mengambil dokumen yang diperlukan, berdasarkan "itemId"
  JavaScript
  1
  2
  3
  4
  > db. item. temukan(
  { itemId. 123456 }
  )
  { . . . }
2. Aplikasi menganalisis dokumen hasil dan memeriksa apakah bidang "terjual" lebih besar dari "total"
3. Jika ada item yang tersedia an. operasi update() dijalankan untuk menambah nomor "terjual" untuk item tersebut. Dokumen yang diperbarui dikembalikan oleh aplikasi
  JavaScript
  1
  2
  3
  4
  5
  > db. item. perbarui({
      { itemId. 123456 },
      { $termasuk. { terjual. 1 } }
    })
  { . . . }
Selain kompleksitas kode yang meningkat, ada beberapa masalah dengan pendekatan ini yang mungkin tidak terlihat jelas
1. Atomisitas. Satu operasi MongoDB bersifat atomik pada satu tingkat dokumen. Dengan kata lain, jika dua operasi memperbarui dokumen, salah satu operasi harus menunggu. Dalam situasi di "Contoh #1", di mana kueri DAN peningkatan dokumen kami terjadi dalam operasi yang sama, kami dapat merasa aman mengetahui bahwa jumlah "terjual" dan "total" kami diperbarui secara atomik. Sayangnya, dalam pendekatan baru kami, kami telah memecah kueri dan memperbarui menjadi 2x panggilan basis data terpisah. Artinya, operasi ini tidak sepenuhnya atomik dan rentan terhadap kondisi balapan. Jika banyak sesi menjalankan logika ini pada saat yang sama, sesi lain mungkin menambahkan penghitung antara operasi database pertama dan kedua Anda
2. Beberapa Operasi. Di mesin penyimpanan seperti WiredTiger dan RocksDB, operasi menunggu dalam antrean saat sistem sedang sibuk. Dalam pendekatan baru kami, kami harus menunggu untuk memasuki mesin penyimpanan dua kali. Di bawah beban yang serius, hal ini dapat menciptakan hambatan yang berjenjang dalam arsitektur Anda. Ini dapat menyebabkan server aplikasi terhenti dan operasi backlog sejalan dengan database yang kewalahan. Pendekatan yang paling efisien adalah melakukan kueri dan peningkatan dalam satu operasi
3. Inefisiensi Jaringan. Melakukan dua perintah basis data membutuhkan dua kali lipat overhead serialisasi dan waktu pulang pergi jaringan. Ada juga peningkatan kecil dalam penggunaan bandwidth yang diperlukan
Pasca-3. 6. Contoh #3
Dalam contoh ketiga ini, mari gunakan yang baru yang ditambahkan di 3. 6 untuk membuat alur kerja ini seefisien mungkin. Perhatikan bahwa pendekatan dalam contoh ini hanya berfungsi pada MongoDB 3. 6 atau Server Percona yang akan datang untuk MongoDB 3. 6 (atau lebih besar)
Expression Query Operator memungkinkan operator yang kuat untuk digunakan pada dokumen hasil reguler. find() kueri. Bagaimana?
Dalam pendekatan baru kita, kita hanya perlu menggunakan satu operator dasar dalam ekspresi kita. $lt (mis. kurang dari). Operator $lt digunakan dalam ekspresi kami untuk memeriksa apakah bidang "terjual" kami kurang dari bidang "total". Dengan menggunakan $lt di bawah operator baru, kita dapat membuat server MongoDB membandingkan "terjual" vs. jumlah "total" dari item yang kami kueri dan hanya mengembalikan dan menambah dokumen jika ekspresinya benar, semuanya dalam satu operasi sisi server atomik.
Inilah tampilan kueri kami yang ditingkatkan
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
db. item. temukanDanModifikasi({
  kueri. {
    itemId. 123456,
    $expr. {
      $lt. [
        "$terjual",
        "$total"
      ]
    }
  },
  perbarui. {
    $termasuk. { terjual. 1 }
  },
  baru. benar
})
Perhatikan bidang $lt "sold" dan "total" diawali dengan tanda dolar ($). Ini memberi tahu agregasi untuk menggunakan nilai sebenarnya dari setiap dokumen yang cocok dalam perbandingan kurang dari secara dinamis. Ini menyelesaikan masalah yang kami temui sebelumnya, dan sekarang kueri ini hanya berhasil jika ada item yang tersedia (“terjual” kurang dari “total). Ini secara efisien mendorong logika ke database
ItemId. 123456 memiliki nilai "total" 10. Jika kita menjalankan. findAndModify() 10 kali, kami mendapatkan hasil ini
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
> db. item. temukanDanModifikasi({
   kueri. {
     itemId. 123456,
     $expr. {
       $lt. [
         "$terjual",
         "$total"
       ]
     }
   },
   perbarui. {
     $inc. { terjual. 1 }
   },
   baru. benar
})
{
"_id" . ObjectId("5a85d32f8a734d82e8bcb5b5"),
"itemId" . 123456,
"nama" . "barang yang sangat keren",
"total" . 10,
"terjual" . 10
}
Sepuluh terjual, total sepuluh. Besar
Jika kami menjalankan kueri yang sama sekali lagi, kami menerima "null"
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
db. item. temukanDanModifikasi({
   kueri. {
     itemId. 123456,
     $expr. {
       $lt. [
         "$terjual",
         "$total"
       ]
     }
   },
   perbarui. {
     $inc. { terjual. 1 }
   },
   baru. benar
})
batal
Sempurna. Sebuah null dikembalikan karena kondisi $lt kita di operator $expr kita tidak berhasil, seperti yang kita inginkan
Mari kita pastikan TIDAK ada kenaikan ke-11, masalah yang kita alami pada contoh pertama kita
JavaScript
1
2
3
4
5
> db. item. temukan(
    { itemId. 123456 },
    { _id. 0, terjual. 1 }
  )
{ "terjual" . 10 }
Di sini kita dapat melihat kenaikan ke-11 tidak berjalan karena $expr gagal lulus. 10 dari 10 item terjual. ini keren sekali
Kesimpulan
Di sini kita bisa melihat kombinasi dari dua fitur server yang ada (. findAndModify() dan bidang dokumen sebagai variabel dalam agregasi) dan MongoDB 3 baru. Operator kueri ekspresi 6 $expr telah memecahkan banyak masalah dengan alur kerja data yang sebelumnya tidak efisien dan berpotensi berbahaya
Lebih lanjut tentang $expr dapat ditemukan di sini.
Kombinasi fungsionalitas ini mampu memberikan atomisitas kueri kami di "Contoh #1" dengan pemeriksaan logika aman yang dilakukan di "Contoh #2". Hasil akhirnya efisien DAN aman
Artikel ini menunjukkan bahwa meskipun setiap komponen fungsionalitas MongoDB kuat dengan sendirinya, fitur-fiturnya bisa menjadi lebih kuat ketika mereka bekerja sama. Dalam hal ini, dengan bantuan merek baru 3. 6 fitur. Kombinasi fitur hebat apa yang Anda lewatkan?

Manakah ekspresi agregasi yang digunakan dalam MongoDB?

$cocok . Digunakan untuk memfilter dokumen dapat mengurangi jumlah dokumen yang diberikan sebagai input ke tahap selanjutnya. $proyek. Ini digunakan untuk memilih beberapa bidang tertentu dari koleksi. $grup. Ini digunakan untuk mengelompokkan dokumen berdasarkan beberapa nilai. $sort. Ini digunakan untuk mengurutkan dokumen yang mengatur ulang mereka.

Mengapa kita menggunakan $$ di MongoDB?

$ dirujuk ke bidang dokumen root sedangkan $$ dirujuk ke nama variabel . Di sini '$data' adalah kolom array dokumen dan $$currentData adalah variabel yang diambil dalam ekspresi as dari agregasi $map.

Apa itu $$ root di MongoDB?

Variabel $$ROOT berisi dokumen sumber untuk grup . Jika Anda hanya ingin meneruskannya tanpa dimodifikasi, Anda dapat melakukan ini dengan $mendorong $$ROOT ke dalam output dari grup.

Bagaimana cara menanyakan banyak nilai di MongoDB?

MongoDB menyediakan find() yang digunakan untuk menemukan banyak nilai atau dokumen dari koleksi. Metode find() mengembalikan kursor dari kumpulan hasil dan mencetak semua dokumen. Untuk menemukan beberapa nilai, kita dapat menggunakan operasi agregasi yang disediakan oleh MongoDB sendiri .