Een uitgebreide NoSQL-tutorial met MongoDB

Nu de hoeveelheid data in het digitale tijdperk explodeert, zijn databases cruciaal voor het opslaan, beheren en analyseren van grote hoeveelheden gegevens. In grote lijnen zijn er twee soorten databases: SQL- en NoSQL-databases.

SQL-databases gebruiken een gestructureerd formaat, en de data is georganiseerd in tabellen met schema’s. In tegenstelling tot SQL-databases bieden NoSQL-databases een flexibel schema voor het opslaan van semi-gestructureerde en ongestructureerde data. Ze bieden de nodige infrastructuur om de enorme hoeveelheid data in het huidige digitale landschap te beheren en te benutten.

Deze uitgebreide gids behandelt de basisprincipes van NoSQL-databases en de verschillende typen NoSQL-databases met voorbeelden uit de industrie. Zodra we deze basis begrijpen, duiken we in MongoDB, een populaire NoSQL-database, en leren we hoe je CRUD‑operaties (Create, Retrieve, Update en Delete) uitvoert.

Wat is NoSQL?

NoSQL staat voor “Not Only SQL” en is ontwikkeld om de beperkingen van relationele databases aan te pakken. Relationele databases volgen een rigide structuur, hebben een tabelvorm en gebruiken SQL (Structured Query Language) voor datamanipulatie.

NoSQL-databases bieden een flexibelere aanpak voor het opslaan van semi‑gestructureerde en ongestructureerde data.

Het belangrijkste voordeel van NoSQL-databases is dat ze geschikt zijn voor het verwerken van grote hoeveelheden data met uiteenlopende structuren. NoSQL-databases zijn schema‑loos, wat zorgt voor meer wendbaarheid en schaalbaarheid.

Deze voordelen gaan echter gepaard met trade-offs. Ze hebben zwakkere consistentie en beperkte ondersteuning voor complexe queries. Ondanks deze beperkingen worden ze veel gebruikt vanwege de voordelen die ze bieden en vormen ze een aanvulling op SQL-databases.

Je kunt meer lezen over de belangrijkste verschillen tussen SQL- en NoSQL-databases en enkele tips over wanneer je welke kiest in een aparte tutorial.

Typen NoSQL-databases

Om te voldoen aan de behoeften van uiteenlopende use-cases gebruiken NoSQL-databases verschillende datamodellen voor het organiseren en benaderen van data. Dit zijn 4 veelvoorkomende typen NoSQL-databases.

1. Sleutel‑waarde‑paar‑gebaseerd is de eenvoudigste vorm van NoSQL-databases. De data wordt opgeslagen als sleutel‑waardeparen en kan met de sleutel worden opgehaald. Voorbeelden zijn Redis en Amazon DynamoDB.
2. Kolomgeoriënteerd organiseert data in kolommen in plaats van rijen. Deze structuur is efficiënt voor het ophalen van data per kolom. Apache Cassandra, HBase en Google Bigtable zijn kolomgeoriënteerd.
3. Grafen‑gebaseerd slaat data op in graafstructuren die bestaan uit knooppunten, verbindingen en eigenschappen. Neo4j en Amazon Neptune zijn populaire graafdatabases.
4. Documentgeoriënteerd slaat data op als JSON‑achtige documenten. De structuur van een document kan variëren en zelfs geneste data bevatten. Dit is een veelgebruikt type NoSQL-database. Voorbeelden zijn MongoDB en CouchDB.

Wil je meer leren over de verschillende typen databases? Raadpleeg dan onze tutorial, NoSQL Databases: What Every Data Scientist Needs to Know.

Nu je weet wat NoSQL is en welke typen NoSQL-databases er zijn, is het tijd voor hands‑on oefening met NoSQL-databases.

NoSQL-tutorial: een NoSQL-database ontwerpen voor een blogplatform

In een praktisch, realistisch voorbeeld duiken is essentieel om de concepten die we hebben behandeld te begrijpen en ermee te experimenteren. Laten we stap voor stap een NoSQL-tutorial doorlopen.

Stel dat je een eigen blogplatform wilt bouwen. Je wilt blogposts maken, reacties toestaan en ze up‑to‑date houden. Omdat je weet dat de data ongestructureerd is, begrijp je dat een NoSQL-database zoals MongoDB goed past bij deze use‑case.

MongoDB is een open‑source NoSQL-database. In plaats van tabellen gebruikt het JSON‑achtige documenten om data op te slaan. Dit maakt het eenvoudig om complexe structuren en relaties te representeren. Het is gemakkelijk om verschillende datatypen te beheren, waaronder tekst, cijfers of afbeeldingen, die waarschijnlijk in blogs voorkomen.

Laten we beginnen met het installeren van MongoDB op je machine.

1. MongoDB installeren

MongoDB installeren is vrij eenvoudig. We kunnen het downloaden en installeren via de officiële MongoDB‑website. De instructies verschillen per besturingssysteem, dus bekijk de installatie-instructies voor jouw besturingssysteem in de officiële documentatie.

