Database NoSQL telah muncul sangat dalam beberapa tahun terakhir karena strukturnya yang kurang dibatasi, desain skema yang skalabel, dan akses yang lebih cepat dibandingkan dengan database relasional tradisional (RDBMS/SQL). MongoDB adalah database NoSQL berorientasi dokumen sumber terbuka yang menyimpan data dalam bentuk objek seperti JSON. Itu telah muncul sebagai salah satu database terkemuka karena skema dinamis, skalabilitas tinggi, kinerja kueri optimal, pengindeksan lebih cepat dan komunitas pengguna aktif. Show Jika Anda berasal dari latar belakang RDBMS/SQL, memahami konsep NoSQL dan MongoDB bisa agak sulit saat memulai karena kedua teknologi memiliki cara representasi data yang sangat berbeda. Artikel ini akan mengarahkan Anda untuk memahami bagaimana RDBMS/SQL domain, fungsionalitasnya, istilah dan peta bahasa kueri ke database MongoDB. Dengan pemetaan, maksud saya bahwa jika kita memiliki konsep dalam RDBMS/SQL, kita akan melihat apa konsep yang sama dalam MongoDB. Kita akan mulai dengan memetakan konsep-konsep dasar relasional seperti tabel, baris, kolom, dll dan bergerak untuk membahas pengindeksan dan join. Kami kemudian akan memeriksa kueri SQL dan mendiskusikan kueri basis data MongoDB yang sesuai. Artikel ini mengasumsikan bahwa Anda mengetahui konsep basis data relasional dasar dan SQL, karena sepanjang artikel ini akan lebih ditekankan pada pemahaman bagaimana konsep-konsep ini dipetakan dalam MongoDB. Mari kita mulai. Memetakan Tabel, Baris dan KolomSetiap database di MongoDB terdiri dari koleksi yang setara dengan database RDBMS yang terdiri dari tabel SQL. Setiap pengumpulan menyimpan data dalam bentuk dokumen yang sama dengan tabel yang menyimpan data dalam baris. Sementara baris menyimpan data dalam kumpulan kolomnya, sebuah dokumen memiliki struktur mirip JSON (dikenal sebagai BSON di MongoDB). Terakhir, cara kita memiliki baris dalam baris SQL, kita memiliki bidang dalam MongoDB. Berikut ini adalah contoh dokumen (baris baca) yang memiliki beberapa bidang (kolom baca) yang menyimpan data pengguna: {
"_id": ObjectId("5146bb52d8524270060001f3"),
"age": 25,
"city": "Los Angeles",
"email": "[email protected]",
"user_name": "Mark Hanks"
}Dokumen ini sama dengan satu baris dalam RDBMS. Koleksi terdiri dari banyak dokumen seperti halnya tabel terdiri dari banyak baris. Perhatikan bahwa setiap dokumen dalam koleksi memiliki bidang {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 unik, yang merupakan bidang 12 byte yang berfungsi sebagai kunci utama untuk dokumen. Bidang ini dibuat secara otomatis saat membuat dokumen dan digunakan untuk mengidentifikasi setiap dokumen secara unik.Untuk memahami pemetaan dengan lebih baik, mari kita ambil contoh 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")0 tabel SQL dan struktur terkait di MongoDB. Seperti yang ditunjukkan pada Fig 1, setiap baris dalam tabel SQL mentransformasikan ke dokumen dan setiap kolom ke bidang di MongoDB. Gambar 1 Skema DinamisSatu hal yang menarik untuk menjadi fokus di sini adalah bahwa berbagai dokumen dalam koleksi dapat memiliki skema yang berbeda. Jadi, dimungkinkan dalam MongoDB untuk satu dokumen memiliki lima bidang dan dokumen lainnya memiliki tujuh bidang. Kolom dapat dengan mudah ditambahkan, dihapus, dan dimodifikasi kapan saja. Juga, tidak ada batasan pada tipe data bidang. Jadi, pada satu contoh, suatu bidang dapat menyimpan data tipe 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")1 dan pada contoh berikutnya bidang tersebut dapat menyimpan sebuah 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")2.Konsep-konsep ini harus tampak sangat berbeda dengan pembaca yang berasal dari latar belakang RDBMS di mana struktur tabel, kolom, tipe data, dan relasinya sudah ditentukan sebelumnya. Fungsionalitas ini untuk menggunakan skema dinamis memungkinkan kami untuk menghasilkan dokumen dinamis pada saat run time. Misalnya, pertimbangkan dua dokumen berikut di dalam koleksi yang sama tetapi memiliki skema yang berbeda (Gbr 2): Gambar 2 Dokumen pertama berisi bidang 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")3 dan 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")4 yang tidak ada dalam dokumen kedua sedangkan dokumen kedua berisi bidang 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")5 dan 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")6 yang tidak ada di yang pertama. Bayangkan jika kita akan merancang hal ini dalam SQL, kita akan menyimpan empat kolom tambahan untuk 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")3, 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")4, 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")5 dan 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")6, beberapa di antaranya akan menyimpan nilai kosong (atau null), dan karenanya menempati ruang yang tidak perlu.Model skema dinamis ini adalah alasan mengapa basis data NosSQL sangat skalabel dalam hal desain. Berbagai skema kompleks (hierarkis, struktur pohon, dll) yang membutuhkan jumlah tabel RDBMS dapat dirancang secara efisien menggunakan dokumen-dokumen tersebut. Contoh tipikal adalah menyimpan posting pengguna, suka mereka, komentar dan informasi terkait lainnya dalam bentuk dokumen. Implementasi SQL untuk hal yang sama idealnya memiliki tabel terpisah untuk menyimpan posting, komentar dan suka sementara dokumen MongoDB dapat menyimpan semua informasi ini dalam satu dokumen. Memetakan Join dan RelationshipRelationship dalam RDBMS dicapai menggunakan hubungan kunci primer dan asing dan men-kueri mereka yang menggunakan join. Tidak ada pemetaan langsung seperti itu di MongoDB tetapi hubungan di sini dirancang menggunakan dokumen yang tersemat dan tertaut. Pertimbangkan contoh di mana kita perlu menyimpan informasi pengguna dan informasi kontak yang sesuai. Desain SQL yang ideal akan memiliki dua tabel, katakanlah 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})1 dan 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})2, dengan 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})3 kunci primer dan 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})4 seperti yang ditunjukkan pada Gambar 3. Tabel 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})2 juga akan berisi kolom 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})6 yang akan menjadi kunci foreign yang menghubungkan ke bidang 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})3 dari tabel 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})1.Gambar 3 Sekarang kita akan melihat bagaimana kita akan merancang hubungan seperti itu di MongoDB menggunakan pendekatan Menghubungkan dokumen dan dokumen Tertanam. Perhatikan bahwa dalam skema SQL, kami biasanya menambahkan kolom (seperti 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})3 dan 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})4 dalam kasus kami) yang bertindak sebagai kolom utama untuk tabel itu. Namun, di MongoDB, kami biasanya menggunakan bidang {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 yang dibuat secara otomatis sebagai kunci utama untuk mengidentifikasi dokumen secara unik.Menautkan DokumenPendekatan ini akan menggunakan dua koleksi, 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})1 dan 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})2 keduanya memiliki bidang {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 unik mereka. Kami akan memiliki bidang 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})6 dalam dokumen 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})2 yang berkaitan dengan bidang {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 dari dokumen 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})1 yang menunjukkan pengguna yang sesuai dengan kontak. (Lihat Gambar 4) Perhatikan bahwa dalam MongoDB, relasi dan operasi terkaitnya harus dijaga secara manual (misalnya, melalui kode) karena tidak ada batasan dan aturan kunci foreign yang berlaku.Gambar 4 Bidang 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})6 dalam dokumen kami hanyalah bidang yang menampung beberapa data dan semua logika yang terkait dengannya harus diimplementasikan oleh kami. Sebagai contoh, bahkan jika Anda akan menyisipkan beberapa 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})6 dalam dokumen 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})2 yang tidak ada dalam koleksi 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})1, MongoDB tidak akan membuang kesalahan yang mengatakan bahwa 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})6 yang sesuai tidak ditemukan dalam koleksi 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})1 (tidak seperti SQL di mana ini akan menjadi batasan kunci foreign tidak valid).Dokumen yang DisematkanPendekatan kedua adalah menyematkan dokumen 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})2 di dalam dokumen 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})1 seperti ini (Gbr 5):Gambar 5 Dalam contoh di atas, kami telah menempelkan dokumen kecil informasi kontak di dalam informasi pengguna. Dengan cara yang sama, dokumen kompleks yang besar dan data hierarkis dapat disematkan seperti ini untuk menghubungkan entitas. Juga, pendekatan mana yang digunakan antara pendekatan Linking dan Embedded tergantung pada skenario spesifik. Jika data yang akan disematkan diharapkan tumbuh lebih besar dalam ukuran, lebih baik menggunakan pendekatan Linking daripada pendekatan Embedded untuk menghindari dokumen menjadi terlalu besar. Pendekatan Embedded umumnya digunakan dalam kasus-kasus di mana sejumlah informasi terbatas (seperti alamat dalam contoh kami) harus disematkan. Bagan PemetaanUntuk meringkas, bagan berikut (Gambar 6) mewakili hubungan bersama umum yang telah kita bahas: Gambar 6 Memetakan SQL ke Kueri MongoDBSekarang kami merasa nyaman dengan pemetaan dasar antara RDBMS dan MongoDB, kami akan membahas bagaimana bahasa query yang digunakan untuk berinteraksi dengan database berbeda di antara mereka. Untuk kueri MongoDB, mari kita asumsikan koleksi 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")0 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 kueri SQL, kami menganggap 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")0 tabel memiliki lima kolom dengan struktur berikut:Gambar 7 Kami akan membahas kueri terkait untuk membuat dan mengubah koleksi (atau tabel), menyisipkan, membaca, memperbarui, dan menghapus dokumen (atau baris). Ada dua kueri untuk setiap titik, satu untuk SQL dan satu lagi untuk MongoDB. Saya akan menjelaskan kueri MongoDB hanya karena kita cukup akrab dengan kueri SQL. Kueri MongoDB yang disajikan di sini ditulis dalam shell JavaScript Mongo sementara kueri SQL ditulis dalam MySQL. MembuatDi MongoDB, tidak perlu secara eksplisit membuat struktur koleksi (seperti yang kita lakukan untuk tabel menggunakan kueri SQL: SELECT * FROM `posts` WHERE `user_name` = 'mark'
MongoDB: db.posts.find({user_name:"mark"})9). Struktur dokumen dibuat secara otomatis ketika memasukkan pertama kali dalam koleksi. Namun, Anda dapat membuat koleksi kosong menggunakan perintah SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})0.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")MemasukanUntuk menyisipkan dokumen dalam MongoDB, kami menggunakan metode SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})1 yang mengambil objek dengan pasangan nilai kunci sebagai inputnya. Dokumen yang dimasukkan akan berisi bidang {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 yang dibuat secara otomatis. Namun, Anda juga dapat secara eksplisit memberikan nilai 12 byte sebagai {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 bersama dengan bidang 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 SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})4 di MongoDB untuk mengubah struktur dokumen. Karena dokumen bersifat dinamis dalam skema, skema akan berubah seiring dan saat pembaruan apa pun terjadi pada dokumen.BacaMongoDB menggunakan metode SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})5 yang setara dengan perintah SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})6 dalam SQL. Pernyataan berikut cukup membaca semua dokumen dari koleksi SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})7.SQL: SELECT * FROM `posts` MongoDB: db.posts.find() Kueri berikut melakukan pencarian bersyarat untuk dokumen yang memiliki bidang SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})8 sebagai SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})9. Semua kriteria untuk mengambil dokumen harus ditempatkan di kurung kurawal {} dipisahkan oleh koma.SQL: SELECT * FROM `posts` WHERE `user_name` = 'mark'
MongoDB: db.posts.find({user_name:"mark"})Kueri berikut mengambil kolom, MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})0 dan MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})1 tertentu seperti yang ditentukan dalam set kedua 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 bidang {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 dengan setiap pernyataan find. Jika kita tidak ingin bidang ini di set hasil kita, kita harus menentukan kunci {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 dengan nilai MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})4 dalam daftar kolom yang akan diambil. Nilai kunci MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})4 menunjukkan bahwa kami ingin mengecualikan bidang ini dari hasil yang ditetapkan.MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})Kueri berikut mengambil bidang tertentu berdasarkan kriteria yang dimana SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})8 adalah SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})9.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})Kami sekarang akan menambahkan satu kriteria lagi untuk mengambil posting dengan tipe privasi sebagai publik. Bidang kriteria yang ditentukan menggunakan koma mewakili logika kondisi MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})8. Dengan demikian, pernyataan ini akan mencari dokumen yang memiliki SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})8 sebagai SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})9 dan 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})1 sebagai 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})2.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 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})3 antara kriteria dalam metode SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})5, kami menggunakan 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})5 operator.{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}0Selanjutnya, kita akan menggunakan metode 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})6 yang mengurutkan hasilnya dalam urutan ascending MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})1 (ditunjukkan oleh 1).{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}1Untuk mengurutkan hasil dalam urutan descending, kami menetapkan 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})8 sebagai nilai bidang.{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}2Untuk membatasi jumlah dokumen yang akan dikembalikan, kami menggunakan metode 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})9 yang menentukan jumlah dokumen.{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}3Cara kami menggunakan 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})0 dalam SQL untuk melewati beberapa record, kami menggunakan fungsi 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})1 di MongoDB. Misalnya, pernyataan berikut akan mengambil sepuluh pos yang dilewati lima pos pertama.{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}4MemperbaruiParameter pertama ke metode 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})2 menentukan kriteria untuk memilih dokumen. Parameter kedua menentukan operasi pembaruan aktual yang akan dilakukan. Sebagai contoh, kueri berikut memilih semua dokumen dengan SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})8 sebagai SQL: SELECT `post_text` , `post_likes_count` FROM `posts`
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})9 dan menetapkan 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})1 sebagai 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})6.Satu perbedaan di sini adalah bahwa secara default, MongoDB kueri 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})2 yang hanya memperbarui satu (dan yang pertama cocok) dokumen. Untuk memperbarui semua dokumen yang cocok, kami harus menyediakan parameter ketiga yang menentukan 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})8 sebagai 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})9 yang menunjukkan bahwa kami ingin memperbarui beberapa dokumen.{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}5HapusMenghapus dokumen sangat sederhana dan mirip dengan SQL. {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}6PengindeksanMongoDB memiliki index default yang dibuat pada bidang {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}9 dari setiap koleksi. Untuk membuat indeks baru di bidang, kami menggunakan metode {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}01 menentukan bidang dan urutan pengurutan terkait ditunjukkan oleh {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}02 atau -{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}02 (ascending atau descending).{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}7Untuk melihat semua indeks yang ada dalam koleksi apa pun, kami menggunakan metode {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}04 pada baris yang sama dari query sql {
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}05{
"_id": ObjectId("5146bb52d8524270060001f3"),
"post_text":"This is a sample post" ,
"user_name": "mark",
"post_privacy": "public",
"post_likes_count": 0
}8KesimpulanDalam artikel ini, kami memahami bagaimana konsep dan istilah dasar RDBMS/SQL berhubungan dalam MongoDB. Kami melihat merancang hubungan dalam MongoDB dan belajar bagaimana fungsionalitas pemetaan kueri SQL dasar di MongoDB. Setelah memulainya dengan artikel ini, Anda bisa mencoba kueri yang rumit termasuk agregasi, pengurangan map, dan kueri yang melibatkan banyak koleksi. Anda juga dapat mengambil bantuan beberapa alat online untuk mengonversi kueri SQL ke kueri MongoDB di awal. Anda bisa bermain merancang sampel skema database MongoDB sendiri. Salah satu contoh terbaik untuk melakukannya adalah database untuk menyimpan posting pengguna, like mereka, komentar dan like komentar. Ini akan memberi Anda pandangan praktis tentang desain skema fleksibel yang ditawarkan MongoDB. Apakah MongoDB termasuk SQL?Seperti yang sudah disebutkan sebelumnya, MongoDB adalah salah satu jenis database NoSQL (Not Only SQL) yang menyimpan datanya dalam bentuk document dengan format JSON. Dengan menggunakan format ini, MongoDB mampu menampung data yang kompleks dan bervariasi.
MongoDB menggunakan bahasa apa?MongoDB sendiri ditulis dengan bahasa C++ dan telah tersedia untuk berbagai jenis bahasa pemrograman. Fitur utama dari mongoDB antara lain: model document-oriented storage.
MongoDB untuk apa?MongoDB adalah database yang mempunyai kemampuan mengelola query dengan lebih baik. Tak hanya itu, MongoDB juga dibekali dengan kemudahan akses sehingga kamu bisa melihat hasil suatu data yang rumit atau tak terstruktur dengan cepat.
Apa perbedaan MongoDB dan MySQL?Apa itu MySQL: Perbedaannya Dengan MongoDB. Hal mendasar yang bisa membedakan MongoDB dengan MySQL adalah sifat database MySQL untuk penyimpanan data relasional, sedangkan MongoDB adalah database untuk penyimpanan data dokumen.
|
Cara menggunakan mongodb apakah sql?
Pos Terkait
Copyright © 2024 apacode Inc.
