Kako definirate Eloquent relacije?

Question

Accepted Answer

**Eloquent relacije** modeliraju kako se tablice baze podataka međusobno povezuju, definirane kao metode na modelima. Laravel podržava sve česte tipove relacija — one-to-many, many-to-many, one-to-one i druge — dajući vam elegantan, objektno-orijentirani pristup povezanim podacima.

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

Najčešća relacija: roditeljski model `hasMany` dječjih modela, a svaki dječji model `belongsTo` roditeljskom modelu. Pristup relaciji kao svojstvu vraća povezane modele.

## 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** koristi pivotnu tablicu (automatski upravljanu), sa `attach`/`detach`/`sync` za upravljanje asocijacijama.

## Ostali tipovi relacija

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

Koristite `with()` za **eager-loading** relacija i sprječavanje N+1 problema s upitima.

## Zašto je to važno

Eloquent relacije su bitne za rad s relacijskim podacima u Laravelu — gotovo svaka aplikacija ima povezane entitete (korisnici i postovi, postovi i tagovi, narudžbe i stavke), pa je razumijevanje kako definirane i koristiti relacije temeljno svakodnevno znanje.

Znanje tipova relacija i kada koristiti svaki — **`hasMany`/`belongsTo`** za one-to-many (najčešći), **`belongsToMany`** za many-to-many (s pivotnom tablicom i `attach`/`detach`/`sync`), `hasOne` za one-to-one, i polimorfne relacije za fleksibilne asocijacije — neophodno je za modeliranje bilo kakvih netrivijalnih podataka i jedan je od Eloquentovih najmoćnijih, elegantnijih značajki.

Relacije vam daju intuitivan, objektno-orijentirani pristup povezanim podacima (`$user->posts`, `$post->author`) bez ručnog pisanja join-ova, što je veliki benefit za produktivnost.

Kritično, razumijevanje **eager loadinga s `with()`** kako bi se spriječio **N+1 problem s upitima** (gdje pristup relacijama u petlji pokida upit po zapisu — ozbiljan problem performansi) je bitno, jer relacije čine N+1 probleme lako uvesti.

Savladavanje Eloquent relacija — njihovo definiranje, pristup povezanim podacima, i eager-loading kako bi se izbjegao N+1 — je temeljno, često korišteno znanje koje je temelj učinkovitog modeliranja podataka i performansi u Laravel aplikacijama.