Hướng dẫn MongoDB: Cách thiết lập và truy vấn cơ sở dữ liệu MongoDB

Các khái niệm cốt lõi về MongoDB

Từ nãy đến giờ tôi liên tục nhắc đến cơ sở dữ liệu tài liệu, nhưng chính xác chúng là gì? Dưới đây là các khái niệm chính:

• Tài liệu (Document): dữ liệu được lưu trong các đối tượng gọi là tài liệu. Nói đơn giản, tài liệu giống các đối tượng khóa-giá trị JSON. Một tài liệu tương đương một hàng trong bảng. Nếu bạn là lập trình viên Python, cứ xem tài liệu như một dictionary là ổn. Chỉ cần nhớ tài liệu có thể lồng tài liệu bên trong, đây là một đặc trưng quan trọng của cơ sở dữ liệu tài liệu.
• Bộ sưu tập (Collection): collections giống như bảng trong cơ sở dữ liệu quan hệ, nhưng thay vì chứa hàng, chúng chứa — bạn đoán đúng rồi — tài liệu. Collection là các cấu trúc dữ liệu khổng lồ có thể chứa hàng nghìn đến hàng triệu dictionary.
• Không lược đồ (Schema-less): Đây là điểm thú vị. Một collection có thể chứa các tài liệu với kích thước khác nhau. Ví dụ, tài liệu 1 có 10 cặp khóa-giá trị trong khi tài liệu 2 có 15 (miễn là thông tin cùng danh mục/chủ đề, như sản phẩm, để collection có ý nghĩa).

Dưới đây là một bảng tóm tắt rất hay về khác biệt giữa cơ sở dữ liệu quan hệ và cơ sở dữ liệu tài liệu:

Hãy bắt tay làm việc với tài liệu trong MongoDB!

Thiết lập MongoDB: Kết nối tới nguồn dữ liệu

Để truy vấn cơ sở dữ liệu tài liệu, ta cần cài đặt máy chủ MongoDB. Dưới đây là hướng dẫn theo nền tảng:

• Với Windows, làm theo hướng dẫn tại liên kết này.
• Với hệ thống giống Unix, bạn có thể cài MongoDB từ terminal:

$ sudo apt-get install -y mongodb

Sau đó, trong môi trường ảo, cài các thư viện pymongo và requests. pymongo là adapter Python chính thức cho máy chủ MongoDB. Ta sẽ cần thư viện requests để lấy dữ liệu từ một API.

$ pip install pymongo
$ pip install requests

Tiếp theo, từ terminal, khởi động máy chủ MongoDB với lệnh sau:

$ sudo service mongodb start

Giờ ta đã sẵn sàng nạp dữ liệu vào cơ sở dữ liệu tài liệu. Có hai kịch bản:

1. Bạn có dữ liệu cục bộ ở định dạng phù hợp như JSON, BSON, YAML hoặc XML.
2. Bạn cần lấy dữ liệu từ nguồn bên ngoài, thường là API.

Chúng ta sẽ làm cả hai. Trước hết, hãy nạp một collection tên drone_races.json cục bộ. Đoạn mã như sau:

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)

Hai đối tượng quan trọng nhất với chúng ta là drones (một cơ sở dữ liệu) và races (một collection). Phần lớn hàm/phương thức sẽ liên quan đến collection. Đối tượng cơ sở dữ liệu chủ yếu dùng để quản lý các collection.

Giờ hãy xem cách nạp cùng dữ liệu đó qua API. Tôi đã lưu thông tin dưới dạng API bằng dịch vụ Mockaroo. Đoạn mã đây:

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.")

Chúng ta đã nạp một số dữ liệu vào collection races của cơ sở dữ liệu tài liệu drones, hay chưa? Hãy kiểm tra bằng các truy vấn!

Các truy vấn MongoDB cơ bản

Đếm tài liệu trong MongoDB

Ta cần đếm số tài liệu bên trong để biết collection có dữ liệu không. Ta sẽ dùng phương thức count_documents để làm điều đó:

>>> races.count_documents({})
9040

Lưu ý dictionary rỗng được truyền vào count_documents. Dictionary đó được gọi là bộ lọc (filter) trong MongoDB. Khi đi tiếp trong bài, ta sẽ học cách điền dictionary để tạo các bộ lọc khác nhau. Hiện tại, ta chưa có bộ lọc. Mã trên tương tự SELECT COUNT(*) FROM table_name trong SQL.

Chúng ta có 9040 tài liệu — tuyệt! Giờ hãy xem một ít dữ liệu.

Trích xuất một tài liệu trong MongoDB

Để xem một tài liệu với pymongo, ta có thể dùng phương thức 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'}

