Eloquent உறவுகளை எவ்வாறு வரையறுப்பது?

Question

Accepted Answer

**Eloquent உறவுகள்** தரவுத்தளத் அட்டவணைகள் எவ்வாறு தொடர்புடையவை என்பதை மாடல் செய்கிறது, மாடல்களில் முறைகளாக வரையறுக்கப்படுகிறது. 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
```

மிகவும் பொதுவான உறவு: ஒரு பெற்றோல் `hasMany` குழந்தைகள், மற்றும் ஒவ்வொரு குழந்தையும் பெற்றோலுக்கு `belongsTo`. உறவை ஒரு சொத்தாக அணுகுவது தொடர்புடைய மாடல்(களை) வழங்குகிறது.

## 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 அட்டவணையைப் பயன்படுத்துகிறது (தானாகவே நிர்வகிக்கப்படுகிறது), `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 உறவுகள் Laravel இல் தொடர்புடைய தரவுகளுடன் வேலை செய்வதற்கு அপরிহார்யமாகும் — প্রায் எல்லா பயன்பாடுகளிலும் தொடர்புடைய நிறுவனங்கள் உள்ளன (பயனர்கள் மற்றும் பதிப்புகள், பதிப்புகள் மற்றும் குறிச்சொற்கள், உத்தரவுகள் மற்றும் உருப்படிகள்), எனவே உறவுகளை எவ்வாறு வரையறுக்க மற்றும் பயன்படுத்த வேண்டும் என்பதைப் புரிந்துகொள்வது அடிப்படை அன்றாட அறிவாகும்.

ஒவ்வொரு உறவு வகை மற்றும் எப்போது பயன்படுத்த வேண்டும் என்பது அறிவது — **`hasMany`/`belongsTo`** one-to-many க்கு (மிகவும் பொதுவானது), **`belongsToMany`** many-to-many க்கு (pivot அட்டவணை மற்றும் `attach`/`detach`/`sync` உடன்), `hasOne` one-to-one க்கு, மற்றும் polymorphic உறவுகள் நমনீய தொடர்புகளுக்கு — எந்தவொரு trivial அல்லாத தரவையும் மாதிரியாக்குவதற்கு அவசியமாகும் மற்றும் Eloquent இன் மிகவும் சக்திவாய்ந்த, நேர்த்தியான அம்சங்களில் ஒன்றாகும்.

உறவுகள் உங்களுக்கு தொடர்புடைய தரவுக்கு உள்ளுணர்வான, object-oriented அணுகல் வழங்குகிறது (`$user->posts`, `$post->author`) தானாகவே joins எழுதாமல், இது ஒரு முக்கிய உৎপাদनத்தன்மை நன்மை.

আলোচনার விষয়ாকার, **N+1 query சிக்கலைத் தடுக்க `with()` உடன் eager loading** புரிந்துகொள்வது (**N+1 query சிக்கல்** எங்கு ஒரு loop இல் உறவுகளை அணுகுவது ஒரு record க்கு ஒரு query ட்রிகர் செய்கிறது — ஒரு கடுமையான செயல்திறன் சிக்கல்) அவசியமாகும், உறவுகள் N+1 சிக்கல்களை அறிமுகப்படுத்த எளிதாக்குகிறது.

Eloquent உறவுகளை மாஸ்டர் செய்வது — அவற்றை வரையறுத்தல், தொடர்புடைய தரவு அணுகுதல், மற்றும் N+1 ஐ தவிர்க்க eager-loading — Laravel பயன்பாடுகளில் பকை தரவு மாடல்லிங் மற்றும் செயல்திறனை அடியாணையாக் செய்யும் முக்கிய, அடிக்கடி பயன்படுத்தப்படும் அறிவாகும்.