Jak definiujesz relacje Eloquent?

Question

Accepted Answer

**Relacje Eloquent** modelują sposób, w jaki tabele bazy danych się między sobą łączą — definiowane jako metody na modelach. Laravel obsługuje wszystkie powszechne typy relacji — jeden-do-wielu, wiele-do-wielu, jeden-do-jednego i inne — dając ci elegancki, obiektowo-orientowany dostęp do powiązanych danych.

## Jeden-do-wielu (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
```

Najczęstsza relacja: rodzic `hasMany` (ma wielu) dzieci, a każde dziecko `belongsTo` (należy do) rodzica. Dostęp do relacji jako właściwości zwraca powiązany model lub modele.

## Wiele-do-wielu (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
```

**Wiele-do-wielu** używa tabeli pośredniej (pivot table) — zarządzanej automatycznie — z `attach`/`detach`/`sync` do zarządzania skojarzeniami.

## Inne typy relacji

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

Użyj `with()` do **eager-loadowania** relacji i zapobiegania problemowi N+1.

## Dlaczego to ważne

Relacje Eloquent są niezbędne do pracy z danymi relacyjnymi w Laravelu — prawie każda aplikacja ma powiązane encje (użytkownicy i posty, posty i tagi, zamówienia i elementy), dlatego zrozumienie, jak definiować i używać relacji, jest podstawową wiedzą codzienną.

Znajomość typów relacji i kiedy używać każdego — **`hasMany`/`belongsTo`** dla jeden-do-wielu (najczęstsze), **`belongsToMany`** dla wiele-do-wielu (z tabelą pośrednią i `attach`/`detach`/`sync`), `hasOne` dla jeden-do-jednego i relacje polimorficzne dla elastycznych skojarzeń — jest konieczna do modelowania dowolnych, nietrywialnych danych i jest jedną z najmocniejszych, eleganckich cech Eloquenta.

Relacje dają ci intuicyjny, obiektowo-orientowany dostęp do powiązanych danych (`$user->posts`, `$post->author`) bez ręcznego pisania joinów, co jest dużą korzyścią dla produktywności.

Krytycznie, zrozumienie **eager loadowania z `with()`** aby zapobiec **problemowi N+1** (gdzie dostęp do relacji w pętli powoduje zapytanie na jeden rekord — poważny problem wydajności) jest niezbędne, ponieważ relacje ułatwiają wprowadzenie problemów N+1.

Opanowanie relacji Eloquent — ich definiowania, dostępu do powiązanych danych i eager-loadowania aby uniknąć N+1 — to podstawowa, często używana wiedza, która stanowi fundament efektywnego modelowania danych i wydajności w aplikacjach Laravelowych.