MongoDB-tutorial: MongoDB-databases instellen en query’s uitvoeren

Kernconcepten rond MongoDB

Ik heb het tot nu toe steeds over documentdatabases gehad, maar wat zijn dat nu eigenlijk? Dit zijn de belangrijkste concepten:

• Documenten: data wordt opgeslagen in objecten die documenten worden genoemd. Simpel gezegd lijken documenten op JSON key-value-objecten. Eén document is gelijk aan een rij in een tabel. Ben je Python-programmeur, dan kun je aan een document denken als een dictionary, en dan zit je goed. Onthoud alleen dat documenten geneste documenten kunnen hebben — een van de belangrijkste kenmerken van documentdatabases.
• Collecties: collecties zijn zoals tabellen in relationele databases, maar in plaats van rijen bevatten ze — je raadt het al — documenten. Collecties zijn enorme datastructuren die duizenden of miljoenen dictionaries kunnen bevatten.
• Schema-loos: Hier wordt het interessant. Een collectie kan documenten van verschillende grootte hebben. Zo kan document 1 tien key-value-paren hebben, terwijl document 2 er vijftien heeft (zolang de informatie over dezelfde categorie/onderwerp gaat — zoals producten — zodat de collectie logisch blijft).

Hier is een mooie tabel die de verschillen samenvat tussen relationele databases en documentdatabases:

Laten we nu echt met documenten in MongoDB aan de slag gaan!

MongoDB instellen: verbinden met databronnen

Om documentdatabases te bevragen, moeten we de MongoDB-server installeren. Hier zijn de platformspecifieke instructies:

• Voor Windows: volg de instructies via deze link.
• Voor Unix-achtige systemen kun je MongoDB via de terminal installeren:

$ sudo apt-get install -y mongodb

Installeer vervolgens binnen een virtual environment de libraries pymongo en requests. pymongo is de officiële Python-adapter voor de MongoDB-server. We hebben de requests-library nodig om data uit een API op te halen.

$ pip install pymongo
$ pip install requests

Start daarna vanuit de terminal de MongoDB-server met het volgende commando:

$ sudo service mongodb start

Nu zijn we klaar om data in een documentdatabase te laden. Daarbij zijn er twee scenario’s:

1. Je hebt lokaal data in geschikte formaten zoals JSON, BSON, YAML of XML.
2. Je moet data ophalen uit externe bronnen, meestal API’s.

We behandelen allebei. Laten we eerst lokaal een collectie genaamd drone_races.json laden. Zo doe je dat:

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)

De twee belangrijkste objecten voor ons zijn drones (een database) en races (een collectie). De meeste functies en methoden hebben betrekking op collecties. Databaseobjecten worden vooral gebruikt om collecties te beheren.

Bekijk nu hoe we dezelfde data via een API laden. Ik heb de informatie als een API opgeslagen met een service genaamd Mockaroo. Hier is de snippet:

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

We hebben data geladen in de collectie races van de documentdatabase drones — of toch niet? Laten we het controleren met query’s!

Eenvoudige MongoDB-query’s

Documenten tellen in MongoDB

We moeten de documenten tellen om te zien of er data in een collectie staat. We gebruiken daarvoor de methode count_documents:

>>> races.count_documents({})
9040

Let op de lege dictionary die aan count_documents wordt doorgegeven. Die dictionary heet een filter in MongoDB. In de rest van de tutorial leren we hoe we de dictionary vullen om verschillende soorten filters te maken. Nu hebben we geen filter. De bovenstaande code is hetzelfde als SELECT COUNT(*) FROM table_name in SQL.

We hebben 9040 documenten — yes! Laten we nu naar wat data kijken.

Eén document ophalen in MongoDB

Om één document te bekijken met pymongo, kunnen we de methode find_one gebruiken:

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'}

Let op de velden (keys) van dit document. Het slaat informatie op over één dronerace en bevat zaken als:

• Het aantal ronden
• Weersomstandigheden tijdens de wedstrijd
• De piloten (niet allemaal) tijdens de wedstrijd
• Wedstrijdsponsors, enzovoort.

Het document heeft ook een verplicht veld _id, een unieke hash.

Alle documenten selecteren in MongoDB

count_documents geeft altijd een getal terug, maar soms willen we de data bekijken die door onze query wordt opgehaald. Daarvoor kunnen we de grote broer van find_one gebruiken: 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 met een lege query (geen argumenten) geeft documenten één voor één terug, maar dat is niet wat we willen! We willen query’s uitvoeren om interessante vragen over onze data te beantwoorden. Daar komen filterdocumenten van pas.

Selecteren op basis van een voorwaarde in MongoDB

Laten we beginnen met de simpelste filters — documenten matchen waarbij een veld gelijk is aan een bepaalde waarde. Dit komt overeen met:

SELECT *
 FROM table_name
WHERE field = value

Laten we dit in MongoDB doen:

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

fat_shark_races = races.count_documents(criteria)
fat_shark_races

6194

Hierboven kiezen we de races met "Fat Shark" als sponsor. De syntax is simpelweg een dictionary die het veld sponsors aan "Fat Shark" koppelt.

De MongoDB-querytaal zou geen taal zijn zonder ongelijkheidsoperatoren. Zo gebruik je de “kleiner dan”-operator:

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

quick_races = races.count_documents(criteria)
quick_races

3061

De bovenstaande query introduceert vier nieuwe kenmerken van de MongoDB Query Language (MQL):

• Je kunt subvelden benaderen met dotnotatie. pilots.qualification_time haalt de geneste qualification time binnen het veld pilots op.
• Vrijwel alle operatoren in MQL beginnen met een dollarteken.
• Operatoren worden gebruikt in een genest document zoals hierboven.
• $lt staat voor de “kleiner dan”-operator.

