MongoDB Academy · Lektion

Collections kontra SQL-tabeller

Sammenhold MongoDB-collections med relationelle tabeller, og forstå, hvordan et fleksibelt schema ændrer datadesign.

Lektion 2 af 413 trin

Collections kontra SQL-tabeller er en gratis MongoDB Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i MongoDB Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. MongoDB Academy-kurset indeholder 4 lektioner i alt.

Tabeller og samlinger på et øjeblik

SQL's grundlæggende enhed er tabellen, hvor hver række har identiske kolonner. MongoDB's er samlingen — en gruppe dokumenter, der hver især kan være forskellige.

Fast skema: SQL-metoden

SQL kræver et fast skema, der er defineret, før data indsættes, og ændringer senere kan kræve, at hele tabellen opbygges igen. Stramt, men forudsigeligt og effektivt med hensyn til lagerplads.

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

Fleksibelt skema: MongoDB-metoden

En MongoDB-samling oprettes i det øjeblik, du indsætter et dokument — der kræves ikke noget skema. Dette fleksible skema er fantastisk til prototyper, men din kode skal kunne håndtere manglende felter.

// 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

Skema kontra skemaløshed: afvejningen

Ingen af delene vinder entydigt. Faste skemaer beskytter mod ugyldige data, mens fleksible skemaer lader dig arbejde hurtigt. MongoDB's JSON Schema-validering giver dig en valgfri mellemvej.

Normalisering kontra denormalisering

SQL foretrækker normalisering — at opdele data på tværs af tabeller. MongoDB foretrækker denormalisering — at indlejre relaterede data samlet, så du kan læse det hele på én gang uden JOINs.

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

Oprettelse af samlinger eksplicit

Samlinger oprettes automatisk, men createCollection lader dig angive indstillinger på forhånd — f.eks. en begrænset samling til logfiler eller en validator. Koden viser et eksempel.

// 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

Visning og sletning af samlinger

Nogle få praktiske kommandoer viser, tæller og sletter samlinger. Hvis du vil tømme en samling uden at slette den, skal du bruge deleteMany — MongoDB har ingen TRUNCATE. Koden viser dem.

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

Feltet _id og primærnøgler

Hver samling har _id som sin primærnøgle med et automatisk, entydigt indeks. Du kan angive dit eget _id — f.eks. en produkts SKU — så længe det er entydigt.

// 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' });

Forskelle i indeksstrukturer

Både SQL og MongoDB bruger B-træ-indekser, men MongoDB kan også indeksere indlejrede felter og array-elementer. Fleksible skemaer koster derfor ikke forespørgslernes hastighed.

// 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

Transaktioner: tabeller kontra samlinger

Siden v4.0 understøtter MongoDB transaktioner med flere dokumenter. Men ved at indlejre relaterede data i ét dokument får du ofte atomare opdateringer uden overhovedet at have brug for dem.

// 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

Hvornår du bør vælge tabeller frem for samlinger

Nogle gange er SQL-tabeller det bedre valg: stabile skemaer, mange JOINs eller streng integritet for fremmednøgler. Vælg det rigtige værktøj, ikke det mest trendy.

Hurtigt tjek

Test din forståelse af begreberne MongoDB og NoSQL-databaser fra denne lektion.

Besvar den i den interaktive lektion

Opsummering af lektionen

Du har lært, at samlinger ikke gennemtvinger et skema, at MongoDB indlejrer relaterede data for at undgå JOINs, og at hver samling automatisk indekserer _id. Næste emne: databaser og navnerum.

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 30
Lektioner: 120

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Collections kontra SQL-tabeller” gratis?

Ja — hele teksten til “Collections kontra SQL-tabeller” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af MongoDB Academy-kurset, skal du opgradere til CoddyKit PRO. MongoDB Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Collections kontra SQL-tabeller”?

Sammenhold MongoDB-collections med relationelle tabeller, og forstå, hvordan et fleksibelt schema ændrer datadesign. Du øver dig i MongoDB Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på MongoDB Academy?

Der kræves ingen tidligere erfaring. MongoDB Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Collections kontra SQL-tabeller”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne MongoDB Academy-lektion?

Ja. Alle MongoDB Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til MongoDB Academy