Cum definiți relațiile Eloquent?

Question

Accepted Answer

**Relațiile Eloquent** modelează modul în care tabelele bazei de date sunt corelate, definite ca metode pe modele. Laravel suportă toate tipurile de relații obișnuite — one-to-many, many-to-many, one-to-one și altele — oferindu-vă acces elegant, orientat pe obiecte la date corelate.

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

Cea mai comună relație: un părinte `hasMany` copii, și fiecare copil `belongsTo` părintele. Accesarea relației ca proprietate returnează model(ele) corelat(e).

## 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** folosește un tabel pivot (gestionat automat), cu `attach`/`detach`/`sync` pentru a gestiona asociații.

## Alte tipuri de relații

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

Folosiți `with()` pentru a **eager-load** relații și a preveni problema query N+1.

## De ce conteaza

Relațiile Eloquent sunt esențiale pentru lucrul cu date relaționale în Laravel — aproape fiecare aplicație are entități corelate (utilizatori și postări, postări și etichete, comenzi și articole), deci înțelegerea modului de definire și utilizare a relațiilor este cunoaștere fundamentală de zi cu zi.

Cunoscerea tipurilor de relații și când să folosiți fiecare — **`hasMany`/`belongsTo`** pentru one-to-many (cea mai comună), **`belongsToMany`** pentru many-to-many (cu tabelul pivot și `attach`/`detach`/`sync`), `hasOne` pentru one-to-one, și relații polimorfice pentru asociații flexibile — este necesară pentru modelarea oricăror date non-triviale și este una dintre cele mai puternice și elegante caracteristici ale Eloquent.

Relațiile vă oferă acces intuitiv, orientat pe obiecte la date corelate (`$user->posts`, `$post->author`) fără a scrie manual join-uri, ceea ce este un beneficiu major de productivitate.

Critic, înțelegerea **eager loading cu `with()`** pentru a preveni **problema query N+1** (unde accesarea relațiilor într-o buclă declanșează o cerere per înregistrare — o problemă severă de performanță) este esențială, deoarece relațiile fac ușor introducerea problemelor N+1.

Stăpânirea relațiilor Eloquent — definirea lor, accesarea datelor corelate, și eager-loading pentru a evita N+1 — este cunoaștere fundamentală, frecvent utilizată, care susține modelarea eficientă a datelor și performanța în aplicațiile Laravel.