Start na de installatie MongoDB. Open simpelweg de terminal en voer het volgende in, afhankelijk van je besturingssysteem:

// Linux
sudo systemctl start mongod

//Mac OS
brew services start mongodb-community@7.0

We krijgen een output met “Successfully started”, zoals hieronder te zien is.

Output: Starting MongoDB. (Deze en alle onderstaande afbeeldingen door de auteur)

De MongoDB‑installatie bevat een MongoDB‑shell genaamd mongosh, die we kunnen gebruiken om met de MongoDB‑database te communiceren. Daarvoor is dus geen extra installatie nodig.

Start de MongoDB‑shell door de volgende commandoregel in je terminal uit te voeren:

mongosh

Het uitvoeren van het commando mongosh geeft de onderstaande output, wat aangeeft dat de verbinding met je database tot stand is gebracht.

Start de MongoDB‑shell.

Met MongoDB geïnstalleerd, gaan we door met het definiëren van ons datamodel.

2. Het datamodel definiëren

We maken een database genaamd “blog” en twee collecties met de naam “posts” en “comments”. De collectie “posts” is voor de blogberichten en de collectie “comments” voor de reacties op die berichten.

Elk postdocument krijgt velden voor de titel, inhoud, auteur en aanmaakdatum, terwijl elk commentaardocument velden bevat voor de inhoud van de reactie, de auteur en het bijbehorende post‑ID.

Om alle bestaande databases op te sommen, voer je show dbs uit in de shell. Als dit de eerste keer is dat je MongoDB gebruikt, zie je de onderstaande output.

Som de bestaande databases op.

Standaard gebruiken we de test‑database. Hoewel we ons in de test‑database bevinden, wordt de database pas aangemaakt wanneer we een document in een collectie in de database invoegen.

Om een nieuwe database te maken, voer je use <database_name>. uit.

In ons voorbeeld gebruiken we “blog” als naam voor onze database. Voer use blog uit om de nieuwe database te maken. Zoals hierboven vermeld, laat het commando show dbs de nieuwe database pas zien nadat we een collectie in de database hebben ingevoegd. Voer daarom de onderstaande commando’s uit om een collectie te maken.

// create database
use blog

// create collection
db.createCollection("posts")
db.createCollection("comments")

Het uitvoeren van use blog schakelt de database van “test” naar “blog”.

Output: Database en collectie maken.

Na het aanmaken van collecties kunnen we dit verifiëren met het commando show dbs.

Lijst met databases.

We hebben succesvol een database en collecties aangemaakt.

3. CRUD‑operaties implementeren

MongoDB ondersteunt vier primaire CRUD‑operaties (Create, Read, Update, Delete) om met data te werken:

1. Create: Om een document in MongoDB te maken, voegen we het in een collectie in met de methode insertOne() of insertMany(). Documenten kunnen elke geldige JSON‑data bevatten, wat een flexibel schemadesign mogelijk maakt.
2. Read: Om data uit MongoDB te lezen, voeren we queries uit met de methode find(). De queries filteren documenten op basis van opgegeven criteria en geven de resultaten terug.
3. Update: Voor het bijwerken van documenten kunnen updateOne() of updateMany() worden gebruikt. Deze methode maakt flexibele datamanipulatie mogelijk.
4. Delete: Om documenten uit een collectie te verwijderen, gebruiken we de methode deleteOne() of deleteMany(). Verwijderingen worden uitgevoerd op basis van opgegeven criteria, zoals het matchen van een bepaalde veldwaarde.

Nu we de commando’s hebben gezien, gaan we ze toepassen in onze blog‑use‑case.

4. Een blogpost maken

Om documenten in een MongoDB‑database in te voegen, zijn er twee methoden.

1. insertOne() : Deze methode voegt één document per keer in
2. insertMany() : Met deze methode kunnen we meerdere documenten tegelijk invoegen.

Laten we beide methoden gebruiken om blogposts toe te voegen aan de database. In de onderstaande code maken we documenten in de collectie “posts”. Elk document heeft een titel, inhoud, auteur en aanmaakdatum.

// use insertOne() method to insert one document to the "posts" collection
db.posts.insertOne({
   title: "Introduction to NoSQL with MongoDB",
   content: "MongoDB is a NoSQL database that stores data in JSON format",
   author: "Arunn Thevapalan",
   createdAt: new Date()
})

// array of blog post documents
var postsData = [
   {
       title: "Getting Started with MongoDB",
       content: "Learn the basics of MongoDB",
       author: "Arunn Thevapalan",
       createdAt: new Date()
   },
   {
       title: "Advanced MongoDB Techniques",
       content: "Explore advanced features of MongoDB",
       author: "Jim Murphy",
       createdAt: new Date()
   }
];

// use insertMany() to insert multiple documents
db.posts.insertMany(postsData);

