MongoDB Academy · Les

Collections versus SQL-tabellen

U vergelijkt MongoDB-collections met relationele tabellen en begrijpt hoe een flexibel schema het gegevensontwerp verandert.

Les 2 van 413 stappen

Collections versus SQL-tabellen is een gratis MongoDB Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject MongoDB Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus MongoDB Academy bevat in totaal 4 lessen.

Tabellen en collecties in één oogopslag

De basiseenheid van SQL is de tabel, waarin elke rij dezelfde kolommen heeft. Bij MongoDB is dat de collectie — een groep documenten die elk kunnen verschillen.

Vast schema: de SQL-aanpak

SQL vereist een vast schema dat is gedefinieerd voordat er gegevens worden ingevoerd, en een latere wijziging kan de hele tabel opnieuw opbouwen. Rigide, maar voorspelbaar en efficiënt qua opslag.

-- SQL table: schema defined upfront, rigid
CREATE TABLE users (
  id         SERIAL PRIMARY KEY,
  name       VARCHAR(100) NOT NULL,
  email      VARCHAR(200) UNIQUE NOT NULL,
  age        INT,
  created_at TIMESTAMP DEFAULT NOW()
);
-- Every row must have exactly these columns

Flexibel schema: de MongoDB-aanpak

Een MongoDB-collectie verschijnt zodra je iets invoegt — een schema is niet nodig. Dit flexibele schema is geweldig voor prototypen, maar je code moet omgaan met ontbrekende velden.

// No schema definition needed - collection created on first insert
db.users.insertOne({ name: 'Alice', email: 'alice@test.com', age: 30 });

// Next insert can have completely different fields
db.users.insertOne({ name: 'Bob', email: 'bob@test.com', company: 'Acme', role: 'admin' });

// Both documents live in the same 'users' collection

Schema tegenover schema-loos: de afweging

Geen van beide is zonder meer de beste keuze. Vaste schema's beschermen tegen onjuiste gegevens; flexibele schema's laten je snel werken. Met MongoDB's JSON Schema-validatie krijg je een optionele middenweg.

Normalisatie tegenover denormalisatie

SQL geeft de voorkeur aan normalisatie — gegevens verdelen over tabellen. MongoDB geeft de voorkeur aan denormalisatie — gerelateerde gegevens samen opnemen, zodat je alles in één keer leest zonder JOIN's.

// SQL normalized: address in separate table
// SELECT u.name, a.city FROM users u JOIN addresses a ON a.user_id = u.id

// MongoDB denormalized: address embedded in user document
{
  _id: ObjectId('...'),
  name: 'Alice',
  address: { city: 'London', zip: 'EC1A' }   // no JOIN needed
}

Collecties expliciet aanmaken

Collecties verschijnen automatisch, maar met createCollection kun je vooraf opties instellen — bijvoorbeeld een begrensde collectie voor logboeken of een validator. De code laat dit zien.

// Create a capped collection explicitly
db.createCollection('appLogs', {
  capped: true,
  size: 10485760,   // 10 MB maximum size
  max: 50000        // optional: max 50,000 documents
});
// When full, oldest documents are automatically removed

Collecties weergeven en verwijderen

Met enkele handige opdrachten kun je collecties weergeven, tellen en verwijderen. Als je een collectie wilt leegmaken zonder haar te verwijderen, gebruik je deleteMany — MongoDB heeft geen TRUNCATE. De code laat ze zien.

// Useful collection management commands in mongosh
db.getCollectionNames();
// ['users', 'orders', 'products']

db.users.countDocuments({});
// 4823

db.users.stats().storageSize;
// 2097152 (bytes)

// Delete all documents but keep the collection:
db.users.deleteMany({});
// { acknowledged: true, deletedCount: 4823 }

Het veld _id en primaire sleutels

Elke collectie heeft _id als primaire sleutel, met een automatische unieke index. Je kunt zelf een _id opgeven — bijvoorbeeld een product-SKU — zolang die uniek is.

// Custom _id values
db.products.insertOne({
  _id: 'SKU-HEADPHONES-BLK-42',   // string _id
  name: 'Wireless Headphones Black',
  price: 79.99
});

// Lookup by custom _id is O(log n) via the _id index
db.products.findOne({ _id: 'SKU-HEADPHONES-BLK-42' });

Verschillen in indexstructuur

Zowel SQL als MongoDB gebruiken B-tree-indexen, maar MongoDB kan ook geneste velden en array-elementen indexeren. Flexibele schema's gaan dus niet ten koste van de querysnelheid.

// Index a nested field and an array field
db.users.createIndex({ 'address.city': 1 });
// Now queries on city use an index:
db.users.find({ 'address.city': 'Chicago' });

// Multikey index on array field - indexes each element
db.products.createIndex({ tags: 1 });
db.products.find({ tags: 'electronics' }); // uses multikey index

Transacties: tabellen tegenover collecties

Sinds versie 4.0 ondersteunt MongoDB transacties voor meerdere documenten. Maar door gerelateerde gegevens in één document op te nemen, krijg je vaak atomische updates zonder dat je transacties nodig hebt.

// Single-document atomicity (always available)
// Updating order status and adding a tracking number
db.orders.updateOne(
  { _id: orderId },
  { $set: { status: 'shipped', trackingNumber: 'UPS123456' } }
);
// These two field updates happen atomically - no transaction needed

Wanneer je beter tabellen dan collecties kiest

Soms zijn SQL-tabellen de betere keuze: bij stabiele schema's, veel JOIN's of strikte integriteit van externe sleutels. Kies het juiste hulpmiddel, niet het hulpmiddel dat toevallig de grootste hype heeft.

Korte controle

Toets je begrip van de concepten rond MongoDB en NoSQL-databases uit deze les.

Beantwoord dit in de interactieve les

Samenvatting van de les

Je hebt geleerd dat collecties geen schema afdwingen, dat MongoDB gerelateerde gegevens insluit om JOIN's over te slaan en dat elke collectie automatisch een index op _id krijgt. Hierna: databases en naamruimten.

Gratis beginnen

Leer JavaScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 30
Lessen: 120

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Collections versus SQL-tabellen” gratis?

Ja — de volledige tekst van “Collections versus SQL-tabellen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus MongoDB Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus MongoDB Academy bevat in totaal 4 lessen.

Wat leer ik in “Collections versus SQL-tabellen”?

U vergelijkt MongoDB-collections met relationele tabellen en begrijpt hoe een flexibel schema het gegevensontwerp verandert. Je oefent met MongoDB Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met MongoDB Academy te beginnen?

Ervaring vooraf is niet nodig. MongoDB Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Collections versus SQL-tabellen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over MongoDB Academy?

Ja. Elke les over MongoDB Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar MongoDB Academy