Hãy để ý các trường (key) của tài liệu này. Nó lưu thông tin về một cuộc đua drone và bao gồm các thông tin như:

• Số vòng đua
• Điều kiện thời tiết lúc diễn ra trận
• Các phi công (không phải tất cả) trong trận
• Nhà tài trợ của trận, v.v.

Tài liệu cũng có trường bắt buộc _id, là một hash duy nhất.

Chọn tất cả tài liệu trong MongoDB

count_documents luôn trả về một con số, nhưng đôi khi, ta muốn xem dữ liệu mà truy vấn khớp. Để làm vậy, ta có thể dùng “anh cả” của find_one, đó là 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 với truy vấn rỗng (không tham số) trả về các tài liệu lần lượt, nhưng đó không phải điều ta muốn! Ta muốn thực hiện truy vấn để trả lời những câu hỏi thú vị về dữ liệu. Đây là lúc các tài liệu bộ lọc phát huy tác dụng.

Chọn theo điều kiện trong MongoDB

Hãy bắt đầu với các bộ lọc đơn giản nhất — tìm các tài liệu có trường bằng một giá trị nào đó. Điều này tương đương:

SELECT *
 FROM table_name
WHERE field = value

Hãy làm điều đó trong MongoDB:

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

fat_shark_races = races.count_documents(criteria)
fat_shark_races

6194

Ở trên, ta chọn các trận có "Fat Shark" là nhà tài trợ. Cú pháp chỉ đơn giản là một dictionary ánh xạ trường sponsors tới "Fat Shark".

Ngôn ngữ truy vấn MongoDB sẽ không đúng nghĩa “ngôn ngữ” nếu thiếu các toán tử so sánh. Đây là cách dùng toán tử “nhỏ hơn”:

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

quick_races = races.count_documents(criteria)
quick_races

3061

Truy vấn trên giới thiệu bốn đặc điểm mới của ngôn ngữ truy vấn MongoDB (MQL):

• Bạn có thể truy cập trường con với cú pháp dấu chấm. pilots.qualification_time trích xuất thời gian vòng loại được lồng trong trường pilots.
• Hầu hết toán tử trong MQL bắt đầu bằng ký hiệu dollar.
• Các toán tử được dùng trong một tài liệu lồng như trên.
• $lt là toán tử “nhỏ hơn”.

Vậy kết quả truy vấn này cho biết có 3061 trận mà một phi công có thời gian vòng loại dưới 10 giây. Truy vấn này khả thi nhờ toán tử $lt. Dưới đây là “anh chị em” của nó:

• $lte: nhỏ hơn hoặc bằng
• $gt: lớn hơn
• $gte: lớn hơn hoặc bằng.

Chúng có cùng cú pháp với $lt.

Chọn với các toán tử logic trong MongoDB

MQL cũng có các toán tử logic như $and và $or. Hãy bắt đầu với toán tử thứ hai.

Chúng ta sẽ truy xuất các trận có địa điểm là Vương quốc Anh hoặc nhà tài trợ là Etisalat:

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

>>> races.count_documents(criteria)

6223

Một lần nữa, dùng nút Explain code để xem giải thích chi tiết.

Có 6223 tài liệu khớp tiêu chí. Để dùng logic OR cho nhiều giá trị của cùng một trường, ta có thể dùng toán tử $in.

Ví dụ, ta có thể kiểm tra điều kiện thời tiết xấu như sau:

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

>>> races.count_documents(criteria)

5508

Truy vấn này sẽ rất phiền nếu viết bằng toán tử $or. Giờ đến $and.

Lần này, ta muốn tìm các trận có địa điểm là Australia VÀ nhà tài trợ là Fat Shark. Đây là cách làm với $and:

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

Nhưng thực tế, bạn sẽ hiếm khi dùng $and vì có thể triển khai đơn giản hơn nhiều:

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

races.count_documents(criteria)
193

Chỉ cần thêm nhiều cặp khóa-giá trị vào tài liệu bộ lọc là đạt logic AND.

Cuối cùng là toán tử $nin, dùng để kiểm tra không thuộc tập. Ví dụ, ta có thể trả về tất cả các trận không diễn ra ở Hoa Kỳ, Vương quốc Anh hoặc Australia:

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

>>> races.count_documents(criteria)
126

Điều này chỉ còn lại Các Tiểu vương quốc Ả Rập Thống nhất là quốc gia, vì thế truy vấn trên thực ra có thể viết là:

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

>>> races.count_documents(criteria)
126

Nhưng bạn đã hiểu ý tưởng.

Truy vấn giá trị null hoặc thiếu trong MongoDB

