Database NoSQL telah muncul pesat dalam beberapa tahun terakhir karena struktur mereka kurang dibatasi, desain skema scalable, dan akses yang lebih cepat dibandingkan dengan database relasional tradisional (RDBMS / SQL).  MongoDB merupakan database NoSQL open source yang berorientasi dokumen  yang menyimpan data dalam bentuk objek JSON seperti. Ini telah muncul sebagai salah satu database terkemuka karena skema yang dinamis, skalabilitas tinggi, performa query yang optimal, mengindeks lebih cepat dan komunitas pengguna yang aktif.

Jika Anda berasal dari sebuah latar belakang RDBMS/SQL, pemahaman konsep NoSQL dan MongoDB  dapat sedikit sulit saat mulai karena kedua teknologi memiliki cara yang sangat berbeda dari representasi data. Artikel ini akan mendorong Anda untuk memahami bagaimana domain RDBMS / SQL , fungsinya, persyaratan dan bahasa query yang dipetakan database MongoDB. Dengan pemetaan, berarti bahwa jika kita memiliki sebuah konsep dalam RDBMS / SQL, kita akan melihat apa konsep yang ekuivalen dalam MongoDB.

Kita akan mulai dengan pemetaan konsep relasional dasar seperti tabel, baris, kolom, dll dan bergerak untuk membahas pengindeksan dan join. Kami kemudian akan memeriksa query SQL dan mendiskusikan sesuai query database MongoDB mereka. Artikel ini mengasumsikan bahwa Anda memahami konsep database relasional dasar dan SQL, karena seluruh artikel lebih banyak menekankan pada pemahaman bagaimana konsep-konsep ini dipetakan di MongoDB. Mari kita mulai.

Memetakan Tables, Rows dan Columns

Setiap database MongoDB terdiri dari koleksi yang setara dengan database RDBMS yang terdiri dari tabel SQL. Setiap collection menyimpan data dalam bentuk dokumen yang setara dengan tabel yang menyimpan data dalam baris. Sementara row menyimpan data di dalam kumpulan kolom, dokumen memiliki struktur seperti JSON (dikenal sebagai BSON di MongoDB). Terakhir, cara kita memiliki baris/rows di baris SQL, kita memiliki fields di MongoDB. Berikut adalah contoh dari sebuah dokumen (baca row) yang memiliki beberapa fields (baca columns) menyimpan data pengguna:

{
  "_id": ObjectId("5146bb52d8524270060001f3"),
  "age": 25,
  "city": "Los Angeles",
  "email": "mark@abc.com<script type="text/javascript">
  /* <![CDATA[ */
  (function(){try{var s,a,i,j,r,c,l,b=document.getElementsByTagName("script");l=b[b.length-1].previousSibling;a=l.getAttribute('data-cfemail');if(a){s='';r=parseInt(a.substr(0,2),16);for(j=2;a.length-j;j+=2){c=parseInt(a.substr(j,2),16)^r;s+=String.fromCharCode(c);}s=document.createTextNode(s);l.parentNode.replaceChild(s,l);}}catch(e){}})();
/* ]]> */
  </script>",
  "user_name": "Mark Hanks"
}

Dokumen ini setara dengan satu baris di RDBMS. Collection terdiri dari banyak dokumen seperti tabel terdiri dari banyak baris. Perhatikan bahwa setiap dokumen dalam Collection memiliki field _id yang unik, yang merupakan field 12byte yang berfungsi sebagai kunci utama untuk dokumen. Bidang ini otomatis dihasilkan pada penciptaan dokumen dan digunakan untuk secara unik mengidentifikasi setiap dokumen.

Untuk memahami pemetaan yang lebih baik, mari kita ambil contoh dari sebuah tabel SQL users dan struktur yang sesuai di MongoDB. Seperti ditunjukkan dalam Gambar 1, setiap baris dalam tabel SQL diubah ke document dan setiap kolom ke field di MongoDB.

Figure 1 Mapping Table to Collection (1)
Gambar 1

Skema Dinamis

