Aan de slag met de MongoDB Query API

Als populaire NoSQL-database biedt MongoDB een flexibele en schaalbare manier om je data te beheren. Deze gids is je startpunt om de intuïtieve Query API onder de knie te krijgen, waarmee je met je data kunt werken via een eenvoudige BSON (Binary JSON), geoptimaliseerd voor efficiëntie en datatypes. 

In dit artikel behandelen we de basisbewerkingen create, read, update, delete (CRUD), gaan we in op nauwkeurig query'en met filters en projectie, verkennen we de kracht van aggregatiepipelines voor datatransformatie en hebben we het over indexering om de prestaties te verbeteren. Aan het einde heb je een sterke basis om data in je MongoDB-collecties efficiënt op te halen en te bewerken.

Basisconcepten: CRUD-bewerkingen

De ruggengraat van elke database-interactie is CRUD: create, read, update en delete. Laten we bekijken hoe je elk hiervan uitvoert in MongoDB.

Data aanmaken (insert)

Om nieuwe documenten aan een collectie toe te voegen, gebruik je de insert-methoden. Documenten in MongoDB zijn JSON-achtige objecten.

insertOne()

Deze methode wordt gebruikt om één document aan een collectie toe te voegen.

// A sample document to insert
const newProduct = {
  name: "Wireless Mouse",
  brand: "Logitech",
  price: 29.99,
  inStock: true
};

// Insert the new document into the 'products' collection
db.products.insertOne(newProduct);Mogelijk gemaakt door

insertMany()

Deze methode voegt meerdere documenten in één keer toe, wat veel efficiënter is dan ze stuk voor stuk in te voegen.

// An array of documents to insert
const newProducts = [
  { name: "Mechanical Keyboard", brand: "Corsair", price: 129.99, inStock: false },
  { name: "Gaming Headset", brand: "Razer", price: 99.99, inStock: true },
  { name: "Webcam", brand: "LogiTech", price: 79.99, inStock: true }
];

// Insert the array of documents into the 'products' collection
db.products.insertMany(newProducts);Mogelijk gemaakt door

Data lezen (find)

De find()-methode is je primaire hulpmiddel om documenten uit een collectie op te halen. Als je find() aanroept, krijg je niet meteen alle documenten zelf terug. In plaats daarvan retourneert het een cursor. Dit is een efficiënte manier om met potentieel grote resultsets om te gaan zonder alles tegelijk in het geheugen te laden.

De eenvoudigste aanroep van find() neemt geen argumenten aan en retourneert een cursor naar elk document in de collectie.

// Find and return a cursor to all documents in the 'products' collection
db.products.find();Mogelijk gemaakt door

Hier is een voorbeeld van hoe dat cursorobject eruitziet in mongosh (de MongoDB-shell) en hoe je ermee kunt werken:

// Find all products and assign the returned cursor to a variable
const productCursor = db.products.find();

// The variable 'productCursor' now holds the cursor object, not the documents themselves.
// To get the documents, you need to iterate over the cursor.

// You can convert the cursor to an array to see all the documents
const allProducts = productCursor.toArray();
console.log(allProducts);

// Or, you can manually iterate through the documents
while (productCursor.hasNext()) {
  const product = productCursor.next();
  console.log(product);
}Mogelijk gemaakt door

De cursor zelf is een object met verschillende methoden zoals toArray(), hasNext() en next() waarmee je de documenten in de resultset kunt ophalen en ermee kunt werken.

Data bijwerken (update)

Om bestaande documenten te wijzigen, gebruik je de update-methoden. Deze methoden nemen twee hoofdargumenten: een filter om de te updaten documenten te selecteren en een update-operator om de wijzigingen te specificeren. Een veelgebruikte operator is $set, die de waarde van een veld zet.

updateOne()

Deze methode werkt het eerste document bij dat overeenkomt met het filter.

// Update the 'Wireless Mouse' document to set its price to 39.99
db.products.updateOne(
  { name: "Wireless Mouse" }, // Filter to find the document
  { $set: { price: 39.99 } } // Update operator
);Mogelijk gemaakt door

updateMany()

Deze methode werkt alle documenten bij die overeenkomen met het opgegeven filter.

// Update all 'LogiTech' brand products to be in stock
db.products.updateMany(
  { brand: "LogiTech" }, // Filter to find the documents
  { $set: { inStock: true } } // Update operator
);Mogelijk gemaakt door

Data verwijderen (delete)

Om documenten te verwijderen, gebruik je de delete-methoden. Ook deze nemen een filter om te bepalen welke documenten moeten worden verwijderd.

deleteOne()

Deze methode verwijdert het eerste document dat overeenkomt met het filter.

// Delete the 'Webcam' document
db.products.deleteOne({ name: "Webcam" });Mogelijk gemaakt door

deleteMany()

Deze methode verwijdert alle documenten die overeenkomen met het filter. Om alle documenten in een collectie te verwijderen, kun je een leeg filter {} meegeven.

// Delete all documents that are not in stock
db.products.deleteMany({ inStock: false });Mogelijk gemaakt door

