Tutorial MongoDB: Cara Menyiapkan dan Melakukan Query pada Database MongoDB

Konsep Inti Seputar MongoDB

Saya sudah berulang kali menyebut database dokumen sampai titik ini, tetapi sebenarnya apa itu? Berikut konsep utamanya:

• Dokumen: data disimpan dalam objek yang disebut dokumen. Secara sederhana, dokumen mirip dengan objek key-value JSON. Satu dokumen setara dengan satu baris dalam tabel. Jika Anda programmer Python, anggap saja dokumen sebagai dictionary, dan itu sudah tepat. Ingat saja bahwa dokumen dapat memiliki dokumen bersarang, yang merupakan salah satu fitur utama database dokumen.
• Koleksi: koleksi seperti tabel dalam database relasional, tetapi alih-alih berisi baris, mereka berisi, ya, dokumen. Koleksi adalah struktur data besar yang dapat berisi ribuan atau jutaan dictionary.
• Tanpa skema: Di sinilah menariknya. Satu koleksi dapat memiliki dokumen dengan ukuran bervariasi. Misalnya, dokumen 1 bisa memiliki 10 pasangan key-value sementara dokumen 2 bisa memiliki 15 (selama informasinya masih dalam kategori/topik yang sama, seperti produk, agar koleksi tetap masuk akal).

Berikut tabel ringkas yang merangkum perbedaan antara database relasional dan database dokumen:

Mari benar-benar mulai bekerja dengan dokumen di MongoDB!

Penyiapan MongoDB: Menghubungkan ke Sumber Data

Untuk melakukan query pada database dokumen, kita perlu memasang server MongoDB. Berikut instruksi spesifik platform:

• Untuk Windows, ikuti instruksi pada tautan ini.
• Untuk sistem mirip Unix, Anda dapat memasang MongoDB dari terminal:

$ sudo apt-get install -y mongodb

Lalu, di dalam lingkungan virtual, pasang pustaka pymongo dan requests. pymongo adalah adapter Python resmi untuk server MongoDB. Kita akan memerlukan pustaka requests untuk mengambil data dari API.

$ pip install pymongo
$ pip install requests

Selanjutnya, dari terminal, jalankan server MongoDB dengan perintah berikut:

$ sudo service mongodb start

Sekarang, kita siap memuat beberapa data ke dalam database dokumen. Ada dua skenario saat melakukannya:

1. Anda memiliki data secara lokal dalam format yang sesuai seperti JSON, BSON, YAML, atau XML.
2. Anda perlu mengambil data dari sumber eksternal, biasanya API.

Kita akan membahas keduanya. Pertama, mari muat koleksi bernama drone_races.json secara lokal. Berikut cuplikannya:

import json

from pymongo import MongoClient

# Establish connection to MongoDB
client = MongoClient("localhost", 27017)
# Create a database named "drones"
drones = client["drones"]
# Create a collection named "races"
races = drones["races"]

# Load dataset into MongoDB
with open("data/drone_races.json", "r") as file:
   data = json.load(file)
   races.insert_many(data)

Dua objek terpenting bagi kita adalah drones (sebuah database) dan races (sebuah koleksi). Sebagian besar fungsi dan metode akan terkait dengan koleksi. Objek database sebagian besar digunakan untuk mengelola koleksi.

Sekarang, mari lihat cara memuat data yang sama menggunakan API. Saya telah menyimpan informasi tersebut sebagai API menggunakan layanan bernama Mockaroo. Berikut cuplikannya:

import requests
from pymongo import MongoClient

# Fetch data from the API
api_url = (
   "https://my.api.mockaroo.com/drone_race_matches.json?key=6f5a6b50"
)
response = requests.get(api_url)

if response.status_code == 200:
   data = response.json()  # Get the JSON data from the API

   # Establish a connection to MongoDB
   client = MongoClient()

   # Access or create a specific database
   drones = client["drones"]

   # Access or create a specific collection within the database
   races = drones["races"]

   # Insert the fetched data into the MongoDB collection
   races.insert_many(data)
else:
   print("Failed to fetch data from the API.")

Kita telah memuat beberapa data ke dalam koleksi races dari database dokumen drones, atau benarkah? Mari periksa dengan menggunakan query!

Query MongoDB Dasar

Menghitung dokumen di MongoDB

