Indonesian (Bahasa Indonesia) translation by Keti Pritania (you can also view the original English article)

Siap untuk terus belajar tentang MongoDB, salah satu teknologi paling keren untuk web developer? Dalam kedua ini bagian dari seri, kita beralih dari dasar-dasar, lanjutan query - dengan operator bersyarat - dan MapReduce.

Melangkah melampaui dasar-dasar

Sebelumnya, kita membahas dasar-dasar dan bagaimana untuk memulai dengan mongoDB, salah satu yang terbaik berkembang biak dari implementasi NoSQL. Kami memandang cara menginstalnya, membuat database dasar dan kemudian melakukan operasi dasar di atasnya:

Cari
Update
Hapus

Selain itu, kita mulai melihat bagaimana untuk mulai berinteraksi dengan mongoDB dalam cara yang lebih kuat, melalui penggunaan penyeleksi. Penyeleksi memberikan kita kemampuan untuk memiliki kendali jauh lebih baik dan untuk menggali cukup dalam untuk menemukan data yang kita inginkan.

Nah, itu semua baik dan bagus untuk memulai dengan, tetapi ketika Anda ingin menulis aplikasi betulan, Anda perlu untuk pergi lebih jauh. Yah, hal ini masih mendapatkan seri dimulai setelah semua, tapi saya ingin membuat Anda bersemangat tentang kemungkinan bekerja dalam cara yang berorientasi dokumen. Saya ingin bergairah Anda untuk mengambil teknologi ini besar dan membuat Anda sendiri dan menggunakannya sebagai kuat sebanyak yang Anda bisa untuk membuat aplikasi fantastis.

Hari ini, kita akan memperluas pada permintaan dari terakhir kali dan belajar dua aspek kunci dari mongoDB:

Pertanyaan lanjutan
MapReduce

Pertanyaan lanjutan

Sebelumnya kita melihat pertanyaan dasar dan diperkenalkan ke penyeleksi. Sekarang kita akan masuk ke pertanyaan yang lebih maju, dengan membangun pekerjaan sebelumnya dalam dua cara utama:

Operator bersyarat
Kalimat biasa

Masing-masing berturut-turut menyediakan kami dengan lebih berbutir halus kontrol atas permintaan kita dapat menulis dan, akibatnya, informasi yang kami dapat mengekstrak dari database mongoDB kami.

Operator bersyarat

Operator bersyarat yang, seperti namanya, operator untuk query koleksi yang memperbaiki kondisi yang query harus cocok ketika mengekstrak data dari database. Ada sejumlah mereka, tetapi hari ini saya akan fokus pada orang-orang kunci 9. Ini adalah:

$lt – nilai harus kurang dari bersyarat
$gt – nilai harus lebih besar dari bersyarat
$lte - nilai harus kurang dari atau sama dengan persyaratan
$gte – nilai harus lebih besar dari atau sama dengan bersyarat
$in – nilai harus di set conditional
$nin – nilai tidak harus di set conditional
$not – nilai harus setara dengan bersyarat

Mari kita lihat satu per satu. Buka terminal Anda dan bersiap-siap untuk menggunakan database asli dari bagian pertama dalam seri ini (pra-modifikasi). Untuk membuat tutorial ini lebih mudah, kita akan membuat sedikit perubahan ke database. Kami akan memberikan setiap dokumen dalam koleksi kami atribut usia. Untuk melakukannya, jalankan kueri modifikasi berikut:


  		db.nettuts.update({"_id" : ObjectId("4ef224be0fec2806da6e9b27")}, {"$set" : {"age" : 18 }});
			db.nettuts.update({"_id" : ObjectId("4ef224bf0fec2806da6e9b28")}, {"$set" : {"age" : 45 }});
			db.nettuts.update({"_id" : ObjectId("4ef224bf0fec2806da6e9b29")}, {"$set" : {"age" : 65 }});
			db.nettuts.update({"_id" : ObjectId("4ef224bf0fec2806da6e9b2a")}, {"$set" : {"age" : 43 }});
			db.nettuts.update({"_id" : ObjectId("4ef224bf0fec2806da6e9b2b")}, {"$set" : {"age" : 22 }});
			db.nettuts.update({"_id" : ObjectId("4ef224bf0fec2806da6e9b2c")}, {"$set" : {"age" : 45 }});
			db.nettuts.update({"_id" : ObjectId("4ef224bf0fec2806da6e9b2d")}, {"$set" : {"age" : 33 }});

