Kako definirate Eloquent razmerja?

Question

Accepted Answer

**Eloquent razmerja** modelirajo, kako se baze podatkov med seboj povezujejo, definirana kot metode na modelih. Laravel podpira vse običajne vrste razmerij — ena-na-mnogo, mnogo-na-mnogo, ena-na-ena in drugo — kar vam omogoča eleganten, objektno-orientiran dostop do povezanih podatkov.

## Ena-na-mnogo (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
```

Najpogostejše razmerje: nadrejena entiteta `hasMany` podrejenih, vsaka podrejena entiteta pa `belongsTo` nadrejeni. Dostop do razmerja kot lastnosti vrne povezane modele.

## Mnogo-na-mnogo (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
```

**Mnogo-na-mnogo** uporablja pivot tabelo (upravljano avtomatsko), s `attach`/`detach`/`sync` za upravljanje povezav.

## Druge vrste razmerij

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

## Napredno nalaganje (izognite se 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();
```

Uporabite `with()` za **napredno nalaganje** razmerij in preprecite N+1 težavo s poizvedbami.

## Zakaj je to pomembno

Eloquent razmerja so bistvena za delo s povezanimi podatki v Laravelu — skoraj vsaka aplikacija ima povezane entitete (uporabnike in objave, objave in oznake, naročila in predmete), zato je razumevanje, kako definirati in uporabljati razmerja, temeljno vsakodnevno znanje.

Znanje vrst razmerij in kdaj uporabiti vsako — **`hasMany`/`belongsTo`** za ena-na-mnogo (najpogostejše), **`belongsToMany`** za mnogo-na-mnogo (s pivot tabelo in `attach`/`detach`/`sync`), `hasOne` za ena-na-ena in polimorfna razmerja za fleksibilne povezave — je potrebno za modeliranje vseh ne-trivialnih podatkov in je ena najbolj moćnih, elegantnih lastnosti Eloquenta.

Razmerja vam omogočajo intuitiven, objektno-orientiran dostop do povezanih podatkov (`$user->posts`, `$post->author`) brez ročnega pisanja JOIN-ov, kar je velika korist za produktivnost.

Kritično je razumevanje **naprednega nalaganja z `with()`** za preprecitev **N+1 težave s poizvedbami** (kjer dostop do razmerij v zanki sproži poizvedbo na zapis — resna težava s performancami) je bistveno, saj razmerja olajšajo uvajanje N+1 problemov.

Ovladati Eloquent razmerja — njihovo definiranje, dostop do povezanih podatkov in napredno nalaganje za izogib N+1 — je temeljno, pogosto uporabljano znanje, ki je temelj učinkovitega modeliranja podatkov in performanc v Laravel aplikacijah.