Nauwkeurig ophalen: queryfilters

Queryfilters vormen het hart van de kracht van MongoDB. Ze zijn het eerste argument in de methoden find() en update en laten je precies selecteren met welke documenten je wilt werken.

Vergelijkingsoperators

Deze operators laten je de waarde van een veld vergelijken met een opgegeven waarde.

$eq (gelijk aan)

Dit zoekt documenten waarin een veld gelijk is aan een waarde.

// Find all products that are made by 'Razer'
db.products.find({ brand: { $eq: "Razer" } });
// This can be simplified to:
// db.products.find({ brand: "Razer" });Mogelijk gemaakt door

$gt en $gte (groter dan, groter dan of gelijk aan)

Deze zoeken documenten waarin de waarde van een veld groter is dan ($gt) of groter dan of gelijk aan ($gte) een opgegeven waarde.

// Find all products with a price greater than 100
db.products.find({ price: { $gt: 100 } });Mogelijk gemaakt door

$lt en $lte (kleiner dan, kleiner dan of gelijk aan)

Deze zoeken documenten waarin de waarde van een veld kleiner is dan ($lt) of kleiner dan of gelijk aan ($lte) een opgegeven waarde.

// Find all products with a price less than or equal to 50
db.products.find({ price: { $lte: 50 } });Mogelijk gemaakt door

$ne (niet gelijk aan)

$ne zoekt documenten waarin een veld niet gelijk is aan een opgegeven waarde.

// Find all products that are NOT made by 'LogiTech'
db.products.find({ brand: { $ne: "LogiTech" } });Mogelijk gemaakt door

$in en $nin (in een array, niet in een array)

Deze zoeken documenten waarin de waarde van een veld voorkomt in ($in) of niet voorkomt in ($nin) een opgegeven array met waarden.

// Find all products from 'Razer' or 'Corsair'
db.products.find({ brand: { $in: ["Razer", "Corsair"] } });Mogelijk gemaakt door

Logische operators

Logische operators combineren meerdere voorwaarden om complexe queries te maken.

$and

$and combineert queryvoorwaarden met een logische AND. Alle voorwaarden moeten waar zijn.

// Find all products with a price greater than 50 AND are in stock
db.products.find({ $and: [{ price: { $gt: 50 } }, { inStock: true }] });
// This can be simplified by just listing the conditions:
// db.products.find({ price: { $gt: 50 }, inStock: true });Mogelijk gemaakt door

$or

Dit combineert queryvoorwaarden met een logische OR. Minstens één voorwaarde moet waar zijn.

// Find all products with a brand of 'Corsair' OR a price less than 40
db.products.find({ $or: [{ brand: "Corsair" }, { price: { $lt: 40 } }] });Mogelijk gemaakt door

Element- en evaluatieoperators 

Deze operators bieden nog meer flexibiliteit bij het filteren.

$exists

$exists komt overeen met documenten die een specifiek veld bevatten.

// Find all documents that have an 'inStock' field
db.products.find({ inStock: { $exists: true } });Mogelijk gemaakt door

$regex

Hiermee kun je reguliere expressies gebruiken voor patroonherkenning in tekenreeksvelden.

// Find all product names that start with 'Wireless'
db.products.find({ name: { $regex: /^Wireless/ } });Mogelijk gemaakt door

Je output vormgeven: projectie

Wanneer je een find()-operatie uitvoert, kun je ervoor kiezen om slechts een subset van de velden in elk document te ontvangen. Dit heet projectie en is het tweede argument dat je aan find() meegeeft. Het helpt de hoeveelheid overgedragen en verwerkte data te verminderen.

Velden opnemen

Je kunt opgeven welke velden je wilt retourneren door hun waarde op 1 te zetten.

// Find all products and return only the 'name' and 'price' fields
db.products.find({}, { name: 1, price: 1 });Mogelijk gemaakt door

Velden uitsluiten

Omgekeerd kun je opgeven welke velden je wilt verbergen door hun waarde op 0 te zetten.

// Find all products and hide the 'inStock' field
db.products.find({}, { inStock: 0 });Mogelijk gemaakt door

Het veld _id wordt standaard altijd geretourneerd, tenzij je het expliciet uitsluit.

Het _id-veld

Om het veld _id te verbergen, moet je het expliciet op 0 zetten.

// Find all products, returning only 'name' and 'price', and hiding '_id'
db.products.find({}, { _id: 0, name: 1, price: 1 });Mogelijk gemaakt door

Geavanceerde datatransformatie: aggregatiepipelines

Aggregatie is een krachtig framework voor dataverwerking in MongoDB. Een aggregatiepipeline bestaat uit een reeks stages die documenten verwerken en de resultaten van de ene naar de volgende stage doorgeven.

$match

Een $match-stage filtert documenten op basis van een queryfilter, net zoals in find(). Dit is vaak de eerste stage om het aantal te verwerken documenten te verminderen.

