Si i përcaktoni marrëdhëniet e Eloquent?

Question

Accepted Answer

**Marrëdhëniet e Eloquent** modelojnë se si tabela të bazës së të dhënave lidhen, të përcaktuara si metoda në modele. Laravel suporton të gjitha llojet e zakonshme të marrëdhënieve — një-me-shumë, shumë-me-shumë, një-me-një, dhe më shumë — duke ju dhënë qasje elegante, të orientuara nga objekti në të dhënat e lidhura.

## Një-me-shumë (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
```

Marrëdhënia më e zakonshme: një prind `hasMany` fëmijë, dhe çdo fëmijë `belongsTo` prindi. Qasja në marrëdhënien si pronë kthen modele(t) e lidhura.

## Shumë-me-shumë (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
```

**Shumë-me-shumë** përdor një tabelë pivot (menaxhuar automatikisht), me `attach`/`detach`/`sync` për të menaxhuar shoqërimet.

## Llojet e tjera të marrëdhënies

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

## Ngarkimi i paravendosur (shmangni 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();
```

Përdorni `with()` për të **ngarkuar paravendosur** marrëdhëniet dhe për të parandaluar problemin e pyetjeve N+1.

## Pse ka rëndësi

Marrëdhëniet e Eloquent janë thelbësore për të punuar me të dhëna relacionale në Laravel — gati çdo aplikacion ka entitete të lidhura (përdorues dhe postime, postime dhe etiketat, porosit dhe artikujt), kështu që kuptimi se si të përcaktojnë dhe përdorin marrëdhëniet është njohuri fundamentale e përditshme.

Njohja e llojeve të marrëdhënies dhe kur ta përdorni secilin — **`hasMany`/`belongsTo`** për një-me-shumë (më e zakonshme), **`belongsToMany`** për shumë-me-shumë (me tabelën pivot dhe `attach`/`detach`/`sync`), `hasOne` për një-me-një, dhe marrëdhënie polimorfike për shoqërime fleksibël — është e nevojshme për të modeluar ndonjë të dhënë jo-triviale dhe është një nga karakteristikat më të fuqishme dhe më elegante të Eloquent.

Marrëdhëniet ju japin qasje intuitive, të orientuara nga objekti në të dhënat e lidhura (`$user->posts`, `$post->author`) pa shkruar lidhje të dorës, që është një përfitim i madh produktiviteti.

Rënësisht, kuptimi i **ngarkimit të paravendosur me `with()`** për të parandaluar **problemin e pyetjeve N+1** (ku qasja në marrëdhëniet në një lak ndezin një pyetje për secilin regjistrim — një çështje serioze e performancës) është thelbësor, sepse marrëdhëniet e bëjnë problemet N+1 të lehtë për t'u futur.

Mastering marrëdhëniet e Eloquent — përcaktimin e tyre, qasjen në të dhënat e lidhura, dhe ngarkimin e paravendosur për të shmangur N+1 — është njohuri thelbësore, e shpeshtë e përdorur që mbështet modelimin efektiv të të dhënave dhe performancën në aplikacionet e Laravel.