Satu hal yang menarik untuk fokus di sini adalah bahwa dokumen-dokumen yang berbeda dalam koleksi dapat memiliki skema yang berbeda. Jadi, sangat mungkin di MongoDB untuk satu dokumen memiliki lima field dan dokumen lain untuk memiliki tujuh field. Field dapat dengan mudah ditambahkan, dihapus dan dimodifikasi kapan saja. Juga, tidak ada kendala pada jenis data field. Dengan demikian, pada satu instance dapat menyimpan tipe data int  dan pada contoh berikutnya dapat menyimpan array.

Konsep-konsep ini harus tampak sangat berbeda dengan pembaca yang datang dari latar belakang RDBMS dimana struktur tabel, kolom mereka, tipe data dan hubungan yang telah ditentukan. Fungsionalitas ini menggunakan skema dinamis memungkinkan kita untuk menghasilkan dokumen dinamis pada saat dijalankan.

Sebagai contoh, pertimbangkan dua dokumen berikut dalam koleksi yang sama tetapi memiliki skema yang berbeda (Gambar 2):

Figure 2 Documents in a Collection having different structure

Gambar 2

Dokumen pertama berisi kolom alamat dan tanggal lahir yang tidak hadir dalam dokumen kedua sedangkan dokumen kedua berisi field occupation dan gender yang tidak hadir dalam dokumen pertama. Bayangkan jika kita telah merancang hal ini di SQL, kita akan terus empat kolom tambahan untuk alamat, tanggal lahir, jenis kelamin dan pekerjaan, beberapa di antaranya akan menyimpan nilai-nilai kosong (atau null), dan karenanya menempati ruang yang tidak perlu.

Model skema dinamis adalah alasan mengapa database NosSQL sangat scalable dalam hal desain. Berbagai skema kompleks (hirarkis, struktur pohon, dll) yang akan membutuhkan sejumlah tabel RDBMS dapat dirancang secara efisien dengan menggunakan dokumen-dokumen tersebut. Sebuah contoh khas akan menyimpan posting pengguna, mereka suka, komentar dan informasi terkait lainnya dalam bentuk dokumen. Sebuah implementasi SQL yang sama idealnya akan memiliki tabel terpisah untuk menyimpan posting, komentar dan suka sementara dokumen MongoDB dapat menyimpan semua informasi ini dalam satu dokumen.

Memetakan Join dan Hubungan

Hubungan di RDBMS yang dicapai dengan menggunakan hubungan kunci primer dan asing dan query yang menggunakan join. Tidak ada pemetaan langsung seperti di MongoDB tetapi hubungan di sini dirancang menggunakan dokumen tertanam dan menghubungkannya.

Pertimbangkan contoh di mana kita perlu untuk menyimpan informasi pengguna dan informasi kontak yang sesuai. Sebuah desain SQL ideal akan memiliki dua tabel, katakanlah user_information dan contact_information, dengan kunci primer id dan contact_id seperti ditunjukkan pada Gambar 3. Tabel contact_information juga akan berisi kolom user_id yang akan menghubungkan kunci asing untuk field id dari tabel user_information.

Relationships in RDBMS are achieved using primary and foreign key relationships and querying those using joins. There is no such straightforward mapping in MongoDB but the relationships here are designed using embedded and linking documents.

Consider an example wherein we need to store user information and corresponding contact information. An ideal SQL design would have two tables, sayuser_information and contact_information, with primary keys id andcontact_id as shown in Fig 3. The contact_information table would also contain a column user_id which would be the foreign key linking to the id field of theuser_information table.

Figure 3
Gambar 3

Sekarang kita akan melihat bagaimana kita akan merancang hubungan tersebut dalam MongoDB menggunakan pendekatan Linking documents dan Embedded documents. Perhatikan bahwa dalam skema SQL, kita biasanya menambahkan kolom (seperti id dan contact_id dalam kasus kami) yang bertindak sebagai kolom utama untuk meja itu. Namun, dalam MongoDB, kita umumnya menggunakan field yang secara otomatis dihasilkan _id sebagai kunci utama untuk secara unik mengidentifikasi dokumen.

Linking Documents

