One-to-many-relatie in databases: een complete gids

In deze tutorial leg ik uit wat de one-to-many-relatie is, hoe je die implementeert in databaseontwerp, en welke best practices je volgt om je databases schaalbaar en efficiënt te houden.

Als je net begint als database-engineer, raad ik je aan om onze Introduction to Relational Databases in SQL en Database Design cursussen te volgen om te leren hoe je relaties maakt bij het definiëren van je databaseschema.

Wat is een one-to-many-relatie?

Een one-to-many-relatie (1:N) beschrijft de situatie waarin één record in een tabel gekoppeld kan worden aan meerdere records in een andere tabel. Simpel gezegd: één ding komt één keer voor maar kan verbonden zijn met veel gerelateerde dingen.

Zo kan één klant meerdere bestellingen plaatsen, maar elke bestelling hoort bij precies één klant.

Je ziet one-to-many-relaties vaak beschreven met deze termen:

• Bovenliggende tabel (parent): Een tabel die het “één”-record bevat
• Ondergeschikte tabel (child): Een tabel die de “veel”-records bevat

In ons voorbeeld staat het klantenrecord in de parent-tabel en de bestellingen staan in de child-tabel.

Cardinaliteit bij one-to-many-relaties begrijpen

Cardinaliteit beschrijft hoeveel records tussen twee tabellen kunnen worden gekoppeld. Het beantwoordt vragen als: 

• Hoeveel bestellingen kan een klant hebben?
• Kan een klant bestaan zonder bestellingen?

One-to-many-relaties zijn asymmetrisch: de regels verschillen per tabel. In de parent-tabel kan één record aan veel records gerelateerd zijn, terwijl in de child-tabel elk record aan slechts één record gerelateerd kan zijn.

Cardinaliteit omvat ook minimale en maximale grenzen, waarbij:

• Minimale cardinaliteit: Het minimale aantal toegestane gerelateerde records.
• Maximale cardinaliteit: Het maximale aantal toegestane gerelateerde records.

Bijvoorbeeld: een klant kan nul of veel bestellingen hebben, maar een bestelling moet precies bij één klant horen.

Deze regels beïnvloeden het tabelontwerp door aan te geven of bepaalde velden leeg mogen zijn en hoe strikt de database relaties afdwingt.

One-to-many-relaties visualiseren met ER-diagrammen

In databaseontwerp is een Entity-Relationship (ER) diagram een visuele manier om tabellen (entiteiten), hun onderlinge relaties (relationships) en de aantallen koppelingen (cardinaliteit) te tonen.

ER-diagramnotatie

De meeste ER-diagrammen gebruiken specifieke symbolen aan het uiteinde van de lijnen tussen je tabellen die precies aangeven wat de relatie is. Hieronder de gangbare visuele conventies voor:

• Entiteiten: Getekend als rechthoeken om tabellen als Customers of Orders weer te geven.
• Relaties: Weergegeven als lijnen tussen entiteiten om aan te geven hoe ze zich tot elkaar verhouden
• Cardinaliteitssymbolen: Het getal 1 of een enkele streep staat voor “één”, terwijl ∞, * of een kraaienpoot staat voor “veel”.

Eenvoudig ER-diagramexample

Het onderstaande voorbeeld toont de relatie tussen de tabellen Customers en Orders. De one-to-many-relatie laat zien dat één klant veel bestellingen kan hebben, maar elke bestelling hoort bij één klant. De CustomerID komt voor in de tabel Orders om die terug te koppelen aan de tabel Customers.

Veelvoorkomende voorbeelden van one-to-many-relaties

De volgende voorbeelden zijn situaties met one-to-many-relaties die je vaak tegenkomt:

• Auteur → Boeken: Eén auteur kan meerdere boeken schrijven, maar elk boek heeft één auteur (in een eenvoudig ontwerp).
• Afdeling → Werknemers: Eén afdeling kan veel werknemers hebben, maar elke werknemer hoort bij één afdeling
• Categorie → Producten: Eén categorie kan veel producten bevatten, maar elk product is aan één categorie toegewezen.

Een one-to-many-relatie implementeren in een relationele database

One-to-many-relaties worden geïmplementeerd met primary keys en foreign keys. In deze sectie laat ik zien hoe deze constraints helpen om dataintegriteit in databases af te dwingen.

Primary en foreign keys

De primary key is een kolom die elke rij in een tabel uniek identificeert, terwijl de foreign key een veld of set velden is in de ene tabel die verwijst naar de primary key in een andere tabel.

In een one-to-many-relatie heeft de “één”-kant een primary key, en de “veel”-tabel slaat die sleutel op als foreign key. De foreign key legt vervolgens de link tussen de twee tabellen en zorgt ervoor dat elk record aan de “veel”-kant naar een geldig record aan de “één”-kant verwijst.