Semua yang baik, Anda dapat menjalankan 'menemukan semua' dan Anda akan memiliki output berikut:


		db.nettuts.find();                                                                          
		{ "_id" : ObjectId("4ef224be0fec2806da6e9b27"), "age" : 18, "dob" : "21/04/1978", "first" : "matthew", "gender" : "m", "hair_colour" : "brown", "last" : "setter", "nationality" : "australian", "occupation" : "developer" }
		{ "_id" : ObjectId("4ef224bf0fec2806da6e9b28"), "age" : 45, "dob" : "26/03/1940", "first" : "james", "gender" : "m", "hair_colour" : "brown", "last" : "caan", "nationality" : "american", "occupation" : "actor" }
		{ "_id" : ObjectId("4ef224bf0fec2806da6e9b29"), "age" : 65, "dob" : "03/06/1925", "first" : "arnold", "gender" : "m", "hair_colour" : "brown", "last" : "schwarzenegger", "nationality" : "american", "occupation" : "actor" }
		{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2a"), "age" : 43, "dob" : "21/04/1978", "first" : "tony", "gender" : "m", "hair_colour" : "brown", "last" : "curtis", "nationality" : "american", "occupation" : "developer" }
		{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2b"), "age" : 22, "dob" : "22/11/1958", "first" : "jamie lee", "gender" : "f", "hair_colour" : "brown", "last" : "curtis", "nationality" : "american", "occupation" : "actor" }
		{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2c"), "age" : 45, "dob" : "14/03/1933", "first" : "michael", "gender" : "m", "hair_colour" : "brown", "last" : "caine", "nationality" : "english", "occupation" : "actor" }
		{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2d"), "age" : 33, "dob" : "09/12/1934", "first" : "judi", "gender" : "f", "hair_colour" : "white", "last" : "dench", "nationality" : "english", "occupation" : "actress" }

$lt/$lte

Sekarang mari kita Cari semua aktor yang kurang dari 40. Untuk melakukan itu, menjalankan query berikut:

1
2	db.nettuts.find( { "age" : { "$lt" : 40 } } );

Setelah menjalankan kueri tersebut, Anda akan melihat output berikut:

1
2	{ "_id" : ObjectId("4ef224be0fec2806da6e9b27"), "age" : 18, "dob" : "21/04/1978", "first" : "matthew", "gender" : "m", "hair_colour" : "brown", "last" : "setter", "nationality" : "australian", "occupation" : "developer" }
3	{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2b"), "age" : 22, "dob" : "22/11/1958", "first" : "jamie lee", "gender" : "f", "hair_colour" : "brown", "last" : "curtis", "nationality" : "american", "occupation" : "actor" }
4	{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2d"), "age" : 33, "dob" : "09/12/1934", "first" : "judi", "gender" : "f", "hair_colour" : "white", "last" : "dench", "nationality" : "english", "occupation" : "actress" }

Bagaimana dengan mereka yang kurang dari 40 inklusif? Menjalankan query berikut untuk kembali bahwa hasil:

1
2	db.nettuts.find( { "age" : { "$lte" : 40 } } );

Ini menghasilkan daftar berikut:

1
2	{ "_id" : ObjectId("4ef224be0fec2806da6e9b27"), "age" : 18, "dob" : "21/04/1978", "first" : "matthew", "gender" : "m", "hair_colour" : "brown", "last" : "setter", "nationality" : "australian", "occupation" : "developer" }
3	{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2b"), "age" : 22, "dob" : "22/11/1958", "first" : "jamie lee", "gender" : "f", "hair_colour" : "brown", "last" : "curtis", "nationality" : "american", "occupation" : "actor" }
4	{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2d"), "age" : 33, "dob" : "09/12/1934", "first" : "judi", "gender" : "f", "hair_colour" : "white", "last" : "dench", "nationality" : "english", "occupation" : "actress" }

$gt/$gte

Sekarang mari kita Cari semua aktor yang lebih tua dari 47. Menjalankan query berikut untuk menemukan daftar:

1
2	db.nettuts.find( { 'age' : { '$gt' : 47 } } );

Anda akan mendapatkan hasil sebagai berikut:

		{ "_id" : ObjectId("4ef224bf0fec2806da6e9b29"), "age" : 65, "dob" : "03/06/1925", "first" : "arnold", "gender" : "m", "hair_colour" : "brown", "last" : "schwarzenegger", "nationality" : "american", "occupation" : "actor" }

Apa tentang termasuk 40?

1
2	db.nettuts.find( { 'age' : { '$gte' : 47 } } );

Seperti ada hanya satu orang lebih dari 47, data kembali tidak berubah.

$dalam / $nin

Bagaimana menemukan informasi berdasarkan daftar kriteria? Ini yang pertama sudah ok, tapi bisa dibilang, cukup sepele. Sekarang mari kita lihat untuk melihat mana dari orang-orang yang kita adalah aktor atau pengembang. Dengan query berikut, kita akan menemukan yang (untuk membuatnya sedikit lebih mudah untuk membaca, kita sudah terbatas kunci yang dikembalikan ke nama hanya pertama dan terakhir):

1
2	db.nettuts.find( { 'occupation' : { '$in' : [ "actor", "developer" ] } }, { "first" : 1, "last" : 1 } );

Query ini, menghasilkan output berikut:


			{ "_id" : ObjectId("4ef224be0fec2806da6e9b27"), "first" : "matthew", "last" : "setter" }
			{ "_id" : ObjectId("4ef224bf0fec2806da6e9b28"), "first" : "james", "last" : "caan" }
			{ "_id" : ObjectId("4ef224bf0fec2806da6e9b29"), "first" : "arnold", "last" : "schwarzenegger" }
			{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2a"), "first" : "tony", "last" : "curtis" }
			{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2b"), "first" : "jamie lee", "last" : "curtis" }
			{ "_id" : ObjectId("4ef224bf0fec2806da6e9b2c"), "first" : "michael", "last" : "caine" }

Anda dapat melihat bahwa kita bisa mendapatkan kebalikan dari ini dengan menggunakan $ninjust sebagai hanya.

Mari kita membuat ini sedikit lebih menyenangkan dan menggabungkan beberapa operator. Mari kita mengatakan bahwa kita ingin mencari semua orang, yang baik laki-laki atau pengembang, mereka kurang dari 40 tahun.

Nah, itu sedikit seteguk, tetapi dengan operator bahwa kami telah digunakan sejauh ini-cukup mudah dicapai. Mari kita selesaikan dan Anda akan lihat. Silahkan lihat pada pertanyaan di bawah ini:

1
2	db.nettuts.find( { $or : [ { "gender" : "m", "occupation" : "developer" } ], "age" : { "$gt" : 40 } }, { "first" : 1, "last" : 1, "occupation" : 1, "dob" : 1 } );

Anda dapat melihat bahwa kita telah ditetapkan bahwa kedua jenis kelamin dapat laki-laki atau pendudukan dapat seorang pengembang dalam kondisi $or dan kemudian ditambahkan dan kondisi dari zaman yang lebih besar dari 4.

Untuk itu, kita mendapatkan hasil sebagai berikut:

			{ "_id" : ObjectId("4ef22e522893ba6797bf8cb6"), "first" : "matthew", "last" : "setter", "dob" : "21/04/1978", "occupation" : "developer" }

			{ "_id" : ObjectId("4ef22e522893ba6797bf8cb9"), "first" : "tony", "last" : "curtis", "dob" : "21/04/1978", "occupation" : "developer" }

Ekspresi Reguler

Sekarang saya yakin bahwa Anda tidak akan puas dengan hal ini. Saya melakukan menjanjikan Anda beberapa kompleksitas dan canggih. Jadi mari kita masuk ke menggunakan beberapa string biasa. Katakanlah kita ingin menemukan pengguna yang memiliki nama depan dimulai dengan 'ma' atau 'ke' dan siapa nama belakang dimulai dengan 'se' atau 'de'. Bagaimana kita akan melakukannya?

Telah melihat query berikut menggunakan ekspresi reguler:

1
2	db.nettuts.find( { "first" : /(ma\|to)*/i, "last" : /(se\|de)/i } );

Mengingat, hasilnya akan:

		{ "_id" : ObjectId("4ef22e522893ba6797bf8cb6"), "first" : "matthew", "last" : "setter", "dob" : "21/04/1978", "gender" : "m", "hair_colour" : "brown", "occupation" : "developer", "nationality" : "australian" }

		{ "_id" : ObjectId("4ef22e532893ba6797bf8cbc"), "first" : "judi", "last" : "dench", "dob" : "09/12/1934", "gender" : "f", "hair_colour" : "white", "occupation" : "actress", "nationality" : "english" }

Mari kita lihat pertanyaan itu sedikit lebih dekat. Pertama, kita sedang melakukan regex pada nama pertama.

1
2	"first" : /(ma\|to)*/i

saya menunjukkan bahwa kita sedang melakukan regex case-sensitive.

(ma | untuk) * menunjukkan bahwa awal string nama pertama harus baik 'ma' atau 'untuk'.

Jika Anda tidak terbiasa, * pada akhirnya, akan cocok dengan apa pun setelah itu. Jadi ketika Anda memasukkannya bersama-sama, kami mencocokkan nama pertama yang memiliki baik 'ma' atau 'untuk' pada awal mereka. Dalam regex untuk nama terakhir, Anda dapat melihat bahwa kita telah melakukan hal yang sama, tetapi untuk nama terakhir.

Tidak yakin? Mari kita coba yang lain. Bagaimana menggabungkan dengan salah satu operator bersyarat. Katakanlah kita ingin menemukan semua orang dengan nama depan james atau jamie yang merupakan aktor wanita Amerika. Bagaimana kita akan melakukannya? Baiklah, mari kita lihat bagaimana kita melakukannya di bawah ini:

1
2	db.nettuts.find( { "first" : /(jam?e)/i, "gender" : "f", "occupation" : "actor", "nationality" : "american" } );

Regex di atas akan cocok kombinasi seperti: james, jamie, jamee dll. Tanda tanya akan cocok dengan satu karakter, apakah a-z, A-Z atau 0-9. Kemudian, seperti sebelumnya, * cocok apa pun yang muncul setelah 'e'. Dari sana, kami menggunakan operator bersyarat dari sebelumnya untuk lebih membatasi hasil yang datang kembali. Perlu dicatat bahwa karena kita menggunakan operator case-sensitive, saya, pertanyaan tidak akan menggunakan indeks. Tetapi untuk keperluan contoh ini, tidak masalah.

Output dari pertanyaan di atas adalah:

		{ "_id" : ObjectId("4ef22e522893ba6797bf8cba"), "first" : "jamie lee", "last" : "curtis", "dob" : "22/11/1958", "gender" : "f", "hair_colour" : "brown", "occupation" : "actor", "nationality" : "american" }

MapReduce

MapReduce adalah big daddy analisis data. Dalam kasus Anda tidak pernah mendengar itu, MapReduce adalah proses di mana agregasi data dapat berpisah dan bertani di cluster komputer untuk mengurangi waktu yang dibutuhkan untuk menentukan hasil agregat pada set data.

Hal ini terdiri dari dua bagian: peta dan mengurangi. Peta menciptakan pekerjaan yang kemudian dapat dipindahkan ke node pekerja untuk menjalankan komponen Reduce. Mengurangi kemudian menghitung jawaban untuk yang sepotong kerja yang adalah bertani untuk itu dan mengembalikan hasil yang dapat dikombinasikan dengan potongan-potongan lainnya untuk membentuk jawaban akhir.

Jika Anda ingin sebuah deskripsi yang lebih spesifik, inilah yang Wikipedia mengatakan tentang hal ini:

MapReduce adalah kerangka untuk memproses masalah sangat didistribusikan di seluruh Dataset besar yang menggunakan sejumlah besar komputer (node), secara kolektif disebut sebagai sebuah cluster (jika semua node menggunakan hardware yang sama) atau grid (jika node menggunakan hardware yang berbeda). Pemrosesan komputasi dapat terjadi pada data yang disimpan baik dalam sistem file (tidak terstruktur) atau dalam database (terstruktur).

"Peta" langkah: master node membutuhkan input, partisi ini ke masalah sub yang lebih kecil, dan mendistribusikan mereka pekerja node. Sebuah node pekerja dapat melakukan ini lagi pada gilirannya, menyebabkan struktur multi-level pohon. Node pekerja memproses masalah yang lebih kecil, dan meneruskan jawabannya kembali ke node masternya.

"Mengurangi" langkah: master node kemudian mengumpulkan jawaban untuk semua masalah sub dan menggabungkan mereka dalam beberapa cara untuk membentuk output-jawaban untuk masalah yang awalnya berusaha untuk memecahkan.

Contoh MapReduce

Mari kita lihat sebuah contoh sederhana. Kami akan menganalisis dataset sederhana kami dan menemukan jumlah total semua wanita dalam grup. Diakui, ini adalah contoh yang sangat sederhana, tapi itu akan meletakkan dasar bagi pemahaman, praktis, bagaimana MapReduce bekerja.

Peta fungsi

Di sini, kita akan menciptakan sebuah peta fungsi yang mengumpulkan informasi dalam dataset kami oleh jenis kelamin orang dan memancarkan jumlah 1 untuk setiap satu dari mereka.

1
2	var map = function() {
3	emit( { gender: this.gender }, { count: 1 } );
4	}

Ini akan mengembalikan output yang mirip dengan berikut:

1
2	{ 'f' : 1 }

Mengurangi fungsi

Fungsi mengurangi kami akan mengambil output dari fungsi peta dan menggunakannya untuk menjaga berjalan total menghitung untuk setiap gender. Silahkan lihat pada mengurangi fungsi di bawah ini.


			var reduce = function(key, values) {
			    var result = { count : 0 };
    
			    values.forEach(function(value){
			        result.count += value.count;
			    })
    
			    return result;
			}

Menjalankan MapReduce

Sekarang, kita menyatukannya dengan memanggil fungsi mapReduce di basis data kita saat ini. Kami lulus dalam peta dan mengurangi variabel yang kita buat sebelumnya dengan menelepon peta kami dan mengurangi fungsi dan Tentukan nama koleksi yang hasilnya akan disimpan dalam; dalam hal ini 'gender'. Hanya untuk mengulangi, hasil memanggil fungsi mapReduce adalah kumpulan dalam database kami saat ini; bahwa kita bisa iterate atas seperti kita akan setiap koleksi lainnya. Silahkan lihat kode di bawah:

1
2	var res = db.nettuts.mapReduce( map, reduce, { out : 'gender' } );

Menampilkan output

Ketika peta-mengurangi selesai, kita dapat mengaksesnya seperti koleksi yang normal, dengan menjalankan findfunction di atasnya seperti yang kita lakukan di bawah ini.

1
2	db.gender.find();
3	{ "_id" : { "gender" : "f" }, "value" : { "count" : 2 } }
4	{ "_id" : { "gender" : "m" }, "value" : { "count" : 5 } }

Di sini, kami sekarang memiliki total berjalan per jenis kelamin; 2 untuk wanita dan 5 untuk pria - yang berkorelasi dengan dataset kami. Tapi bagaimana jika kita ingin menyaring oleh perempuan dalam kelompok. Yah, tidak banyak untuk itu. Kita hanya perlu membuat penggunaan klausa query untuk memungkinkan kita untuk melakukannya. Beruntung bagi kita, itu akan terlihat akrab. Silahkan lihat pada pertanyaan di bawah ini.

1
2	var res = db.nettuts.mapReduce( map, reduce, { out : 'gender', query : { "gender" : "f" } } );

Sekarang, ketika kita menampilkan output, itu akan terlihat seperti di bawah ini:

1
2	db.gender.find();
3	{ "_id" : { "gender" : "f" }, "value" : { "count" : 2 } }

Ada sejumlah parameter lain bahwa Anda dapat melewati ke fungsi mapReduce untuk lebih lanjut menyesuaikan output.

sort - semacam output kembali
limit - batas jumlah hasil
out - nama koleksi untuk menyimpan hasilnya di
finalise - menetapkan fungsi untuk menjalankan setelah proses pengurangan lengkap
scope - menetapkan variabel yang dapat digunakan dalam peta, mengurangi dan menyelesaikan fungsi lingkup
jsMode - menghindari langkah perantara (antara peta dan mengurangi) mengkonversi ke JSON format
verbose - melacak statistik tentang proses eksekusi

Berliku

Ini telah cakupan angin puyuh beberapa topik yang lebih kompleks dari mongoDB. Tapi aku berharap bahwa itu telah memberi Anda bahkan lebih banyak rasa dari apa yang mungkin dengan menggunakan alat yang besar ini.

Kita telah melihat bersyarat operator: $lt, $gt, $lte, $gte, $in, $nin, $not dan jalankan melalui pengenalan MapReduce. Saya berharap bahwa Anda telah mendapat banyak dari ini dan akan belajar lebih lanjut tentang alat yang hebat yang mongoDB.

Memulai dengan MongoDB - Bagian 2