Pendekatan ini akan menggunakan dua collectionsuser_information dan contact_information keduanya memiliki field unik _id mereka. Kita akan memiliki field user_id dalam dokumen contact_information yang berkaitan dengan field _id dari  dokumen user_information yang menunjukkan mana kontak pengguna yang sesuai dengannya. (Lihat Gambar 4) Perhatikan bahwa dalam MongoDB, hubungan dan operasi yang terkait harus diurus secara manual (misalnya, melalui kode) karena tidak ada batasan kunci asing dan aturan berlaku.

Figure 4 Linking Documents in MongoDB
Figure 4

Field  user_id dalam dokumen kita hanyalah sebuah field yang memegang beberapa data dan semua logika terkait dengan itu harus dilaksanakan oleh kita. Bahkan jika Anda akan memasukkan beberapa user_id dalam dokumen contact_information yang tidak ada dalam koleksi user_information, MongoDB tidak akan membuang kesalahan apapun yang mengatakan bahwa user_id yang sesuai tidak ditemukan di koleksi user_information (tidak seperti SQL di mana ini akan menjadi batasan kunci asing tidak valid).

Menanamkan Dokumen

Pendekatan kedua adalah dengan menanamkan dokumen contact_information dalam dokumen user_information seperti ini (Gambar 5):

Figure 5 Embedding Documents in MongoDB
Gambar 5

Dalam contoh di atas, kita telah menanamkan sebuah dokumen kecil informasi kontak dalam informasi pengguna. Dalam cara yang sama, dokumen kompleks yang besar dan data hirarkis dapat tertanam seperti ini untuk berhubungan badan.

Juga, pendekatan mana yang digunakan antara pendekatan Menghubungkan dan Menanamkan tergantung pada skenario tertentu. Jika data yang akan tertanam diperkirakan akan tumbuh lebih besar dalam ukuran, lebih baik menggunakan pendekatan Menghubungkan daripada pendekatan Menanamkan untuk menghindari dokumen menjadi terlalu besar. Pendekatan tertanam umumnya digunakan dalam kasus di mana jumlah informasi terbatas (seperti alamat pada contoh kita) harus tertanam.

Bagan Pemetaan

Untuk meringkas, tabel berikut (Gambar 6) merupakan hubungan umum yang telah kita bahas:

Figure 6 Mapping Chart
Gambar 6

Memetakan Query SQL ke MongoDB

Sekarang bahwa kita nyaman dengan pemetaan dasar antara RDBMS dan MongoDB, kita akan membahas bagaimana bahasa query yang digunakan untuk berinteraksi dengan database berbeda di antara mereka.

Untuk query MongoDB, mari kita asumsikan koleksi pengguna dengan struktur dokumen sebagai berikut:


{
     "_id": ObjectId("5146bb52d8524270060001f3"),
     "post_text":"This is a sample post" ,
     "user_name": "mark",
     "post_privacy": "public",
     "post_likes_count": 0
}

Untuk query SQL , kita mengasumsikan tabel users memiliki lima kolom dengan struktur dibawah ini:

Figure 7 Sample SQL Table
Gambar 7

Kita akan membahas query yang berkaitan dengan membuat dan mengubah koleksi (atau tabel), memasukkan, membaca, memperbarui dan menghapus dokumen (atau baris). Ada dua query untuk setiap titik, satu untuk SQL dan satu lagi untuk MongoDB. Saya akan menjelaskan query MongoDB hanya karena kita sudah familiar dengan query SQL. Query MongoDB disajikan di sini ditulis dalam Mongo JavaScript shell sedangkan query SQL yang ditulis dalam MySQL.

Create

Dalam MongoDB, tidak perlu secara eksplisit menciptakan struktur koleksi (seperti yang kita lakukan untuk tabel menggunakan query CREATE TABLE). Struktur dokumen secara otomatis dibuat ketika insert pertama terjadi dalam koleksi. Namun, Anda dapat membuat koleksi kosong menggunakan perintah createCollection.

SQL: CREATE TABLE `posts` (`id` int(11) NOT NULL AUTO_INCREMENT,`post_text` varchar(500) NOT NULL,`user_name` varchar(20) NOT NULL,`post_privacy` varchar(10) NOT NULL,`post_likes_count` int(11) NOT NULL,PRIMARY KEY (`id`))

