તમે Eloquent સંબંધો કેવી રીતે વ્યાખ્યાયિત કરો છો?

Question

Accepted Answer

**Eloquent સંબંધો** ડેટાબેસ ટેબલ્સ કેવી રીતે સંબંધિત છે તેને મોડેલ કરે છે, જે મોડલ્સ પર મેથોડ્સ તરીકે વ્યાખ્યાયિત થાય છે. Laravel બધા સામાન્ય સંબંધ પ્રકારોને સમર્થન આપે છે — one-to-many, many-to-many, one-to-one, અને વધુ — જે તમને સંબંધિત ડેટાતો elegant, object-oriented approach આપે છે.

## 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 તેના parent ને `belongsTo` કરે છે. સંબંધને property તરીકે access કરવાથી સંબંધિત 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` વાપર કરીને associations સંચાલન કરવામાં આવે છે.

## અન્ય સંબંધ પ્રકારો

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

સંબંધોને **eager-load** કરવા અને N+1 query સમસ્યાને રોકવા માટે `with()` વાપરો.

## આ શા માટે મહત્વપૂર્ણ છે

Eloquent સંબંધો Laravel માં સંબંધિત ડેટા સાથે કામ કરવા માટે આવશ્યક છે — લગભગ દરેક application મા સંબંધિત entities હોય છે (users અને posts, posts અને tags, orders અને items), તેથી સંબંધોને કેવી રીતે વ્યાખ્યાયિત અને ઉપયોગ કરવો તે સમજવું મૂળભૂત દૈનિક જ્ઞાન છે.

સંબંધ પ્રકારો અને દરેક કોને કયારે વાપરવો તે જાણવું — **`hasMany`/`belongsTo`** one-to-many માટે (સૌથી સામાન્ય), **`belongsToMany`** many-to-many માટે (pivot table અને `attach`/`detach`/`sync` સાથે), `hasOne` one-to-one માટે, અને polymorphic relations લ유ચણશીલ associations માટે — કોઈપણ non-trivial ડેટા મોડલ કરવા માટે આવશ્યક છે અને Eloquent ની સૌથી શક્તિશાળી, elegant સુવિધાઓ છે.

સંબંધો તમને intuitive, object-oriented approach આપે છે સંબંધિત ડેટાતો (`$user->posts`, `$post->author`) જોડાણ(joins) manually લખ્યા વિના, જે એક મોટો productivity લાભ છે.

મહત્વપૂર્ણ રીતે, **`with()` સાથે eager loading** સમજવું જેથી **N+1 query સમસ્યા** (જ્યાં loop માં સંબંધોને access કરવાથી દરેક record માટે એક query ચાલે છે — એક serious performance issue) ટાળી શકાય, આવશ્યક છે, કારણ કે સંબંધો N+1 સમસ્યાઓ સરળતાથી પેદા કરે છે.

Eloquent સંબંધોમાં માહિર થવું — તેમને વ્યાખ્યાયિત કરવું, સંબંધિત ડેટા access કરવું, અને N+1 ટાળવા માટે eager-load કરવું — Laravel applications માં અસરકારક ડેટા મોડલિંગ અને performance ની ભીંતી આધાર બનતું core, frequently-used જ્ઞાન છે.