Kita perlu menghitung dokumen di dalamnya untuk mengetahui apakah ada data dalam sebuah koleksi. Kita akan menggunakan metode count_documents untuk melakukannya:

>>> races.count_documents({})
9040

Perhatikan dictionary kosong yang diberikan ke count_documents. Dictionary itu disebut filter di MongoDB. Seiring berjalannya tutorial, kita akan mempelajari cara mengisi dictionary untuk membuat berbagai jenis filter. Saat ini, kita belum memiliki filter. Kode di atas sama dengan SELECT COUNT(*) FROM table_name dalam SQL.

Kita mendapatkan 9040 dokumen — yay! Sekarang, mari lihat sebagian data.

Mengekstrak satu dokumen di MongoDB

Untuk melihat satu dokumen dengan pymongo, kita dapat menggunakan metode find_one:

from pprint import pprint

>>> pprint(races.find_one())
{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'laps': 3,
'league': 'F1 Drones',
'location': {'city': 'Ford',
             'country': 'United Kingdom',
             'date': 'error: invalid date "2024-10-25"',
             'venue': 'Manhattan Seas'},
'name': 'Honorable',
'pilots': {'drone': 'DJI3-old',
           'finishing_position': 66,
           'name': 'Kariotta Cow',
           'qualification_time': 27.39,
           'team': 'Sky Crusaders',
           'telemetry': {'altitude': 34.3,
                         'battery_voltage': 12.1,
                         'speed': 68.3,
                         'timestamp': 'error: invalid date '
                                      '"2024-10-25T14:09:26Z"'}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'weather_conditions': 'snowy'}

Perhatikan field (key) dari dokumen ini. Dokumen ini menyimpan informasi tentang satu balapan drone dan mencakup informasi seperti:

• Jumlah putaran
• Kondisi cuaca saat pertandingan
• Para pilot (tidak semuanya) selama pertandingan
• Sponsor pertandingan, dan seterusnya.

Dokumen juga memiliki field wajib _id, yang merupakan hash unik.

Memilih semua dokumen di MongoDB

count_documents selalu mengembalikan angka, tetapi terkadang, kita ingin melihat data yang cocok dengan query kita. Untuk melakukannya, kita dapat menggunakan versi lebih kuat dari find_one, yaitu find:

from pprint import pprint

for race in races.find():
   pprint(race)
   break

{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'laps': 3,
'league': 'F1 Drones',
'location': {'city': 'Ford',
             'country': 'United Kingdom',
             'date': 'error: invalid date "2024-10-25"',
             'venue': 'Manhattan Seas'},
'name': 'Honorable',
'pilots': {'drone': 'DJI3-old',
           'finishing_position': 66,
           'name': 'Kariotta Cow',
           'qualification_time': 27.39,
           'team': 'Sky Crusaders',
           'telemetry': {'altitude': 34.3,
                         'battery_voltage': 12.1,
                         'speed': 68.3,
                         'timestamp': 'error: invalid date '
                                      '"2024-10-25T14:09:26Z"'}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'weather_conditions': 'snowy'}

find dengan query kosong (tanpa argumen) mengembalikan dokumen satu per satu, namun itu bukan yang kita inginkan! Kita ingin menjalankan query agar dapat menjawab pertanyaan menarik tentang data kita. Di sinilah dokumen filter akan sangat berguna.

Memilih berdasarkan suatu kondisi di MongoDB

Mari mulai dengan filter paling sederhana — mencocokkan dokumen ketika suatu field bernilai sama dengan suatu nilai. Ini setara dengan:

SELECT *
 FROM table_name
WHERE field = value

Mari lakukan di MongoDB:

criteria = {"sponsors": "Fat Shark"}

fat_shark_races = races.count_documents(criteria)
fat_shark_races

6194

Di atas, kita memilih balapan dengan "Fat Shark" sebagai sponsor. Sintaksnya cukup dictionary yang memetakan field sponsors ke "Fat Shark".

Bahasa query MongoDB tidak akan disebut bahasa jika tidak memiliki beberapa operator ketaksamaan umum. Berikut cara menggunakan operator "kurang dari":

criteria = {"pilots.qualification_time": {"$lt": 10}}

quick_races = races.count_documents(criteria)
quick_races

3061

Query di atas memperkenalkan empat fitur baru dari bahasa query MongoDB (MQL):

• Anda dapat mengakses sub-field dengan notasi titik. pilots.qualification_time mengekstrak waktu kualifikasi yang bersarang di dalam field pilots.
• Hampir semua operator di MQL diawali dengan tanda dolar.
• Operator digunakan dalam dokumen bersarang seperti di atas.
• $lt adalah operator "kurang dari".

Jadi, hasil query ini memberi tahu kita bahwa ada 3061 pertandingan di mana salah satu pilot memiliki waktu kualifikasi kurang dari 10 detik. Query ini dimungkinkan dengan operator $lt. Berikut saudara-saudaranya:

• $lte: kurang dari atau sama dengan
• $gt: lebih dari
• $gte: lebih dari atau sama dengan.

Sintaksnya sama seperti $lt.

Memilih dengan operator kondisi logis di MongoDB

MQL juga menyertakan operator kondisi logis seperti $and dan $or. Mari mulai dengan yang terakhir.

Kita akan mengambil balapan dengan lokasi United Kingdom atau sponsor Etisalat:

criteria = {
   "$or": [
       {"location.country": "United Kingdom"},
       {"sponsors": "Etisalat"},
   ]
}

>>> races.count_documents(criteria)

6223

Sekali lagi, gunakan tombol Explain code untuk penjelasan terperinci.

Ada 6223 dokumen yang cocok dengan kriteria kita. Untuk menggunakan logika OR bagi beberapa nilai pada field yang sama, kita dapat menggunakan operator $in.

Sebagai contoh, kita dapat memeriksa kondisi cuaca buruk dengan cara berikut:

criteria = {
   "weather_conditions": {"$in": ["rainy", "snowy", "cloudy"]}
}

>>> races.count_documents(criteria)

5508

Query ini akan merepotkan jika ditulis dengan operator $or. Sekarang, lanjut ke $and.

Kali ini, kita ingin menemukan balapan dengan lokasi Australia DAN sponsor Fat Shark. Berikut cara melakukannya dengan $and:

criteria = {
   "$and": [
       {"location.country": "Australia"},
       {"sponsors": "Fat Shark"},
   ]
}
>>> races.count_documents(criteria)
193

Namun dalam praktiknya, Anda jarang menggunakan $and karena dapat diimplementasikan dengan cara yang jauh lebih sederhana:

criteria = {
   "location.country": "Australia",
   "sponsors": "Fat Shark",
}

races.count_documents(criteria)
193

Cukup tambahkan lebih banyak pasangan key-value ke dokumen filter untuk mendapatkan operator logis AND.

Akhirnya, ada operator $nin, yang memeriksa ketidakanggotaan. Misalnya, kita dapat mengembalikan semua pertandingan yang tidak diadakan di United States, United Kingdom, atau Australia:

criteria = {
   "location.country": {
       "$nin": ["United States", "United Kingdom", "Australia"]
   }
}

>>> races.count_documents(criteria)
126

Ini hanya menyisakan United Arab Emirates sebagai negara, jadi query di atas sebenarnya bisa ditulis sebagai:

criteria = {"location.country": "United Arab Emirates"}

>>> races.count_documents(criteria)
126

Namun, Anda paham maksudnya.

Melakukan query nilai null atau hilang di MongoDB

Memeriksa nilai null atau hilang adalah operasi universal dalam semua tugas analisis data. Karena itu, ada operator untuk itu di MongoDB — $exists. Berikut dua contoh yang memeriksa apakah field tertentu ada:

criteria = {"location.district": {"$exists": True}}

>>> races.count_documents(criteria)

0

Hmm, ternyata district Field laps tidak ada pada dokumen mana pun. Namun, field tersebut harus ada di semua dokumen karena merupakan informasi kunci tentang balapan.

criteria = {"laps": {"$exists": True}}

races.count_documents(criteria)
9040

Seperti yang diharapkan, semua dokumen memiliki field laps. Namun bagaimana dengan field yang ada tetapi bernilai null? Kita juga bisa memeriksanya:

criteria = {"pilots.finishing_position": None}

races.count_documents(criteria)
0

Dengan menggunakan objek bawaan None di Python, kita dapat memeriksa nilai suatu field apakah hilang.

Ada beberapa skenario lanjutan yang juga memerlukan pemeriksaan null atau keberadaan. Misalnya, Anda mungkin ingin memeriksa apakah elemen tertentu dari beberapa array bersarang yang besar ada.

Untuk melakukan ini, kita dapat menggunakan sintaks pengindeksan array di MQL. Misalnya, untuk menemukan balapan dengan hanya satu sponsor, kita perlu memeriksa apakah elemen kedua dari array sponsors ada:

# Penghitungan dimulai dari 0 seperti biasa
criteria = {"sponsors.1": {"$exists": False}}

races.count_documents(criteria)
2929

Dan semudah menambahkan nomor indeks elemen ke key. Jadi, dalam koleksi kita, hampir 3000 balapan disponsori oleh hanya satu entitas.

Sintaks pengindeksan array ini berfungsi untuk banyak operator lain, bukan hanya $exists.

Proyeksi (membatasi field)

Satu hal terakhir yang akan kita bahas dalam tutorial ini adalah proyeksi. Sampai titik ini, hasil query kita menyertakan setiap field dalam tiap dokumen. Ini tidak ideal ketika dokumen Anda memiliki ratusan field. Bayangkan betapa melelahkannya output saat Anda mencetaknya!

Jadi, untuk memilih field yang ingin kita kembalikan, kita dapat menggunakan proyeksi. Berikut caranya:

criteria = {"pilots.telemetry.speed": {"$gte": 20}}
projection = {
   "sponsors": 1,
   "location.country": 1,
   "pilots.telemetry.speed": 1,
   "pilots.name": 1,
}

fast_pilots = races.find(criteria, projection)

for pilot in fast_pilots:
   pprint(pilot)
   break

Pada kasus di atas, kita menulis kriteria filter seperti biasa tetapi kali ini kita mendefinisikan dokumen lain dengan empat field disetel ke 1. Jika kita meneruskan dokumen projection ini sebagai argumen kedua ke find atau count_documents, kita hanya akan mendapatkan field yang disetel ke 1 pada output.

{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'location': {'country': 'United Kingdom'},
'pilots': {'name': 'Kariotta Cow', 'telemetry': {'speed': 68.3}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat']}

Meskipun kita memilih hanya empat field, field _id yang bandel tetap ikut. Untuk menekan perilaku ini, setel ke 0 dalam dictionary projection:

criteria = {"pilots.telemetry.speed": {"$gte": 20}}
projection = {
   "sponsors": 1,
   "location.country": 1,
   "pilots.telemetry.speed": 1,
   "pilots.name": 1,
   "_id": 0,
}

fast_pilots = races.find(criteria, projection)

for pilot in fast_pilots:
   pprint(pilot)
   break

{'location': {'country': 'United Kingdom'},
'pilots': {'name': 'Kariotta Cow', 'telemetry': {'speed': 68.3}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat']}

Sekarang, ini lebih rapi.

Terakhir, untuk mengembalikan semua field kecuali beberapa, kita bisa menyetel field tersebut ke 0:

projection = {"_id": 0, "league": 0, "pilots": 0}

# Kriteria kosong untuk yang ini
races.find_one({}, projection)

{'name': 'Honorable',
'location': {'venue': 'Manhattan Seas',
 'city': 'Ford',
 'country': 'United Kingdom',
 'date': 'error: invalid date "2024-10-25"'},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'laps': 3,
'weather_conditions': 'snowy'}

Seperti yang Anda lihat, kali ini kita memiliki semua field kecuali _id, league, dan pilots.

Penutup

Tutorial ini belum sepenuhnya mencerminkan besarnya MongoDB sebagai alat manajemen database. Hari ini, kita hanya membahas query GET (query untuk mengambil informasi), tetapi MongoDB juga memungkinkan spesialis data untuk menyisipkan, memperbarui, atau menghapus informasi dalam database dokumen. Kita juga belum membahas satu kelas query — agregasi.

Semua topik ini berada di luar cakupan artikel dan memerlukan sumber daya tambahan untuk mempelajarinya. Mengapa tidak memeriksa yang berikut ini:

• Kursus pengantar penggunaan MongoDB dalam data science dengan Python — kursus komprehensif yang juga membahas query lanjutan seperti agregasi
• Pengantar MongoDB di Python — Tutorial MongoDB lain yang membahas operasi CRUD (create, read, update, delete) dengan pymongo.
• Kursus konsep NoSQL — jika Anda tertarik dengan database NoSQL, kursus ini untuk Anda. Selain database dokumen, kursus ini membahas database non-relasional lainnya.