Introductie tot Eloquent-relaties

Wat zijn relaties?

Databasetabellen zijn vaak aan elkaar gerelateerd. Een blogpost heeft bijvoorbeeld veel reacties, of een bestelling is gerelateerd aan de gebruiker die haar heeft geplaatst. Eloquent biedt een mechanisme om zulke relaties tussen tabellen eenvoudig te definiëren en te gebruiken. Relaties definieer je als methoden op je Eloquent-modellen.

Deze pagina gebruikt concrete modellen zoals User, Post, Comment en Tag als voorbeeld. We gaan ervan uit dat deze modellen en tabellen al zijn aangemaakt.

De belangrijkste relaties die Eloquent ondersteunt zijn:

Relatie	Beschrijving
`hasOne`	Eén-op-één (parent heeft één child)
`belongsTo`	Omgekeerde van één-op-één (child behoort tot parent)
`hasMany`	Eén-op-veel (parent heeft meerdere children)
`belongsToMany`	Veel-op-veel (met een tussentabel)

hasOne (één-op-één)

hasOne beschrijft een relatie waarbij een model precies één ander model heeft. Bijvoorbeeld wanneer een User één Profile heeft.

De relatie definiëren

Definieer een profile-methode op het User-model.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasOne;

class User extends Model
{
    public function profile(): HasOne
    {
        return $this->hasOne(Profile::class);
    }
}

Eloquent leidt de foreign key automatisch af uit de naam van het bovenliggende model. In dit geval wordt aangenomen dat de tabel profiles een kolom user_id heeft.

Gerelateerde data ophalen

Je kunt de gedefinieerde relatie benaderen als property.

$user = User::find(1);
$profile = $user->profile;

Wanneer je een relatiemethode als property aanroept, voert Eloquent automatisch een query uit en geeft het de gerelateerde data terug. Dit heet een “dynamische relatieproperty”.

belongsTo (omgekeerde van één-op-één)

belongsTo is het omgekeerde van hasOne en definieer je op het model dat de foreign key heeft. Het beschrijft de relatie waarbij een Profile tot een User behoort.

De relatie definiëren

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Profile extends Model
{
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}

Eloquent gebruikt als foreign key de kolomnaam die bestaat uit de relatiemethodenaam met _id erachter (in dit geval user_id).

Gerelateerde data ophalen

$profile = Profile::find(1);
$user = $profile->user;

echo $user->name;

hasMany (één-op-veel)

hasMany is de meest gebruikte relatie, waarbij één bovenliggend model meerdere onderliggende modellen heeft. Bijvoorbeeld wanneer één Post meerdere Comment-modellen heeft.

De relatie definiëren

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;

class Post extends Model
{
    public function comments(): HasMany
    {
        return $this->hasMany(Comment::class);
    }
}

Eloquent gaat ervan uit dat de tabel comments een kolom post_id heeft.

Gerelateerde data ophalen

Een hasMany-relatie geeft een collectie terug.

$post = Post::find(1);

foreach ($post->comments as $comment) {
    echo $comment->body;
}

Je kunt ook voorwaarden aan de query toevoegen.

$recentComments = Post::find(1)
    ->comments()
    ->latest()
    ->take(5)
    ->get();

De omgekeerde relatie (belongsTo)

Om vanuit een reactie naar de post te verwijzen, definieer je belongsTo op het Comment-model.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Comment extends Model
{
    public function post(): BelongsTo
    {
        return $this->belongsTo(Post::class);
    }
}

$comment = Comment::find(1);
echo $comment->post->title;

belongsToMany (veel-op-veel)

Een veel-op-veel-relatie gebruik je wanneer beide modellen meerdere relaties met elkaar hebben. Bijvoorbeeld wanneer een Post meerdere Tag-modellen heeft en een Tag ook bij meerdere Post-modellen hoort.

Tabelstructuur

Voor veel-op-veel heb je een tussentabel nodig. In het geval van Post en Tag maak je een tussentabel genaamd post_tag.

posts
    id - integer
    title - string

tags
    id - integer
    name - string

post_tag
    post_id - integer
    tag_id - integer

De naam van de tussentabel leidt Eloquent automatisch af door de namen van de twee gerelateerde modellen in alfabetische volgorde samen te voegen (post + tag → post_tag).

De relatie definiëren

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;

class Post extends Model
{
    public function tags(): BelongsToMany
    {
        return $this->belongsToMany(Tag::class);
    }
}

Door hetzelfde te definiëren aan de Tag-kant, kun je ook in omgekeerde richting verwijzen.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;

class Tag extends Model
{
    public function posts(): BelongsToMany
    {
        return $this->belongsToMany(Post::class);
    }
}

Gerelateerde data ophalen

$post = Post::find(1);

foreach ($post->tags as $tag) {
    echo $tag->name;
}

Gerelateerde data toevoegen en verwijderen

Met attach voeg je records toe aan de tussentabel, met detach verwijder je ze.

$post = Post::find(1);

// Een tag toevoegen
$post->tags()->attach($tagId);

// Een tag verwijderen
$post->tags()->detach($tagId);

// Alle huidige relaties vervangen
$post->tags()->sync([$tagId1, $tagId2]);

Met sync worden tussentabelrecords met andere ID’s dan de opgegeven ID’s automatisch verwijderd, zodat alleen de doorgegeven ID’s als relatie overblijven.

Eager loading

Wat is het N+1-probleem?

Wanneer je een relatie als property benadert, voert Eloquent telkens een query uit. Dit heet “lazy loading”. Als je binnen een lus een relatie benadert, ontstaat het N+1-probleem.

// Eén query om alle posts op te halen
$posts = Post::all();

foreach ($posts as $post) {
    // Voor elke post wordt een query uitgevoerd om de gebruiker op te halen (N keer)
    echo $post->user->name;
}

Bij 100 posts worden in totaal 101 queries uitgevoerd. Dit heeft een grote impact op de prestaties.

Eager loading met with()

Met de with()-methode haal je gerelateerde data in één keer op. Zo blijft het aantal queries beperkt tot slechts twee.

// Posts en gebruikers ophalen met twee queries
$posts = Post::with('user')->get();

foreach ($posts as $post) {
    // Er worden geen extra queries uitgevoerd
    echo $post->user->name;
}

Er worden maar twee SQL-queries uitgevoerd:

select * from posts

select * from users where id in (1, 2, 3, ...)

Meerdere relaties tegelijk eager loaden

Je kunt meerdere relaties opgeven met een array.

$posts = Post::with(['user', 'comments', 'tags'])->get();

Genest eager loaden

Met de puntnotatie kun je ook geneste relaties eager loaden.

// Eager load de reacties op posts en de gebruiker van elke reactie
$posts = Post::with('comments.user')->get();

Eager loading is zeer belangrijk om het N+1-probleem te voorkomen. Maak er een gewoonte van om altijd with() te gebruiken wanneer je binnen een lus relaties benadert.

Volgende stappen