// Find all products with a brand of 'LogiTech'
db.products.aggregate([
  { $match: { brand: "LogiTech" } }
]);Mogelijk gemaakt door

$group

De $group-stage groepeert documenten op basis van een opgegeven _id-expressie en kan diverse accumulatorbewerkingen uitvoeren, zoals het berekenen van de som of het gemiddelde van een veld.

// Group products by brand and calculate the total number of products for each brand
db.products.aggregate([
  { $group: { _id: "$brand", totalProducts: { $sum: 1 } } }
]);Mogelijk gemaakt door

$project

Een $project-stage vormt elk document in de stroom om, vergelijkbaar met projectie in find(). Je kunt nieuwe velden toevoegen, bestaande verwijderen en data bewerken.

// Project a new field 'nameAndPrice' for each document
db.products.aggregate([
  { $project: { name: 1, price: 1, nameAndPrice: { $concat: ["$name", " (", "$price", ")"] } } }
]);Mogelijk gemaakt door

$sort

De $sort-stage ordent de documenten opnieuw op basis van een opgegeven veld. De waarde 1 is voor oplopend, en -1 voor aflopend.

// Sort all products by price in descending order
db.products.aggregate([
  { $sort: { price: -1 } }
]);Mogelijk gemaakt door

$limit en $skip

Deze stages worden gebruikt voor paginering. $skip slaat een opgegeven aantal documenten aan het begin van de pipeline over, en $limit beperkt het aantal documenten dat wordt doorgegeven aan de volgende stage.

// Skip the first 10 products and then return the next 5
db.products.aggregate([
  { $skip: 10 },
  { $limit: 5 }
]);Mogelijk gemaakt door

Een eenvoudig pipeline-voorbeeld

Hier is een compleet voorbeeld dat laat zien hoe deze stages samenwerken.

// Find the average price of all products that are currently in stock,
// grouped by brand.
db.products.aggregate([
  { $match: { inStock: true } }, // Filter for products in stock
  { $group: { _id: "$brand", averagePrice: { $avg: "$price" } } } // Group and calculate average price
]);Mogelijk gemaakt door

Prestaties verbeteren: indexering

Indexen zijn speciale datastructuren die een klein, gemakkelijk doorzoekbaar deel van de data uit een collectie opslaan. Ze verbeteren de queryprestaties aanzienlijk doordat MongoDB snel documenten kan vinden en ophalen zonder de hele collectie te scannen.

createIndex()

Je maakt een index aan op een veld waar je vaak op queryt of op sorteert.

// Create a single-field index on the 'brand' field
db.products.createIndex({ brand: 1 });Mogelijk gemaakt door

De 1 geeft een oplopende index aan. Je kunt -1 gebruiken voor aflopend, wat gunstig kan zijn voor queries die in die richting sorteren.

Een index aanmaken op een veld zoals brand zorgt ervoor dat queries die filteren op brand (bijv. db.products.find({ brand: "Razer" })) veel sneller worden uitgevoerd, vooral naarmate je collectie groeit.

Overwegingen bij het kiezen van te indexeren velden

Je maakt doorgaans indexen aan op velden die je vaak in je queries gebruikt, zoals in een find()-filter of in de $match-stage van een aggregatie.

• Cardinaliteit: Velden met veel unieke waarden (hoge cardinaliteit), zoals het e-mailadres van een gebruiker, zijn uitstekende kandidaten voor indexen.
• Selectiviteit van de query: Een veld dat voor een bepaalde query slechts een kleine subset van documenten oplevert, is ook een goede kandidaat.
• Sorteren: Als je je queryresultaten vaak op een bepaald veld sorteert, zorgt een index op dat veld ervoor dat de sorteerbewerking veel sneller is.

Impact op queries

Indexen hebben een grote impact op prestaties. Een query met een index is vaak vele malen sneller dan dezelfde query zonder index.

// Conceptual illustration of performance difference

// Without an index on 'brand':
// MongoDB performs a full collection scan, checking every document.
// This is slow, especially with millions of documents.
db.products.find({ brand: "Razer" });

// With an index on 'brand':
// MongoDB uses the index to quickly locate and return only the matching documents.
// This is very fast.
db.products.find({ brand: "Razer" });Mogelijk gemaakt door

Om queries verder te optimaliseren, kun je de methode db.collection.explain() gebruiken om de queryprestaties te analyseren en te zien hoe indexen worden benut.

Conclusie: jouw reis naar MongoDB-vaardigheid

Je hebt zojuist een spoedcursus in de Query API van MongoDB afgerond! Je weet nu hoe je kern-CRUD-bewerkingen uitvoert, krachtige filters gebruikt om specifieke data op te halen, je output vormgeeft met projectie en je data transformeert met aggregatiepipelines. Ook heb je een basisbegrip van indexering om prestaties te verbeteren.

Deze gids biedt een solide basis, en de beste manier om deze concepten te beheersen is door te oefenen. Ik moedig je aan om te experimenteren met verschillende queries en de volledige documentatie te verkennen om meer geavanceerde operators en features te ontdekken. Veel codeerplezier!