Eenvoudig SQL-voorbeeld

Laten we bekijken hoe je een one-to-many-relatie in SQL opzet met het onderstaande voorbeeld.

Je maakt de tabel Customers waarin CustomerID elke klant uniek identificeert. Dit is de parent-tabel.

-- Create Customers table with CustomerID as primary key
CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    CustomerName VARCHAR(100)
);Mogelijk gemaakt door

Maak nu de tabel Orders waarin de CustomerID een foreign key is. In deze tabel verwijst elke bestelling naar precies één klant en dit is de child-tabel.

-- Create Orders table with CustomerID as a foreign key
CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    OrderDate DATE,
    CustomerID INT,
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);Mogelijk gemaakt door

One-to-many versus many-to-many-relaties

Het verschil tussen one-to-many en many-to-many-relaties begrijpen is belangrijk voor een correct databaseontwerp. De onderstaande tabel vat deze verschillen samen:

Het is belangrijk om te weten dat relationale databases many-to-many-relaties niet rechtstreeks kunnen opslaan met één enkele foreign key. In plaats daarvan gebruiken ze een koppelings- (ook wel junction- of brug-)tabel.

Zo kun je records in de tabel Students veilig relateren aan de tabel Courses via de tabel Enrollments als koppelings­tabel. De koppelings­tabel splitst de many-to-many-relatie op in twee one-to-many-relaties en slaat daarom foreign keys naar beide tabellen op. Dit ontwerp helpt bij database normalisatie en houdt het efficiënt.

Ik raad onze cursus Joining Data in SQL aan om de verschillende soorten joins in SQL te leren en te oefenen met werken met gerelateerde tabellen.

Veelgemaakte fouten bij one-to-many-relaties

Dit zijn enkele veelvoorkomende problemen bij one-to-many-relaties en hoe je ze oplost:

• De foreign key in de verkeerde tabel zetten: Als je de foreign key in de “één”-tabel opslaat in plaats van in de “veel”-tabel, eindig je met meerdere waarden in één kolom of herhaalde kolommen. Dat schendt normalisatie en maakt query’s lastig. Zet de foreign key daarom altijd aan de “veel”-kant van de relatie.
• One-to-many verwarren met many-to-many: Als je een relatie als one-to-many modelleert terwijl beide kanten meerdere gerelateerde records kunnen hebben, leidt dat tot ontbrekende data, dubbele rijen of starre ontwerpen die niet met de eisen meegroeien. Controleer daarom altijd of een child-record meerdere gerelateerde records kan hebben; zo ja, gebruik dan een koppelings­tabel.
• Onbedoeld verweesde records toestaan: Child-records zonder geldige parent toestaan zorgt voor inconsistente data, zoals bestellingen zonder klant of werknemers zonder afdeling. Los dit op met foreign key-constraints zoals ON DELETE CASCADE, zodat de database geldige relaties automatisch afdwingt.

Best practices voor het ontwerpen van one-to-many-relaties

Ik raad de volgende best practices aan als leidraad om efficiënte en schaalbare one-to-many-relaties te ontwerpen:

• Gebruik duidelijke en consistente naamgeving: Noem primary keys voorspelbaar, zoals CustomerID en OrderID. Duidelijke naamgeving maakt relaties ook zonder diagrammen meteen zichtbaar en helpt bij het laten aansluiten van foreign keys op de bijbehorende primary key.

• Dwing foreign key-constraints af: Gebruik foreign keys zodat de database dataintegriteit bewaakt en ongeldige of verweesde records voorkomt, vooral als je data groeit.

• Denk vroeg na over verwijdergedrag: Bepaal wat er met child-records moet gebeuren wanneer een parent wordt verwijderd om dataverlies of kapotte verwijzingen te vermijden. CASCADE zorgt er bijvoorbeeld voor dat alle child-records worden verwijderd wanneer het parent-record wordt verwijderd.

• Houd ontwerpen simpel: Vermijd onnodige tabellen of complexe relaties en ontwerp voor wat je nu nodig hebt, niet voor hypothetische toekomstige gevallen. Eenvoudige ontwerpen zijn makkelijker te onderhouden, uit te leggen en uit te breiden.

Conclusie

Een one-to-many-relatie beschrijft hoe één record in de ene tabel gekoppeld kan zijn aan meerdere records in een andere tabel, terwijl elk van die gerelateerde records bij slechts één parent hoort. Dit patroon is fundamenteel in relationeel databaseontwerp omdat het data organiseert en onnodige duplicatie voorkomt.

Ik raad onze Associate Data Engineer in SQL career track aan om te leren hoe je databases in SQL ontwerpt om data efficiënt te verwerken, op te slaan en te organiseren. En als je je databasebeheer­vaardigheden voor big data wilt uitbreiden, helpt onze cursus Introduction to Data Modeling in Snowflake je met dimensioneel modelleren.