Hogyan definiálsz Eloquent relációkat?

Question

Accepted Answer

**Az Eloquent relációk** azt modellezik, hogy az adatbázis-táblák hogyan kapcsolódnak egymáshoz, és modellek metódusaiként vannak definiálva. A Laravel az összes közös relációtípust támogatja — one-to-many, many-to-many, one-to-one és még több — ami elegáns, objektum-orientált hozzáférést biztosít a kapcsolódó adatokhoz.

## One-to-many (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
```

A leggyakoribb reláció: egy szülő `hasMany` gyermekek, és minden gyermek `belongsTo` a szülőhöz. A relációt tulajdonságként elérve a kapcsolódó modell(ek)et kapod vissza.

## Many-to-many (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
```

A **many-to-many** egy pivot táblát használ (automatikusan kezelve), az `attach`/`detach`/`sync` műveletekkel az asszociációk kezeléséhez.

## Egyéb relációtípusok

```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 (kerüld az N+1 problémát!)

```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();
```

Használd a `with()` metódust az **eager-loading** relációkhoz, és kerüld el az N+1 query problémát.

## Miért fontos

Az Eloquent relációk nélkülözhetetlenek a relációs adatokkal való munkához a Laravelben — szinte minden alkalmazásnak vannak kapcsolódó entitásai (felhasználók és posztok, posztok és tagok, megrendelések és tételek), így a relációk definiálása és használata alapvető, mindennapi tudás.

A relációtípusok ismerete és az alkalmazásukat — a **`hasMany`/`belongsTo`** one-to-many-hez (a leggyakoribb), **`belongsToMany`** many-to-many-hez (a pivot tábla és `attach`/`detach`/`sync` használatával), `hasOne` one-to-one-hez, és polimorf relációk rugalmas asszociációkhoz — szükséges bármilyen nem triviális adat modellezéséhez, és az Eloquent egyik legerősebb, legecskezebb funkciója.

A relációk intuitív, objektum-orientált hozzáférést biztosítanak a kapcsolódó adatokhoz (`$user->posts`, `$post->author`) anélkül, hogy manuálisan kellene joinokat írni, ami nagy termelékenységi előnyt jelent.

Kritikusan fontos az **eager loading `with()` segítségével** az **N+1 query probléma megelőzésére** (ahol relációk egy cikluson belüli elérése minden rekord után egy queryt vált ki — egy súlyos teljesítményprobléma), mivel a relációk könnyen bevezethető N+1 problémákat teremtenek.

Az Eloquent relációk elsajátítása — azok definiálása, kapcsolódó adatok elérése, és eager-loading az N+1 elkerüléséhez — alapvető, gyakran használt tudás, amely a hatékony adatmodellezés és teljesítmény alapja a Laravel alkalmazásokban.