మీరు Eloquent సంబంధాలను ఎలా నిర్వచిస్తారు?

Question

Accepted Answer

**Eloquent relationships** డేటాబేస్ టేబుల్‌లు ఎలా సంబంధం కలిగి ఉన్నాయో మోడల్ చేస్తాయి, ఇవి మోడల్‌ల మీద పద్ధతులుగా నిర్వచించబడతాయి. Laravel అన్ని సాధారణ సంబంధ రకాలను సమర్థిస్తుంది — one-to-many, many-to-many, one-to-one, మరియు మరిన్ని — ఇది సంబంధిత డేటాకు సొగసైన, object-oriented యాక్సెస్ ఇస్తుంది.

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

సర్వ సాధారణ సంబంధం: ఒక parent `hasMany` children, మరియు ప్రతి child `belongsTo` parent. సంబంధాన్ని property గా యాక్సెస్ చేస్తే సంబంధిత model(s) తిరిగి వస్తుంది.

## 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** ఒక pivot table ను ఉపయోగిస్తుంది (ఆటోమేటిక్‌గా నిర్వహించబడుతుంది), సంబంధాలను నిర్వహించడానికి `attach`/`detach`/`sync` తో.

## ఇతర సంబంధ రకాలు

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

N+1 query సమస్యను నిరోధించడానికి సంబంధాలను **eager-load** చేయడానికి `with()` ను ఉపయోగించండి.

## ఎందుకు ముఖ్యమైనది

Eloquent relationships Laravel లో సంబంధిత డేటా కోసం పనిచేయడానికి అత్యవసరమైనవి — దాదాపు ప్రతి అప్లికేషన్‌కు సంబంధిత entities (users మరియు posts, posts మరియు tags, orders మరియు items) ఉన్నాయి, కాబట్టి సంబంధాలను ఎలా నిర్వచించాలి మరియు ఉపయోగించాలో అర్థం చేసుకోవడం ఒక ప్రాథమిక రోజువారీ జ్ఞానం.

సంబంధ రకాలను మరియు ఎప్పుడు ప్రతిదాన్ని ఉపయోగించాలో తెలుసుకోవడం — **`hasMany`/`belongsTo`** one-to-many (అత్యంత సాధారణ), **`belongsToMany`** many-to-many (pivot table మరియు `attach`/`detach`/`sync` తో), one-to-one కోసం `hasOne`, మరియు유연한సంబంధాల కోసం polymorphic relations — ఏదైనా non-trivial డేటాను మోడల్ చేయడానికి అవసరమైనది మరియు ఇది Eloquent యొక్క అత్యంత శక్తిశాలి, సొగసైన లక్షణాలలో ఒకటి.

Relationships మీకు సంబంధిత డేటాకు సహజమైన, object-oriented యాక్సెస్ ఇస్తాయి (`$user->posts`, `$post->author`) మానవీయంగా joins లను రాయకుండానికి, ఇది ఒక ప్రధాన ఉత్పादకత ప్రయోజనం.

ప్రతికూలంగా, **`with()` తో eager loading** ను అర్థం చేసుకోవడం **N+1 query సమస్య** (ఇక్కడ loop లో relationships ని యాక్సెస్ చేస్తే ప్రతి record కు ఒక query ట్రిగర్ అవుతుంది — ఒక తీవ్ర performance సమస్య) నిరోధించడానికి అవసరమైనది, relationships N+1 సమస్యలను పరిచయం చేయడం సులభం చేస్తాయి.

Eloquent relationships లను నేర్చుకోవడం — వాటిని నిర్వచించడం, సంబంధిత డేటాను యాక్సెస్ చేయడం, మరియు N+1 నుండి తప్పించడానికి eager-load చేయడం — ఇది core, తరచుగా-ఉపయోగించిన జ్ఞానం ఇది Laravel అప్లికేషన్‌లలో ప్రభావవంతమైన డేటా మోడలింగ్ మరియు performance కు ఆధారం.