Jak definujete Eloquent vztahy?

Question

Accepted Answer

**Eloquent vztahy** modelují způsob, jakým se relacionují databázové tabulky, a definují se jako metody na modelech. Laravel podporuje všechny běžné typy vztahů — one-to-many, many-to-many, one-to-one a další — což vám poskytuje elegantní, objektově orientovaný přístup k souvisejícím datům.

## 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
```

Nejčastější vztah: rodič `hasMany` (má mnoho) dětí a každé dítě `belongsTo` (patří) rodiči. Přístup k vztahu jako k vlastnosti vrátí související model(y).

## 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
```

**Many-to-many** používá pivot tabulku (spravovanou automaticky), s `attach`/`detach`/`sync` pro správu asociací.

## Ostatní typy vztahů

```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 (zabráníte 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();
```

Použijte `with()` k **eager-loadingu** vztahů a zabránění problému s N+1 dotazy.

## Proč je to důležité

Eloquent vztahy jsou nezbytné pro práci s relačními daty v Laravelu — téměř každá aplikace má související entity (uživatelé a příspěvky, příspěvky a štítky, objednávky a položky), takže pochopení toho, jak definovat a používat vztahy, je základní každodenní znalostí.

Znalost typů vztahů a kdy použít každý — **`hasMany`/`belongsTo`** pro one-to-many (nejčastější), **`belongsToMany`** pro many-to-many (s pivot tabulkou a `attach`/`detach`/`sync`), `hasOne` pro one-to-one a polymorfní vztahy pro flexibilní asociace — je nutná pro modelování jakýchkoli netriviálních dat a je jednou z nejsilnějších, nejelegantnějších funkcí Eloquentu.

Vztahy vám dávají intuitivní, objektově orientovaný přístup k souvisejícím datům (`$user->posts`, `$post->author`) bez ručního psaní joinů, což je velký přínos produktivity.

Velmi důležitě je pochopení **eager loadingu s `with()`** pro zabránění **problému N+1 dotazů** (kde přístup k vztahům v cyklu vyvolá dotaz na záznam — vážný problém s výkonem) nezbytné, protože vztahy usnadňují zavedení problémů N+1.

Opanování Eloquent vztahů — jejich definování, přístup k souvisejícím datům a eager-loading pro zabránění N+1 — je základní, často používanou znalostí, která je základem efektivního modelování dat a výkonu v Laravelových aplikacích.