Het resultaat vertelt ons dat er 3061 wedstrijden waren waarin een piloot minder dan 10 seconden kwalificatietijd had. Deze query was mogelijk met de operator $lt. Dit zijn de broertjes en zusjes:

• $lte: kleiner dan of gelijk aan
• $gt: groter dan
• $gte: groter dan of gelijk aan.

Ze hebben dezelfde syntax als $lt.

Selecteren met logische conditionele operatoren in MongoDB

MQL bevat ook logische conditionele operatoren zoals $and en $or. Laten we met de laatste beginnen.

We halen races op met ofwel het Verenigd Koninkrijk als locatie of Etisalat als sponsor:

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

>>> races.count_documents(criteria)

6223

Gebruik opnieuw de knop Explain code voor een gedetailleerde uitleg.

Er zijn 6223 documenten die aan onze criteria voldoen. Wil je een OR-logica voor meerdere waarden binnen hetzelfde veld, gebruik dan de operator $in.

Zo kun je bijvoorbeeld op slechte weersomstandigheden controleren:

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

>>> races.count_documents(criteria)

5508

Deze query zou met de operator $or onhandig zijn om te schrijven. Dan nu $and.

Dit keer willen we races vinden met Australië als locatie EN Fat Shark als sponsor. Zo doe je dat met $and:

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

In de praktijk gebruik je $and echter zelden, want het kan veel eenvoudiger:

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

races.count_documents(criteria)
193

Voeg simpelweg meer key-value-paren toe aan het filterdocument om de AND-logica te krijgen.

Tot slot is er de operator $nin, die controleert op niet-lidmaatschap. We kunnen bijvoorbeeld alle wedstrijden teruggeven die niet in de Verenigde Staten, het Verenigd Koninkrijk of Australië zijn gehouden:

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

>>> races.count_documents(criteria)
126

Dit laat alleen de Verenigde Arabische Emiraten over als land, dus de bovenstaande query had ook zo geschreven kunnen worden:

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

>>> races.count_documents(criteria)
126

Maar je snapt het idee.

Zoeken naar null- of ontbrekende waarden in MongoDB

Controleren op null- of ontbrekende waarden is een universele bewerking in alle data-analytische taken. Daar is in MongoDB een operator voor — $exists. Hier zijn twee voorbeelden die controleren of een bepaald veld bestaat:

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

>>> races.count_documents(criteria)

0

Hmm, het blijkt dat het veld district niet bestaat in een van de documenten. Het veld laps moet echter in alle documenten bestaan, omdat het cruciale informatie over races bevat.

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

races.count_documents(criteria)
9040

Zoals verwacht hebben alle documenten het veld laps. Maar hoe zit het met velden die wel bestaan maar de waarde null hebben? Ook dat kunnen we controleren:

criteria = {"pilots.finishing_position": None}

races.count_documents(criteria)
0

Met het ingebouwde object None in Python kun je elk veld op ontbrekende waarde controleren.

Er zijn ook geavanceerdere scenario’s die null- of existence-checks vereisen. Misschien wil je bijvoorbeeld controleren of bepaalde elementen in grote geneste arrays bestaan.

Daarvoor kunnen we array-indexering in MQL gebruiken. Zo moeten we, om races met slechts één sponsor te vinden, checken of het tweede element van de array sponsors bestaat:

# Counting starts with 0 as always
criteria = {"sponsors.1": {"$exists": False}}

races.count_documents(criteria)
2929

En het is zo eenvoudig als het indexnummer aan de key toevoegen. In onze collectie werden dus bijna 3000 races door slechts één partij gesponsord.

Deze array-indexeringssyntax werkt voor veel andere operatoren, niet alleen $exists.

Projecties (velden beperken)

Het laatste onderdeel in deze tutorial zijn projecties. Tot nu toe bevatten onze queryresultaten elk veld in elk document. Dat is niet ideaal als je documenten honderden velden hebben. Stel je de onleesbare output voor wanneer je ze print!

Om de velden te kiezen die we terug willen krijgen, gebruiken we projecties. Zo werkt het:

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

In dit geval schrijven we onze filtercriteria zoals gewoonlijk, maar definiëren we daarnaast een document met vier velden op 1. Als we dit projection-document als tweede argument doorgeven aan find of count_documents, krijgen we in de output alleen de velden die op 1 staan.

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

Hoewel we slechts vier velden kozen, is het hardnekkige veld _id er toch bijgekomen. Om dit te onderdrukken, zet je het op 0 in de 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']}

Dat staat een stuk netter.

Wil je tot slot alles teruggeven behalve een paar velden, zet die velden dan op 0:

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

# Empty criteria for this one
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'}

Zoals je ziet hebben we dit keer alle velden behalve _id, league en pilots.

Conclusie

Deze tutorial doet geen recht aan de enorme omvang van MongoDB als databasebeheertool. Vandaag hebben we alleen GET-query’s behandeld (query’s om informatie op te halen), maar MongoDB laat dataspecialisten ook informatie invoegen, updaten of verwijderen in documentdatabases. We hebben daarnaast een hele klasse query’s overgeslagen — aggregaties.

Al deze onderwerpen vallen buiten de scope van dit artikel en vereisen extra bronnen om ze te leren. Bekijk deze eens:

• Introductie tot het gebruik van MongoDB in data science met Python — een uitgebreide course die ook geavanceerde query’s zoals aggregaties behandelt
• Intro tot MongoDB in Python — nog een MongoDB-tutorial die CRUD (create, read, update en delete) met pymongo behandelt.
• NoSQL-concepten — als je geïnteresseerd bent in NoSQL-databases, is deze course iets voor jou. Naast documentdatabases behandelt het ook andere niet-relationele databases.