Operasi CRUD Database MongoDB dengan Python (Bagian 1)
MongoDB adalah sistem manajemen basis data NoSQL yang sangat populer untuk menyimpan dan mengelola data dengan skema semi-struktural. Salah satu keunggulan mongoDB adalah kemampuannya dalam menyimpan data semi-struktural atau data dengan skema yang dapat berubah seiring waktu. Ini berarti kita tidak perlu mendefinisikan skema tabel terlebih dahulu seperti pada sistem basis data relasional tradisional. Sebagai gantinya, kita dapat menyimpan dokumen dalam format JSON yang dapat berbeda baik struktur dan isinya di dalam suatu koleksi mongoDB.
Fokus dari tulisan ini adalah bagaimana melakukan operasi CRUD ke koleksi mongoDB menggunakan python. Tulisan ini merupakan bagian pertama dari dua bagian. Pada bagian ini pembahasan mencakup penyiapan kontainer mongoDB, pembuatan (create) dokumen dan pembacaan (read) dokumen menggunakan python. Adapun pada bagian kedua topik bahasan akan mencakup modifikasi dokumen (update), penghapusan dokumen (delete) serta agregasi data dan pipeline.
Mengawali bagian pertama ini, kita akan mulai dengan penyiapan server mongoDB.
Instalasi Kontainer MongoDB
Langkah pertama yang harus dilakukan adalah menyiapkan server MongoDB. Untuk alasan kemudahan pengaturan server, pada tutorial ini kita akan menggunakan kontainer mongoDB dengan docker. Namun silahkan saja jika ingin melakukan instalasi mongoDB secara langsung pada komputer atau bahkan menggunakan layanan remote server seperti MongoDB Atlas.
Jika menggunakan Microsoft Windows, kita dapat menginstal kontainer mongoDB melalui Docker Desktop. Berikut tahapan instalasi yang perlu dilakukan:
- Buka Docker Desktop (jika belum ada, silahkan unduh di sini Docker Desktop), dan pada kotak pencarian ketik mongo sampai muncul pilihan image terkait mongoDB
- Pilih image mongo (official image), selanjutnya pilih versi yang ingin digunakan misalnya latest lalu klik Run
- Pada kotak dialog Run a new container, masukkan nama kontainer misalnya tutorial_mongo_python. Masukkan juga port yang digunakan. Bagian ini mengatur port pada komputer lokal yang akan menjadi port forwarded bagi kontainer mongoDB. Port dapat diisikan berapa saja, dalam contoh ini digunakan port 27017 yaitu port yang sama dengan port default mongoDB pada kontainer. Artinya saat kita mengakses port 27017 pada komputer lokal, maka akan diteruskan ke port 27017 pada kontainer mongoDB. Lanjutkan dengan klik Run dan tunggu sampai proses selesai.
- Setelah selesai, buka tab Containers dan pastikan status kontainer Running. Jika belum, maka jalankan kontainer dengan klik tombol segitiga (start) pada kolom Actions.
Jika langkah-langkah di atas sudah berjalan dengan benar, maka kontainer mongoDB sudah terpasang dan siap digunakan untuk operasi CRUD dengan python.
Ekstensi MongoDB VS Code
(Bagian ini adalah opsional dan dapat dilewati)
Pada tutorial ini penulisan kode python akan menggunakan editor Visual Studio Code. Tentu anda dapat menggunakan kode editor apapun yang diinginkan, jadi silahkan gunakan kode editor pilihan anda.
Visual Studio Code memiliki ekstensi mongoDB for VS Code yang memungkinkan kita melihat database, membuka koleksi serta dokumen yang tersimpan pada server mongoDB. Jika dirasa perlu, silahkan menginstal ekstensi ini pada VS Code anda. Proses instalasi dapat dilakukan dengan mudah dengan mengikuti langkah berikut ini:
- Buka tab Extension dan cari ekstensi MongoDB for VS Code kemudian klik Install
- Jika instalasi berhasil, akan muncul tab baru dengan icon
, klik tab tersebut kemudian atur koneksi dengan klik tombol Connect. Masukkan connection string dengan format mongodb://url_server:portmisalnyamongodb://localhost:27017. - Jika koneksi berhasil dibuat, pada panel bagian kiri akan tampil daftar koneksi dengan status connected. Pada bagian ini kita dapat melihat daftar database, koleksi serta dokumen yang terdapat pada server tersebut.
, klik tab tersebut kemudian atur koneksi dengan klik tombol Connect. Masukkan connection string dengan format 
Interaksi MongoDB dengan python
Untuk mengakses database mongoDB menggunakan python, kita memerlukan pustaka tambahan yaitu pymongo. Pustaka dapat dipasang menggunakan pip seperti berikut:
Instalasi pymongo
# instalasi dari terminal pip install pymongo # instalasi dari cell notebook # !pip install pymongo
Selanjutnya, untuk membuka koneksi ke kontainer mongoDB adalah dengan menggunakan fungsi MongoClient. Pada fungsi ini tentukan alamat dan port dari server yang digunakan misalkan mongodb://localhost:27017/. Setelah terhubung, gunakan fungsi Client untuk membuka atau membuat database. Jika nama yang diberikan tidak ada, maka secara otomatis database akan dibuat menggunakan nama yang diberikan. Jika sudah terhubung dengan database, kita dapat mengakses koleksi di dalamnya menggunakan namanya. Sama seperti sebelumnya, ketika nama koleksi yang diberikan tidak ada dalam database, maka otomatis akan dibuat koleksi baru dengan nama tersebut. Pada contoh ini nama database yang digunakan adalah pokemon_db dan nama koleksinya adalah pokemon_info.
Untuk tahap awal ini, kita dapat mengecek jumlah dokumen pada koleksi pokemon_info menggunakan metode count_documents. Karena database dan koleksi baru dibuat, maka belum ada dokumen apapun di dalamnya
Koneksi ke mongoDB
from pymongo import MongoClient
# ----------------------------------------------- #
# MEMBUKA KONEKSI KE INSTANCE MONGODB #
# ----------------------------------------------- #
client = MongoClient("mongodb://localhost:27017/")
# ----------------------------------------------- #
# MEMBUKA DATABASE POKEMON_DB #
# jika tidak eksis maka akan dibuat database baru #
# ----------------------------------------------- #
db = client["pokemon_db"]
# ----------------------------------------------- #
# MEMBUKA KOLEKSI POKEMON_INFO #
# jika tidak eksis maka akan dibuat database baru #
# ----------------------------------------------- #
collection = db["pokemon_info"]
print(collection.count_documents({}))Membuat Dokumen
Proses create dokumen adalah proses untuk menambahkan dokumen baru pada suatu koleksi. Terdapat dua cara yang dapat digunakan yaitu dengan metode insert_one dan insert_many. Sesuai namanya insert_one digunakan untuk menambah 1 dokumen sedangkan insert_many digunakan untuk menambah beberapa dokumen sekaligus ke dalam suatu koleksi.
insert_one
Dokumen yang akan di-insert perlu dibuat dalam bentuk dictionary yaitu struktur data berupa pasangan key-value. Pada contoh berikut, kita membuat objek pikachu dengan tiga key/field yaitu name, type dan species. Ketika kita menggunakan metode insert_one, hasil insert juga dapat disimpan pada variabel tertentu, variabel tersebut akan memiliki informasi terkait status insert, salah satunya adalah "_id" atau status jika terjadi kegagalan.
Sebagai catatan, ketika melakukan insert dokumen tanpa disertakan field "_id", maka mongoDB akan otomatis membangkitkan id unik pada dokumen tersebut (mirip seperti primary key pada database tabular). Artinya jika contoh kode di bawah ini dijalankan berulang kali, maka akan selalu diinsert dokumen baru dengan "_id" yang berbeda namun isian lainnya sama. Oleh karena itu, jika ingin memastikan data benar-benar unik dapat menambahkan field "_id" pada dokumen yang akan di-insert.
Insert satu dokumen
# ----------------------------------------------- #
# INSERT SATU DOKUMEN #
# ----------------------------------------------- #
# membuat objek pikachu
pikachu = {
"name": "Pikachu",
"type": "Electric",
"species": "Mouse Pokémon"
}
# menambahkan dokumen ke koleksi
result = collection.insert_one(pikachu)
print(result.inserted_id)# OUTPUT 648bdffe272ac5cf1fe203f0
insert_many
Metode insert_many digunakan untuk menambah beberapa dokumen sekaligus pada koleksi. Semua dokumen yang akan ditambah perlu disimpan dalam bentuk list. Pada contoh dibawah ini terdapat objek list pokemon_docs yang berisi 3 dokumen dan masing-masing dokumen terdiri dari beberapa field. Setiap dokumen juga memiliki field "_id", dengan mencantumkan key "_id" ini, mongoDB akan menggunakannya sebagai identitas unik.
Insert banyak dokumen
# ----------------------------------------------- #
# INSERT BANYAK DOKUMEN #
# ----------------------------------------------- #
# membuat dokumen dalam list
pokemon_docs = [
{
"_id" : "0004",
"name": "Charmander",
"type": "Fire",
"species": "Lizard Pokémon",
},
{
"_id" : "0007",
"name": "Squirtle",
"type": "Water",
"species": "Tiny Turtle Pokémon",
},
{
"_id" : "0001",
"name": "Bulbasaur",
"type": ["Grass", "Poison"],
"species": "Seed Pokémon",
},
]
# menambahkan dokumen ke koleksi
results = collection.insert_many(pokemon_docs)
# melihat _id yang berhasil ditambahkan
print(results.inserted_ids)# OUTPUT ['0004', '0007', '0001']
Jika kita menginstal ekstensi mongoDB di VS Code, hasil insert yang sebelumnya sudah dilakukan dapat dilihat melalui tab mongoDB. Untuk memastikan informasi terbaru sudah tampil, klik kanan pada koleksi dan klik menu refresh.
Pada panel bagian kanan dapat dilihat 4 dokumen yang sudah ditambahkan. Termasuk 1 dokumen dengan "_id" yang digenerate oleh mongoDB dan 3 dokumen lainnya dengan "_id" yang sudah ditentukan. Setiap dokmen juga dapat di-klik untuk melihat isian lengkapnya
Pada bagian selanjutnya, kita akan menggunakan python untuk membaca koleksi pada database mongoDB. Agar contoh yang disajikan lebih lengkap, kita akan memasukkan sejumlah data terlebih dahulu. Silahkan download file JSON berikut (pokedex_1st_gen.json), simpan pada lokasi yang sama dengan file python yang digunakan. File ini berisi informasi dari 151 pokemon generasi pertama. Data-data tersebut akan kita gunakan untuk bagian-bagian selanjutnya.
Sebelum menambahkan dokumen ke dalam koleksi pokemon_info, mari kita hapus semua dokumen sebelumnya (atau dapat juga dengan membuat koleksi baru).
Menghapus seluruh dokumen
# ----------------------------------------------- #
# MENGHAPUS SEMUA DOKUMEN #
# ----------------------------------------------- #
# menghapus semua dokumen
result = collection.delete_many({})
# menampilkan jumlah dokumen yang dihapus
print(f"{result.deleted_count} dokumen dihapus")# OUTPUT 4 dokumen dihapus
insert_many (file JSON)
File json yang akan digunakan berisi data 151 pokemon generasi 1 dan memuai informasi serta statistik dari pokemon-pokemon tersebut. Beberapa pokemon memiliki field "successor" dan "predecessor", beberapa hanyak memiliki salah satu field tersebut dan beberapa tidak memiliki keduanya. Untuk field-field yang lain memiliki struktur yang sama untuk setiap dokumen pokemon.
Untuk membuka dokumen JSON gunakan pustaka bawaan python yaitu json. Kita juga menambahkan pustaka pprint agar dapat menampilkan output yang lebih rapi pada objek list dan dict.
Berikut ini kode untuk membaca dokumen JSON serta proses insert dokumen ke dalam koleksi 'pokemon_info':
Insert dokumen dari file json
# --------------------------------------------------- #
# INSERT BANYAK DOKUMEN DARI FILE JSON #
# --------------------------------------------------- #
import json
import pprint
# membuka file JSON
with open(file="pokedex_1st_gen.json", mode="r") as file:
pokedex = json.load(file)
# menampilkan 2 data pertama dari file
pprint.pprint(pokedex[0:2])
# menambahkan dokumen ke koleksi
result = collection.insert_many(pokedex)
# menampilkan jumlah dokumen yang ditambah
print(f"{len(result.inserted_ids)} dokumen ditambahkan")# OUTPUT
[{'_id': '0001',
'name': 'Bulbasaur',
'species': 'Seed',
'stats': {'HP': 45, 'attack': 49, 'defense': 49, 'speed': 45},
'successor': '0002',
'type': ['Grass', 'Poison']},
{'_id': '0002',
'name': 'Ivysaur',
'predecessor': '0001',
'species': 'Seed',
'stats': {'HP': 60, 'attack': 62, 'defense': 63, 'speed': 60},
'successor': '0003',
'type': ['Grass', 'Poison']}]
151 dokumen ditambahkanMembaca Dokumen
Koleksi dokumen pada mongoDB dapat dibaca menggunakan metode find_one dan find. Metode find_one digunakan untuk mendapatkan 1 dokumen dari dalam koleksi, sementara metode find berfungsi lebih luas dan dapat mengembalikan banyak elemen sekaligus berdasarkan kriteria pencarian. Penjelasan kedua metode ini dijelaskan lebih detail pada bagian berikut ini.
find_one
Metode find_one digunakan untuk mencari 1 dokumen dari koleksi. Jika dokumen yang cocok dengan kriteria pencarian lebih dari 1, maka tetap hanya1 saja yang dikirimkan sebagai output. Adapun output yang dikirimkan berupa objek dengan tipe dict.
Secara default, metode find_one akan mengambil semua nilai field yang ada pada dokumen, namun kita dapat menambahkan argumen kedua pada metode tersebut untuk menentukan field mana saja yang akan diambil atau tidak ("_id" akan selalu dikembalikan walaupun tidak ditulis secara eksplisit, kecuali jika diset "_id": 0).
Di bawah ini diberikan 4 contoh penggunaan metode find_one untuk pencarian dokumen. Masing-masing contoh menunjukkan beberapa cara pemanggilan dengan kriteria yang berbeda.
- Contoh 1: mencari dokumen dengan kriteria “
name": "Pikachu", pencarian ini mendapatkan 1 dokumen yang cocok, selanjutnya seluruh field pada dokumen akan disimpan pada variabelresult_1. - Contoh 2: sama dengan contoh 1, namun membatasi field yang diambil yaitu
namedantypesaja. - Contoh 3: sama dengan contoh 1, namun membatasi field yang diambil yaitu selain
type,abilitydanstats. - Contoh 4: mencari dokumen dengan kriteria
"spesies": "Flame". Pada koleksi ini seharusnya terdapat beberapa dokumen yang memenuhi, namun metodefind_onehanya akan mengembalikan 1 dokumen saja.
Contoh metode find_one
# ----------------------------------------------- #
# METODE FIND_ONE UNTUK MENGAMBIL DOKUMEN #
# ----------------------------------------------- #
# Contoh 1 (mengambil semua field)
result_1 = collection.find_one({"name": "Pikachu"})
pprint.pprint(result_1)
# Contoh 2 (mengambil field 'name' dan 'type' saja)
result_2 = collection.find_one(
{"name": "Pikachu"},
{"name": 1, "type": 1},
)
pprint.pprint(result_2)
# Contoh 3 (tanpa field 'type', 'ability' dan 'stats')
result_3 = collection.find_one(
{"name": "Pikachu"},
{"type": 0, "ability": 0, "stats": 0},
)
pprint.pprint(result_3)
# Contoh 4 (mengambil field 'name' dan species')
result_4 = collection.find_one(
{"species": "Flame"},
{"name": 1, "species": 1},
)
pprint.pprint(result_4)# OUTPUT
{'_id': '0025',
'name': 'Pikachu',
'species': 'Mouse',
'stats': {'HP': 35, 'attack': 55, 'defense': 40, 'speed': 90},
'successor': '0026',
'type': ['Electric']}
{'_id': '0025', 'name': 'Pikachu', 'type': ['Electric']}
{'_id': '0025', 'name': 'Pikachu', 'species': 'Mouse', 'successor': '0026'}
{'_id': '0005', 'name': 'Charmeleon', 'species': 'Flame'}
find
Metode find dapat digunakan untuk mendapatkan banyak dokumen sekaligus sesuai dengan kriteria yang diberikan. Output yang dihasilkan dari metode find berupa objek kursor dimana untuk mengakses elemen-elemennya secara berurutan dapat dilakukan menggunakan iterasi. Namun, objek tersebut juga dapat kita konversi ke dalam list jika akan digunakan untuk lebih lanjut.
Berikut ini disajikan dua contoh penggunaan metode find untuk mencari dokumen pada koleksi dengan kriteria tertentu.
- Contoh pertama : menggunakan metode
finduntuk mencari dokumen dengan kriteria"species": "Flame", output yang diperoleh langsung kita konversi ke dalam bentuk list dan disimpan pada variabel"flame_pokemon". Dengan bantuan fungsipprintkita dapat menampilkan output yang lebih rapi. Output menunjukkan terdapat 4 dokumen yang sesuai dengan kriteria ini. - Contoh kedua : mencari dokumen dengan kriteria
"stats.attack": 100. Perhatikan di sini, bahwa"attack"merupakan field yang berada di dalam field"stats". Oleh karena itu, untuk mengaksesnya field tersebut kita gunakan format"field_1.field_2". Cara yang sama juga dapat diterapkan untuk field bersarang yang lebih dalam lagi. Sama seperti sebelumnya, output dikonversi menjadi bentuk list dan disimpan pada variabelattack_100.
Contoh metode find
Contoh 1. Mengambil dokumen dengan nilai field "spesies": "Flame"
# ----------------------------------------------- #
# METODE FIND UNTUK MENGAMBIL BANYAK DOKUMEN #
# ----------------------------------------------- #
flame_pokemon = list(
collection.find(
{"species": "Flame"},
{"_id": 0, "name": 1, "species": 1},
)
)
print("\nPOKEMON SPESIES FLAME: ")
pprint.pprint(flame_pokemon)# OUTPUT
POKEMON SPESIES FLAME:
[{'name': 'Charmeleon', 'species': 'Flame'},
{'name': 'Charizard', 'species': 'Flame'},
{'name': 'Flareon', 'species': 'Flame'},
{'name': 'Moltres', 'species': 'Flame'}]Contoh 2. Mengambil dokumen dengan nilai field "stats.attack": 100
# ----------------------------------------------- #
# METODE FIND UNTUK MENGAMBIL BANYAK DOKUMEN #
# ----------------------------------------------- #
attack_100 = list(
collection.find(
{"stats.attack": 100},
{"_id": 0, "name": 1, "stats.attack": 1},
)
)
print("\nPOKEMON DENGAN ATTACK 100:")
pprint.pprint(attack_100)# OUTPUT
POKEMON DENGAN ATTACK 100:
[{'name': 'Sandslash', 'stats': {'attack': 100}},
{'name': 'Dugtrio', 'stats': {'attack': 100}},
{'name': 'Machoke', 'stats': {'attack': 100}},
{'name': 'Rapidash', 'stats': {'attack': 100}},
{'name': 'Tauros', 'stats': {'attack': 100}},
{'name': 'Moltres', 'stats': {'attack': 100}},
{'name': 'Mew', 'stats': {'attack': 100}}]Operator Perbandingan
Dalam proses pencarian dokumen, kita dapat mengatur kriteria tertentu dengan lebih spesifik menggunakan operator perbandingan. MongoDB memiliki beberapa operator yaitu $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin dan $all. Dua operator pertama, yaitu $eq dan $ne digunakan untuk membandingkan kesamaan dan ketidaksamaan dari suatu field. Operator berikutnya yaitu $gt, $gte, $lt, dan $lte digunakan untuk perbandingan nilai suatu field apakah lebih besar atau lebih kecil dari nilai tertentu. Tiga operator terakhir yaitu $in, $nin dan $all digunakan untuk mengecek apakah suatu field memiliki nilai diantara sekumpulan nilai yang diberikan.
>>> $eq dan $ne
Operator $eq (equal) dan $ne (not equal) digunakan untuk mengecek kesamaan atau ketidaksamaan nilai pada field tertentu. $eq digunakan untuk mencari dokumen dengan nilai field tertentu. Sementara itu, operator $ne dapat digunakan untuk mencari dokumen dengan kondisi tidak sama dengan nilai tertentu. Khusus untuk operator $eq, sebenarnya sama dengan yang sudah kita lakukan pada bagian sebelumnya yaitu langsung menggunakan {"nama_field": nilai}. Jadi operator $eq ini dapat dijadikan sebagai alternatif.
Contoh operator $eq dan $ne
Contoh 1. Mengambil dokumen dengan nilai field "species" sama dengan "Mouse"
# ----------------------------------------------- #
# MENGAMBIL DOKUMEN DENGAN OPERATOR $eq #
# ----------------------------------------------- #
mouse_pokemon = list(
collection.find(
{"species": {"$eq": "Mouse"}},
{"_id": 0, "name": 1, "species": 1},
)
)
print("POKEMON DENGAN SPESIES 'MOUSE':")
pprint.pprint(mouse_pokemon)
# cara lainnya
# mouse_pokemon = list(
# collection.find(
# {"species": "Mouse"},
# {"_id": 0, "name": 1, "species": 1},
# )
#)# OUTPUT
POKEMON DENGAN SPESIES 'MOUSE':
[{'name': 'Rattata', 'species': 'Mouse'},
{'name': 'Raticate', 'species': 'Mouse'},
{'name': 'Pikachu', 'species': 'Mouse'},
{'name': 'Raichu', 'species': 'Mouse'},
{'name': 'Sandshrew', 'species': 'Mouse'},
{'name': 'Sandslash', 'species': 'Mouse'}]Contoh 2. Mengambil dokumen dengan nilai field "species" sama dengan "Mouse" dan "stats.HP" sama dengan 30
# ----------------------------------------------- #
# MENGAMBIL DOKUMEN DENGAN OPERATOR $eq #
# ----------------------------------------------- #
mouse_hp_30 = list(
collection.find(
{
"species": {"$eq": "Mouse"},
"stats.HP": {"$eq": 30},
},
{"_id": 0, "name": 1, "species": 1, "stats.HP": 1},
)
)
print("\nPOKEMON MOUSE DENGAN NILAI 'HP' = 30:")
pprint.pprint(mouse_hp_30)# OUTPUT
POKEMON MOUSE DENGAN NILAI 'HP' = 30:
[{'name': 'Rattata', 'species': 'Mouse', 'stats': {'HP': 30}}]
Contoh 3. Mengambil dokumen dengan nilai field "successor" TIDAK sama dengan None
# ----------------------------------------------- #
# MENGAMBIL DOKUMEN DENGAN OPERATOR $ne #
# ----------------------------------------------- #
species_not_mouse = list(
collection.find(
{"successor": {"$ne": None}},
{"_id": 0, "name": 1, "successor": 1},
)
)
print("\nPOKEMON YANG MEMILIKI SUKSESOR (SUKSESOR != NONE):")
pprint.pprint(species_not_mouse)# OUTPUT
POKEMON YANG MEMILIKI SUKSESOR (SUKSESOR != NONE):
[{'name': 'Bulbasaur', 'successor': '0002'},
{'name': 'Ivysaur', 'successor': '0003'},
{'name': 'Charmander', 'successor': '0005'},
...
{'name': 'Kabuto', 'successor': '0141'},
{'name': 'Dratini', 'successor': '0148'},
{'name': 'Dragonair', 'successor': '0149'}]>>> $gt, $gte, $lt, dan $lte
Empat operator ini digunakan untuk membandingkan besaran nilai suatu field terhadap nilai tertentu. keyword yang digunakan sudah cukup menjelaskan perbedaan masing-masing operator yaitu: $gt (greater than), $gte (greater than or equal), $lt (less than) dan $lte (less than or equal).
Contoh operator $gt, $gte, $lt dan $lte
Contoh 1. Mengambil dokumen dengan field "stats.HP" > 120
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN OPERATOR gt, gte, lt, lte #
# ------------------------------------------------------ #
filter_pokemon = list(
collection.find(
{
"stats.HP": {"$gt": 120},
},
{"_id": 0, "name": 1, "stats.HP": 1},
)
)
print("POKEMON DENGAN HP > 100:")
pprint.pprint(filter_pokemon)# OUTPUT
POKEMON DENGAN HP > 100:
[{'name': 'Wigglytuff', 'stats': {'HP': 140}},
{'name': 'Chansey', 'stats': {'HP': 250}},
{'name': 'Lapras', 'stats': {'HP': 130}},
{'name': 'Vaporeon', 'stats': {'HP': 130}},
{'name': 'Snorlax', 'stats': {'HP': 160}}]Contoh 2. Mengambil dokumen dengan field "species" bukan "Lizard", "stats.attack" = [75-100] dan "stats.defense" = (100 - 120)
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN OPERATOR gt, gte, lt, lte #
# ------------------------------------------------------ #
filter_pokemon = list(
collection.find(
{
"species": {"$ne": "Lizard"},
"stats.attack": {"$gte": 75, "$lte": 100},
"stats.defense": {"$gt": 100, "$lt": 120},
},
{"_id": 0, "name": 1, "species": 1, "stats": 1},
)
)
print("POKEMON BUKAN SPESIES 'LIZARD'\n'ATTACK' : [75-100] dan 'DEFENSE' : (100 - 120)\n")
pprint.pprint(filter_pokemon)# OUTPUT
POKEMON BUKAN SPESIES 'LIZARD'
'ATTACK' : [75-100] dan 'DEFENSE' : (100 - 120)
[{'name': 'Sandslash',
'species': 'Mouse',
'stats': {'HP': 75, 'attack': 100, 'defense': 110, 'speed': 65}},
{'name': 'Graveler',
'species': 'Rock',
'stats': {'HP': 55, 'attack': 95, 'defense': 115, 'speed': 35}},
{'name': 'Slowbro',
'species': 'Hermit Crab',
'stats': {'HP': 95, 'attack': 75, 'defense': 110, 'speed': 30}},
{'name': 'Marowak',
'species': 'Bone Keeper',
'stats': {'HP': 60, 'attack': 80, 'defense': 110, 'speed': 45}}]>>> $in, $nin, dan $all
Operator $in, $nin dan $all digunakan untuk memeriksa apakah nilai pada suatu field cocok atau tidak cocok dengan sekumpulan nilai tertentu. Pada operator $in nilai field harus cocok dengan setidaknya salah satu kumpulan item tersebut. Sebaliknnya, pada operator $nin nilai field harus berbeda dengan setiap item yang diberikan. Adapun untuk operator $all, nilai pada field harus cocok dengan semua item yang diberikan.
Contoh operator $in, $nin, dan $all
Contoh 1. Mengambil Dokumen dengan field "type" berupa "Bug", "Grass" ataupun keduanya
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN OPERATOR $in #
# ------------------------------------------------------ #
bug_or_grass_pokemon = list(
collection.find(
{"type": {"$in": ["Bug", "Grass"]}},
{"_id": 0, "name": 1, "type": 1},
)
)
print("POKEMON TIPE 'BUG' ATAU 'GRASS':\n")
pprint.pprint(bug_or_grass_pokemon)# OUTPUT
POKEMON TIPE 'BUG' ATAU 'GRASS':
[{'name': 'Bulbasaur', 'type': ['Grass', 'Poison']},
{'name': 'Ivysaur', 'type': ['Grass', 'Poison']},
{'name': 'Venusaur', 'type': ['Grass', 'Poison']},
{'name': 'Caterpie', 'type': ['Bug']},
{'name': 'Metapod', 'type': ['Bug']},
{'name': 'Butterfree', 'type': ['Bug', 'Flying']},
...
{'name': 'Vileplume', 'type': ['Grass', 'Poison']},
{'name': 'Bellsprout', 'type': ['Grass', 'Poison']},
{'name': 'Weepinbell', 'type': ['Grass', 'Poison']},
{'name': 'Victreebel', 'type': ['Grass', 'Poison']}]Contoh 2. Mengambil Dokumen dengan field "type" BUKAN "Rock", "Dragon" atau "Electric"
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN OPERATOR $nin #
# ------------------------------------------------------ #
non_rock_dragon_electric = list(
collection.find(
{"type": {"$nin": ["Rock", "Dragon", "Electric"]}},
{"_id": 0, "name": 1, "type": 1},
)
)
print("\nPOKEMON TIPE SELAIN ('ROCK', 'DRAGON', 'ELECTRIC'):\n")
pprint.pprint(non_rock_dragon_electric)# OUTPUT
POKEMON TIPE SELAIN ('ROCK', 'DRAGON', 'ELECTRIC'):
[{'name': 'Bulbasaur', 'type': ['Grass', 'Poison']},
{'name': 'Ivysaur', 'type': ['Grass', 'Poison']},
{'name': 'Venusaur', 'type': ['Grass', 'Poison']},
{'name': 'Charmander', 'type': ['Fire']},
{'name': 'Charmeleon', 'type': ['Fire']},
{'name': 'Charizard', 'type': ['Fire', 'Flying']},
{'name': 'Squirtle', 'type': ['Water']},
...
{'name': 'Paras', 'type': ['Bug', 'Grass']},
{'name': 'Parasect', 'type': ['Bug', 'Grass']},
...
{'name': 'Articuno', 'type': ['Ice', 'Flying']},
{'name': 'Moltres', 'type': ['Fire', 'Flying']},
{'name': 'Mewtwo', 'type': ['Psychic']},
{'name': 'Mew', 'type': ['Psychic']}]Contoh 3. Mengambil Dokumen dengan field "type" berupa "Grass" dan "Poison" sekaligus
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN OPERATOR $all #
# ------------------------------------------------------ #
both_grass_poison = list(
collection.find(
{"type": {"$all": ["Grass", "Poison"]}},
{"_id": 0, "name": 1, "type": 1},
)
)
print("\nPOKEMON TIPE GRASS DAN POISON")
pprint.pprint(both_grass_poison)# OUTPUT
POKEMON TIPE GRASS DAN POISON
[{'name': 'Bulbasaur', 'type': ['Grass', 'Poison']},
{'name': 'Ivysaur', 'type': ['Grass', 'Poison']},
{'name': 'Venusaur', 'type': ['Grass', 'Poison']},
{'name': 'Oddish', 'type': ['Grass', 'Poison']},
{'name': 'Gloom', 'type': ['Grass', 'Poison']},
{'name': 'Vileplume', 'type': ['Grass', 'Poison']},
{'name': 'Bellsprout', 'type': ['Grass', 'Poison']},
{'name': 'Weepinbell', 'type': ['Grass', 'Poison']},
{'name': 'Victreebel', 'type': ['Grass', 'Poison']}]Operator Logika
Operator logika berfungsi untuk menggabungkan beberapa kriteria sekaligus. MongoDB menyediakan 4 operator logika yang dapat digunakan dalam pemeriksaan kriteria pencarian, yaitu:
$and: mengabungkan 2 atau lebih kriteria dan ekspresi akan bernilai True jika semua kriteria bernilai True. (tanpa menulis secara eksplisit operator $and pencarian dengan beberapa kriteria secara otomatis akan dievaluasi menggunakan and, seperti beberapa contoh yang telah diberikan pada contoh-contoh sebelumnya)
$or: menggabungkan 2 atau lebih kriteria dan ekspresi akan bernilai True jika setidaknya satu kriteria bernilai True
$not: mengembalikan negasi (kebalikan nilai) dari kriteria yang diberikan. Jika kriteria bernilai True maka operator $not akan menghasilkan nilai False dan sebaliknya
$nor: mengembalikan negasi dari operasi $or atau hanya akan memberikan nilai True jika semua ekspresi bernilai False
Contoh operator $and, $or, dan $not
Contoh 1. Mengambil Dokumen dengan field "stats.attack >= 100" atau "stats.defense >= 100"
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN OPERATOR $or #
# ------------------------------------------------------ #
docs_pokemon = list(
collection.find(
{
"$or": [
{"stats.attack": {"$gte": 100}},
{"stats.defense": {"$gte": 100}},
],
},
{"_id": 0, "name": 1, "stats": 1},
)
)
print("DAFTAR POKEMON")
print("DENGAN 'ATTACK' >= 100 ATAU 'DEFENSE' >= 100:\n")
pprint.pprint(docs_pokemon)# OUTPUT
DAFTAR POKEMON
DENGAN 'ATTACK' >= 100 ATAU 'DEFENSE' >= 100:
[{'name': 'Blastoise',
'stats': {'HP': 79, 'attack': 83, 'defense': 100, 'speed': 78}},
{'name': 'Sandslash',
'stats': {'HP': 75, 'attack': 100, 'defense': 110, 'speed': 65}},
{'name': 'Nidoking',
'stats': {'HP': 81, 'attack': 102, 'defense': 77, 'speed': 85}},
{'name': 'Dugtrio',
'stats': {'HP': 35, 'attack': 100, 'defense': 50, 'speed': 120}},
{'name': 'Primeape',
'stats': {'HP': 65, 'attack': 105, 'defense': 60, 'speed': 95}},
...
{'name': 'Mewtwo',
'stats': {'HP': 106, 'attack': 110, 'defense': 90, 'speed': 130}},
{'name': 'Mew',
'stats': {'HP': 100, 'attack': 100, 'defense': 100, 'speed': 100}}]Contoh 2. Mengambil Dokumen dengan "type" : ["Grass, "Bug" atau "Ground"] DAN "species" : ["Seed", "Flower", atau "Mushroom"] DAN "stats.attack", "stats.defense", ketiganya tidak lebih besar dari "stats.speed"100
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN OPERATOR 'and', 'nor', 'not' #
# ------------------------------------------------------ #
docs_pokemon = list(
collection.find(
{
"$and": [
{"type": {"$in": ["Grass", "Bug", "Ground"]}},
{"species": {"$in": ["Seed", "Flower", "Mushroom"]}},
],
"$nor": [
{"stats.attack": {"$gt": 100}},
{"stats.defense": {"$gt": 100}},
{"stats.speed": {"$gt": 100}},
],
},
{"_id": 0},
)
)
print("DAFTAR POKEMON")
print("'TIPE': 'GRASS', 'BUG' ATAU 'GROUND'")
print("'SPESIES': 'SEED','FLOWER', 'MUSHROOM'")
print("'ATTACK', 'DEFENSE', 'SPEED': TIDAK LEBIH BESAR DARI 100:\n")
pprint.pprint(docs_pokemon)
# "$nor": [
# {"stats.attack": {"$gt": 100}},
# {"stats.defense": {"$gt": 100}},
# {"stats.speed": {"$gt": 100}},
# ]
# bagian di atas dapat ditulis menggunakan $not:
# "stats.attack": {"$not": {"$gt": 100}},
# "stats.defense": {"$not": {"$gt": 100}},
# "stats.speed": {"$not": {"$gt": 100}},# OUTPUT
DAFTAR POKEMON
'TIPE': 'GRASS', 'BUG' ATAU 'GROUND'
'SPESIES': 'SEED','FLOWER', 'MUSHROOM'
'ATTACK', 'DEFENSE', 'SPEED': TIDAK LEBIH BESAR DARI 100:
[{'name': 'Bulbasaur',
'species': 'Seed',
'stats': {'HP': 45, 'attack': 49, 'defense': 49, 'speed': 45},
'successor': '0002',
'type': ['Grass', 'Poison']},
{'name': 'Ivysaur',
'predecessor': '0001',
'species': 'Seed',
'stats': {'HP': 60, 'attack': 62, 'defense': 63, 'speed': 60},
'successor': '0003',
'type': ['Grass', 'Poison']},
{'name': 'Venusaur',
'predecessor': '0002',
'species': 'Seed',
'stats': {'HP': 80, 'attack': 82, 'defense': 83, 'speed': 80},
'type': ['Grass', 'Poison']},
{'name': 'Vileplume',
'predecessor': '0044',
'species': 'Flower',
'stats': {'HP': 75, 'attack': 80, 'defense': 85, 'speed': 50},
...
'species': 'Flower',
'stats': {'HP': 50, 'attack': 75, 'defense': 35, 'speed': 40},
'successor': '0070',
'type': ['Grass', 'Poison']}]Regex dan Ekspresi
Pencarian dokumen pada mongoDB juga dapat dibuat dengan regular expression (regex). Untuk melakukan pencarian berdasarkan regex kita dapat menggunakan operator $regex. Selain itu, terdapat satu operator lainnya yang juga dapat dimanfaatkan dalam penentuan kriteria pencarian yaitu $expr.
Pada setiap contoh yang sudah dibuat, semua kriteria berupa nilai konstanta seperti "stats.attack" > 100 atau "species" = "Flame" dan sebagainya. Operator $expr memungkinkan kita melakukan pencarian dengan cara membandingkan nilai 1 field dan field lainnya. Sebagai contoh, kita dapat mengambil dokumen dimana nilai field "stats.attack" sama dengan nilai field "stats.defense" ataupun field lainnya.
Contoh operator $regex dan $expr
Contoh 1. Mengambil dokumen dengan field "name" diakhiri kata "saur" dan mengambil dokumen dengan field "name" diawali kata "ra" (case insensitif)
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN OPERATOR $regex #
# ------------------------------------------------------ #
poke_saur = list(
collection.find(
{"name": {"$regex": "saur$"}},
{"name": 1},
)
)
print("POKEMON ____SAUR :\n")
pprint.pprint(poke_saur)
poke_ra = list(
collection.find(
{"name": {"$regex": "^ra", "$options": "i"}},
{"name": 1},
)
)
print("\nPOKEMON RA____-- :\n")
pprint.pprint(poke_ra)# OUTPUT
POKEMON ____SAUR :
[{'_id': '0001', 'name': 'Bulbasaur'},
{'_id': '0002', 'name': 'Ivysaur'},
{'_id': '0003', 'name': 'Venusaur'}]
POKEMON RA____-- :
[{'_id': '0019', 'name': 'Rattata'},
{'_id': '0020', 'name': 'Raticate'},
{'_id': '0026', 'name': 'Raichu'},
{'_id': '0078', 'name': 'Rapidash'}]Contoh 2.
# ------------------------------------------------------ #
# MENGAMBIL DOKUMEN DENGAN $expr #
# ------------------------------------------------------ #
balance_pokemon = list(
collection.find(
{"$expr": {"$eq": ["$stats.attack", "$stats.defense"]}},
{"_id": 0, "name": 1, "stats": 1},
)
)
print("\nPOKEMON ATTACK = DEFENSE: \n")
pprint.pprint(balance_pokemon)# OUTPUT
POKEMON ATTACK = DEFENSE:
[{'name': 'Bulbasaur',
'stats': {'HP': 45, 'attack': 49, 'defense': 49, 'speed': 45}},
{'name': 'Poliwhirl',
'stats': {'HP': 65, 'attack': 65, 'defense': 65, 'speed': 90}},
{'name': 'Poliwrath',
'stats': {'HP': 90, 'attack': 95, 'defense': 95, 'speed': 70}},
{'name': 'Slowpoke',
'stats': {'HP': 90, 'attack': 65, 'defense': 65, 'speed': 15}},
{'name': 'Chansey',
'stats': {'HP': 250, 'attack': 5, 'defense': 5, 'speed': 50}},
{'name': 'Ditto',
'stats': {'HP': 48, 'attack': 48, 'defense': 48, 'speed': 48}},
{'name': 'Mew',
'stats': {'HP': 100, 'attack': 100, 'defense': 100, 'speed': 100}}]Ringkasan
Pada bagian pertama ini kita sudah menyelesaikan topik penyiapan database mongoDB pada docker serta operasi pembuatan dokumen (create) dan pembacaan dokumen (read) mongoDB melalui python. Terdapat setidaknya 4 metode yang dapat digunakan untuk melakukan operasi-operasi tersebut meliputi metode insert_one, insert_many, find_one, dan find. Selain itu, terdapat pula berbagai operator yang memungkinkan kita mengatur kriteria pengambilan dokumen secara lebih spesifik.
Pada bagian kedua topik akan dilanjutkan dengan pembahasan metode update dan delete dokumen serta agregasi dan penggunaan pipeline untuk melakukan operasi yang lebih kompleks.
Selanjutnya: Operasi CRUD Database MongoDB dengan Python (Bagian 2)
