როგორ განსაზღვრავთ Eloquent ურთიერთობებს?

Question

Accepted Answer

**Eloquent ურთიერთობები** მოდელირებენ, თუ როგორ უკავშირდება მონაცემთა ბაზის ცხრილები, რომლებიც განსაზღვრულია როგორც მეთოდები მოდელებში. Laravel-ი მხარს უჭერს ყველა გავრცელებული ურთიერთობის ტიპს — one-to-many, many-to-many, one-to-one და სხვა — რაც გაძლევთ ელეგანტურ, ობიექტზე ორიენტირებულ წვდომას დაკავშირებული მონაცემებზე.

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

იყენეთ `with()` რომ **eager-load** გაკეთოთ ურთიერთობები და თავიდან აიცილოთ N+1 query პრობლემა.

## რატომ აქვს ეს მნიშვნელობა

Eloquent ურთიერთობები აუცილებელია Laravel-ში რელაციური მონაცემების სამუშაოდ — თითქმის ყველა აპლიკაციას აქვს დაკავშირებული ერთეულები (მომხმარებლები და პოსტები, პოსტები და ტეგები, ორდერი და ელემენტები), ამიტომ იმის გაცნობა, თუ როგორ განსაზღვრას და გამოიყენოს ურთიერთობები, ფундამენტური ყოველდღიური ცოდნაა.

ურთიერთობის ტიპების გაცნობა და რომელი რა დროს გამოიყენოს — **`hasMany`/`belongsTo`** one-to-many-სთვის (ყველაზე გავრცელებული), **`belongsToMany`** many-to-many-სთვის (pivot ცხრილი და `attach`/`detach`/`sync`-ით), `hasOne` one-to-one-სთვის, და polymorphic ურთიერთობები მოქნილი ასოციაციებისთვის — აუცილებელია ნებისმიერი არატრივიალური მონაცემების მოდელირებისთვის და ეს არის Eloquent-ის ერთ-ერთი ყველაზე მძლავრი, ელეგანტური ფিჩა.

ურთიერთობები გაძლევთ ინტუიციურ, ობიექტზე ორიენტირებულ წვდომას დაკავშირებული მონაცემებზე (`$user->posts`, `$post->author`) join-ების ხელით დაწერის გარეშე, რაც წარმოადგენს დიდ პროდუქტიულობის სარგებელს.

კრიტიკულად, იმის გაცნობა, **eager loading `with()`-ის საშუალებით** რომ თავიდან აიცილოთ **N+1 query პრობლემა** (სადაც ურთიერთობებზე წვდომა ციკლში ტრიგებს query-ს თითო ჩანაწერზე — მძიმე მუშაობის პრობლემა) აუცილებელია, რადგან ურთიერთობები N+1 პრობლემების შემოტანას ადვილი ხდის.

Eloquent ურთიერთობების დაუფლება — მათი განსაზღვრა, დაკავშირებული მონაცემებზე წვდომა, და eager-loading N+1-ის თავიდან აცილების მიზნით — ძირითადი, ხშირად გამოყენებული ცოდნაა, რომელიც უდევს საფუძველს ეფექტიან მონაცემთა მოდელირებას და მუშაობის გაუმჯობესებას Laravel აპლიკაციებში.