Hoe definieer je Eloquent-relaties?

Question

Accepted Answer

**Eloquent-relaties** modelleren hoe databasetabellen met elkaar relateren, gedefinieerd als methoden op modellen. Laravel ondersteunt alle veelgebruikte relatietypen — één-naar-veel, veel-naar-veel, één-naar-één en meer — wat je elegant, object-georiënteerde toegang tot gerelateerde gegevens geeft.

## Één-naar-veel (hasMany / belongsTo)

```php
class User extends Model {
    public function posts() {              // a user HAS MANY posts
        return $this->hasMany(Post::class);
    }
}
class Post extends Model {
    public function author() {              // a post BELONGS TO a user (inverse)
        return $this->belongsTo(User::class);
    }
}

// access related data as properties (lazy-loaded)
$user->posts;          // a Collection of the user's Posts
$post->author;          // the Post's User
$user->posts()->where('published', true)->get();   // query the relationship
```

De meest voorkomende relatie: een parent `hasMany` kinderen, en elk kind `belongsTo` de parent. Als je de relatie als een eigenschap opent, retourneert dit het gerelateerde model (of de modellen).

## Veel-naar-veel (belongsToMany)

```php
class Post extends Model {
    public function tags() {                // posts and tags — many-to-many
        return $this->belongsToMany(Tag::class);   // uses a pivot table (post_tag)
    }
}
$post->tags;                    // the post's tags
$post->tags()->attach($tagId);   // add an association
$post->tags()->detach($tagId);   // remove
$post->tags()->sync([1, 2, 3]);  // set exactly these
```

**Veel-naar-veel** maakt gebruik van een pivot-tabel (automatisch beheerd), met `attach`/`detach`/`sync` om associaties te beheren.

## Andere relatietypen

```php
$this->hasOne(Profile::class);          // one-to-one
$this->hasManyThrough(...);              // has-many through an intermediate model
$this->morphMany(Comment::class, 'commentable');   // POLYMORPHIC (comments on posts OR videos)
```

## Eager loading (vermijd N+1!)

```php
// ❌ N+1: a query per post to get each author
$posts = Post::all();
foreach ($posts as $post) { echo $post->author->name; }

// ✅ eager load with with() — fetches authors in ONE extra query
$posts = Post::with('author')->get();
```

Gebruik `with()` voor **eager-loading** van relaties en voorkom het N+1-queryprobleem.

## Waarom het belangrijk is

Eloquent-relaties zijn essentieel voor het werken met relationele gegevens in Laravel — bijna elke applicatie heeft gerelateerde entiteiten (gebruikers en posts, posts en tags, orders en items), dus het begrijpen hoe je relaties definieert en gebruikt, is fundamentele alledaagse kennis.

Het kennen van de relatietypen en wanneer je elk ervan gebruikt — **`hasMany`/`belongsTo`** voor één-naar-veel (het meest voorkomende), **`belongsToMany`** voor veel-naar-veel (met de pivot-tabel en `attach`/`detach`/`sync`), `hasOne` voor één-naar-één, en polymorfe relaties voor flexibele associaties — is nodig om niet-triviale gegevensmodellen op te stellen en is een van Eloquent's meest krachtige, elegante functies.

Relaties geven je intuïtieve, object-georiënteerde toegang tot gerelateerde gegevens (`$user->posts`, `$post->author`) zonder handmatig joins te hoeven schrijven, wat een groot productiviteitsvoordeel is.

Beslissend is dat het begrijpen van **eager loading met `with()`** ter voorkoming van het **N+1-queryprobleem** (waarbij het openen van relaties in een lus een query per record activeert — een ernstig prestatieprobleem) essentieel is, omdat relaties N+1-problemen gemakkelijk kunnen introduceren.

Eloquent-relaties beheersen — ze definiëren, gerelateerde gegevens benaderen, en eager-loading toepassen om N+1 te voorkomen — is kernkennis die veel wordt gebruikt en vormt de basis voor effectieve gegevensmodellering en prestaties in Laravel-applicaties.