Deze output geeft aan dat de MongoDB‑server het insertOne-verzoek succesvol heeft ontvangen en verwerkt.

Output: Voeg één document toe aan een collectie.

Op vergelijkbare wijze geeft de onderstaande output aan dat het insertMany-verzoek succesvol is verwerkt.

Output: Voeg meerdere documenten toe aan een collectie.

Met de kennis van de Create‑operatie is nu de Read‑operatie aan de beurt.

5. Blogposts opvragen

We kunnen de methode find() gebruiken om data uit collecties op te halen. Voer het onderstaande commando uit om de bovenstaande blogpost uit onze collectie “posts” op te halen.

db.posts.find()

De find‑methode haalt alle documenten in de collectie “posts” op. De onderstaande output toont alle documenten die we in de vorige stap hebben ingevoegd.

Output: Haal documenten op uit een collectie.

6. Een reactie aan een post toevoegen

Stel dat we een paar reacties aan een post willen toevoegen; we kunnen een document invoegen in de collectie “comments”. Reacties horen bij de blogs, dus we bewaren een verwijzing naar het post‑ID.

// use an object id from any of the above entries
var postId = ObjectId("664bfc27f74ef93812b2179e")

// insert one comment
db.comments.insertOne({
   postId: postId,
   content: "Informative article!",
   author: "Anne Smith",
   createdAt: new Date()
})

Deze output geeft aan dat de MongoDB‑server het verzoek heeft ontvangen en verwerkt.

Output: Maak een document dat naar een ander document verwijst.

7. Reacties voor een post opvragen

Om reacties op te halen die horen bij een specifieke blogpost, kun je de methode find() gebruiken met een queryfilter:

// retrieve the above comment

db.comments.find({postId: postId})

De onderstaande output toont de reactie die we in de vorige stap hebben ingevoegd.

Output: Vind een document met de find‑query.

Zodra gebruikers blogposts hebben aangemaakt, willen ze die later kunnen bijwerken. Laten we dus bekijken hoe we bestaande documenten kunnen updaten.

8. Een blogpost bijwerken

Net als bij het invoegen kan updaten zowel individueel als collectief worden gedaan.

1. updateOne() : Deze methode werkt één document per keer bij
2. updateMany() : Deze methode werkt meerdere documenten tegelijk bij.

Probeer de titel van de blogpost “Introduction to NoSQL with MongoDB” te wijzigen in “Absolute Beginner Guide to NoSQL with MongoDB”.

Omdat we het post‑ID kennen uit een van de eerdere stappen, voer je onderstaande code uit om de titel te wijzigen. Zorg dat je postId bijwerkt met jouw document‑ID.

var postId = ObjectId("664bfc27f74ef93812b2179e");

db.posts.updateOne(
   { _id: postId },
   { $set: { title: "Absolute Beginner guide to NoSQL with MongoDB"} }
);

// verify update
db.posts.find({_id: postId})

De output geeft aan dat het verzoek succesvol is verwerkt. Er is 1 overeenkomend document gevonden en 1 document is aangepast.

Output: Een document bijwerken.

9. Een blogpost verwijderen

Om een blogpost te verwijderen kun je deleteOne() gebruiken. Net als bij eerdere operaties kunnen we optioneel deleteMany() gebruiken om meerdere documenten tegelijk te verwijderen.

var postId = ObjectId("664bfc27f74ef93812b2179e");

// delete post
db.posts.deleteOne({ _id: postId });

// verify deletion -> no output
db.posts.find({_id: postId})

De output bevestigt de succesvolle verwijdering.

Output: Verwijder een document uit een collectie

Natuurlijk hebben we het ontwerp van een blogplatform vereenvoudigd; in de praktijk is dit complexer met allerlei andere acties zoals highlights, likes, claps, aanbevelingen, enzovoort. Maar al deze acties zijn gebaseerd op een van de CRUD‑operaties en we hebben nu een goed begrip van deze onderliggende concepten. Het is nu aan jou om meer features te verkennen en ermee te experimenteren op basis van deze operaties.

Conclusie

Deze tutorial introduceerde je in NoSQL-databases. We begonnen met de basisconcepten, de definitie van NoSQL-databases, hoe ze verschillen van relationele databases en hun typen.

Vervolgens hebben we dit uitgebreid met MongoDB, een veelgebruikte documentgebaseerde database. Tot slot zijn we praktisch aan de slag gegaan met een eenvoudig voorbeeld om een database voor ons blogplatform te ontwerpen.

Het is normaal om vast te lopen bij het ontwerpen van een database voor een nieuwe use‑case, en we raden je aan om de officiële documentatie te raadplegen voor de meest recente functies en voorbeelden.

Hier zijn enkele meer diepgaande cursussen en tutorials als je je kennis van NoSQL verder wilt uitbreiden.

• NoSQL Concepts Course
• Introduction to MongoDB in Python Course
• Introduction to DynamoDB: Mastering NoSQL Database with Node.js | A Beginner’s Tutorial Tutorial