Kiểm tra giá trị null hoặc thiếu là thao tác phổ quát trong mọi tác vụ phân tích dữ liệu. Do đó, MongoDB có toán tử dành cho việc này — $exists. Dưới đây là hai ví dụ kiểm tra một trường có tồn tại hay không:

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

>>> races.count_documents(criteria)

0

Hmm, hóa ra district Trường laps không tồn tại trong bất kỳ tài liệu nào. Tuy nhiên, nó phải tồn tại trong mọi tài liệu vì là thông tin then chốt về các trận đua.

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

races.count_documents(criteria)
9040

Đúng như kỳ vọng, tất cả tài liệu đều có trường laps. Nhưng còn các trường tồn tại nhưng có giá trị null thì sao? Ta cũng có thể kiểm tra:

criteria = {"pilots.finishing_position": None}

races.count_documents(criteria)
0

Bằng cách dùng đối tượng dựng sẵn None trong Python, ta có thể kiểm tra tính thiếu vắng của giá trị ở bất kỳ trường nào.

Cũng có những tình huống nâng cao cần kiểm tra null hoặc sự tồn tại. Ví dụ, bạn có thể muốn kiểm tra một số phần tử của các mảng lồng khổng lồ có tồn tại không.

Để làm điều này, ta có thể dùng cú pháp đánh chỉ số mảng trong MQL. Chẳng hạn, để tìm các trận chỉ có một nhà tài trợ, ta cần kiểm tra phần tử thứ hai của mảng sponsors có tồn tại không:

# Đếm bắt đầu từ 0 như thường lệ
criteria = {"sponsors.1": {"$exists": False}}

races.count_documents(criteria)
2929

Và nó đơn giản như thêm số chỉ mục của phần tử vào khóa. Vậy là trong collection của chúng ta, gần 3000 trận chỉ có một đơn vị tài trợ.

Cú pháp đánh chỉ số mảng này dùng được với nhiều toán tử khác, không chỉ $exists.

Projection (giới hạn trường)

Điều cuối cùng chúng ta sẽ đề cập trong hướng dẫn là projection. Từ đầu đến giờ, kết quả truy vấn của ta bao gồm mọi trường trong mỗi tài liệu. Điều này không lý tưởng khi tài liệu có hàng trăm trường. Hãy tưởng tượng những đầu ra rối mắt khi bạn in chúng!

Vì vậy, để chọn các trường muốn trả về, ta có thể dùng projection. Cách làm như sau:

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

Trong trường hợp trên, ta viết tiêu chí lọc như thường lệ nhưng lần này, ta định nghĩa thêm một tài liệu với bốn trường đặt thành 1. Nếu truyền tài liệu projection này làm tham số thứ hai cho find hoặc count_documents, ta sẽ chỉ nhận các trường đặt 1 trong đầu ra.

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

Mặc dù ta chỉ chọn bốn trường, trường _id “cứng đầu” vẫn len vào bằng cách nào đó. Để loại bỏ hành vi này, đặt nó thành 0 trong 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']}

Giờ thì “đẹp” hơn rồi.

Cuối cùng, để trả về tất cả trừ một vài trường, ta đặt các trường đó thành 0:

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

# Tiêu chí rỗng cho ví dụ này
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'}

Như bạn thấy, lần này ta có tất cả các trường trừ _id, league và pilots.

Kết luận

Hướng dẫn này chưa lột tả hết quy mô đồ sộ của MongoDB với tư cách công cụ quản trị cơ sở dữ liệu. Hôm nay, chúng ta chỉ đề cập đến truy vấn GET (truy vấn lấy thông tin), nhưng MongoDB cũng cho phép chuyên gia dữ liệu chèn, cập nhật hoặc xóa thông tin trong cơ sở dữ liệu tài liệu. Chúng ta cũng bỏ qua cả một lớp truy vấn — tổng hợp (aggregation).

Tất cả các chủ đề này nằm ngoài phạm vi bài viết và cần tài nguyên bổ sung để học. Sao bạn không xem thử những nội dung sau:

• Khóa học giới thiệu dùng MongoDB trong khoa học dữ liệu với Python — một khóa toàn diện cũng bao gồm các truy vấn nâng cao như aggregation
• Giới thiệu MongoDB trong Python — Một hướng dẫn MongoDB khác đề cập thao tác CRUD (tạo, đọc, cập nhật, xóa) với pymongo.
• Khóa học về khái niệm NoSQL — nếu bạn quan tâm đến cơ sở dữ liệu NoSQL, khóa học này dành cho bạn. Ngoài cơ sở dữ liệu tài liệu, nó còn đề cập các CSDL phi quan hệ khác.