MongoDB: db.createCollection("posts")

Insert

Untuk menyisipkan dokumen di MongoDB, kita menggunakan metode insert yang mengambil obyek dengan pasangan nilai kunci sebagai input. Dokumen yang dimasukkan akan berisi field _id yang otomatis dihasilkan oleh software. Namun, Anda juga dapat secara eksplisit memberikan nilai byte 12 sebagai _id bersama dengan field lainnya.

SQL: INSERT INTO `posts` (`id` ,`post_text` ,`user_name` ,`post_privacy` ,`post_likes_count`)VALUES (NULL ,  'This is a sample post',  'mark',  'public',  '0');

MongoDB:  db.posts.insert({user_name:"mark", post_text:"This is a sample post", post_privacy:"public", post_likes_count:0})

Tidak ada fungsi Alter Table di MongoDB untuk mengubah struktur dokumen. Sejak dokumennya dalam skema dinamis, skema berubah sebagaimana dan ketika informasi terbaru terjadi pada dokumen.

Read

MongoDB menggunakan metode find yang setara dengan perintah SELECT di SQL. Pernyataan berikut hanya membaca semua dokumen dari koleksi posts tersebut.

SQL: SELECT * FROM  `posts`

MongoDB: db.posts.find()

Query berikut melakukan pencarian bersyarat untuk dokumen yang memiliki field user_name sebagai mark. Semua kriteria untuk mengambil dokumen harus ditempatkan dalam tanda kurung {} dipisahkan dengan koma.

SQL: SELECT * FROM `posts` WHERE `user_name` =  'mark'

MongoDB: db.posts.find({user_name:"mark"})

Query berikut meminta kolom tertentupost_text dan post_likes_count seperti ditentukan pada kumpulan dalam tanda kurung {}.

SQL: SELECT  `post_text` ,  `post_likes_count` FROM  `posts`

MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})
Perhatikan bahwa MongoDB secara default mengembalikan field _id dengan masing-masing pernyataan yang ditemukan. Jika kita tidak ingin field ini di hasil kembaliannya, kita harus menentukan kunci _id dengan nilai 0 dalam daftar kolom yang akan diambil. Nilai kunci 0 menunjukkan bahwa kita ingin mengecualikan field ini dari kumpulan data yang dihasilkan.
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})

Query berikut meminta field tertentu berdasarkan kriteria yang mana user_name adalah mark.

SQL: SELECT  `post_text` , `post_likes_count` FROM `posts` WHERE `user_name` =  'mark'

MongoDB: db.posts.find({user_name:"mark"},{post_text:1,post_likes_count:1})

Sekarang kita akan menambahkan satu lagi kriteria untuk mengambil tulisan dengan jenis privasi sebagai publik. Bidang kriteria tertentu menggunakan koma mewakili kondisi logika AND. Dengan demikian, pernyataan ini akan mencari dokumen yang memiliki keduanya user_name sebagai mark dan post_privacy sebagai public.

SQL: SELECT  `post_text` ,  `post_likes_count` FROM  `posts` WHERE  `user_name` =  'mark' AND  `post_privacy` =  'public'

MongoDB: db.posts.find({user_name:"mark",post_privacy:"public"},{post_text:1,post_likes_count:1})

Untuk menggunakan logika OR antara kriteria dalam metode find, kita menggunakan operator $or.

SQL: SELECT  `post_text` ,  `post_likes_count` FROM  `posts` WHERE  `user_name` =  'mark' OR  `post_privacy` =  'public'

MongoDB: db.posts.find({$or:[{user_name:"mark"},{post_privacy:"public"}]},{post_text:1,post_likes_count:1})

Selanjutnya, kita akan menggunakan metode sort yang mengurutkan hasil dalam urutan menaik dari post_likes_count (ditandai dengan 1).

SQL: SELECT *  FROM `posts` WHERE `user_name` = 'mark' order by post_likes_count ASC

MongoDB: db.posts.find({user_name:"mark"}).sort({post_likes_count:1})

Untuk mengurutkan hasil dalam urutan menurun, kita tentukan -1 sebagai nilai field.

SQL: SELECT *  FROM `posts` WHERE `user_name` = 'mark' order by post_likes_count DESC

MongoDB: db.posts.find({user_name:"mark"}).sort({post_likes_count:-1})

Untuk membatasi jumlah dokumen yang harus dikembalikan, kami menggunakan metode limit yang menentukan jumlah dokumen.

SQL: SELECT *  FROM `posts` LIMIT 10

MongoDB: db.posts.find().limit(10)

Cara kita menggunakan offset dalam SQL untuk melewati beberapa jumlah record, kita menggunakan function skip di MongoDB. Sebagai contoh, pernyataan berikut akan mengambil sepuluh posting dengan melewatkan lima pertama.

SQL: SELECT *  FROM `posts` LIMIT 10 OFFSET  5

MongoDB: db.posts.find().limit(10).skip(5)

Update

Parameter pertama ke metode update menentukan kriteria untuk memilih dokumen. Parameter kedua menentukan operasi update yang sebenarnya yang akan dilakukan. Sebagai contoh, query berikut memilih semua dokumen with user_name sebagai mark dan menetapkan post_privacy mereka sebagai private.

Satu perbedaan di sini adalah bahwa secara default, query update MongoDB hanya mengupdate satu (dan yang pertama cocok) dokumen. Untuk memperbarui semua dokumen yang sesuai kita harus memberikan parameter ketiga menentukan multi sebagai true menunjukkan bahwa kita ingin memperbarui beberapa dokumen.

The first parameter to the update method specifies the criteria to select the documents. The second parameter specifies the actual update operation to be performed. For example, the following query selects all the documents withuser_name as mark and sets their post_privacy as private.

SQL: UPDATE posts SET post_privacy = "private" WHERE user_name='mark'

MongoDB: db.posts.update({user_name:"mark"},{$set:{post_privacy:"private"}},{multi:true})

Remove

Menghapus dokumen cukup sederhana dan mirip dengan SQL.

SQL: DELETE FROM posts WHERE user_name='mark'

MongoDB:  db.posts.remove({user_name:"mark"})

Mengindex

MongoDB memiliki indeks default dibuat pada field _id disetiap koleksi. Untuk membuat indeks baru pada field lain, kita menggunakan metode ensureIndex dengan menentukan fields dan urutannya ditunjukkan oleh 1 atau -1 (naik atau turun).
SQL: CREATE INDEX index_posts ON posts(user_name,post_likes_count DESC)

MongoDB: db.posts.ensureIndex({user_name:1,post_likes_count:-1})

Untuk melihat semua indeks hadir dalam koleksi mana saja, kita menggunakan metode getIndexes pada baris yang sama dengan query SHOW INDEX dari SQL.

SQL: SHOW INDEX FROM posts

MongoDB: db.posts.getIndexes()

Kesimpulan

Pada artikel ini, kami mengerti bagaimana konsep-konsep dasar dan istilah RDBMS / SQL berhubungan di MongoDB. Kami memandang cara merancang hubungan dalam MongoDB dan belajar bagaimana fungsi query SQL dasar dipetakan di MongoDB.

Setelah mendapatkan bahasan dari artikel ini, Anda dapat melanjutkan mencoba query kompleks termasuk agregasimap reduce dan query yang melibatkan beberapa koleksi. Anda juga dapat mengambil bantuan dari beberapa alat online untuk mengkonversi query SQL ke query MongoDB di awal. Anda dapat merancang sampel skema database MongoDB Anda sendiri. Salah satu contoh terbaik untuk melakukannya akan menjadi database untuk menyimpan posting pengguna, suka, komentar dan komentar sejenisnya. Ini akan memberi Anda pandangan praktis dari desain skema fleksibel yang ditawarkan MongoDB.

Jangan ragu untuk memberi komentar, saran, pertanyaan atau ide-ide Anda.

diterjemahkan secara bebas dari http://code.tutsplus.com/articles/mapping-relational-databases-and-sql-to-mongodb–net-35650?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+nettuts+%28Tuts%2B+Web+Development%29

Advertisements

About phpgeek programmer

pemimpi yang berharap menjadi the best programmer di zamannya

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s