ORM'de ilişkileri nasıl modellersiniz?

Question

Accepted Answer

Django'nun ORM'si üç temel veritabanı ilişkisini ayrılmış alan türleriyle modeller: **ForeignKey** (bire-çok), **ManyToManyField** (çok-çok) ve **OneToOneField** (bire-bir). Bunlar tabloların nasıl ilişkili olduğunu tanımlar ve ilişkili nesnelere Pythonic erişim sağlar.

## ForeignKey — bire-çok (en yaygın)

```python
class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(
        Author,
        on_delete=models.CASCADE,        # what happens if the author is deleted
        related_name="books",            # access the reverse: author.books
    )
```

```python
# access related objects naturally:
book.author                # the Author this book belongs to (forward)
author.books.all()         # all Books by this author (reverse, via related_name)
```

`ForeignKey` "birçok kitap bir yazara aittir" ilişkisini modeller. `on_delete` davranışı (`CASCADE`, `PROTECT`, `SET_NULL`, vb.) **zorunludur** ve yazar silinirse kitaplara ne olacağını tanımlar.

## ManyToManyField — çok-çok

```python
class Article(models.Model):
    title = models.CharField(max_length=200)
    tags = models.ManyToManyField("Tag", related_name="articles")   # many tags ↔ many articles

class Tag(models.Model):
    name = models.CharField(max_length=50)
```

```python
article.tags.add(tag1, tag2)        # associate tags
article.tags.all()                   # all tags on this article
tag.articles.all()                   # all articles with this tag (reverse)
```

Django otomatik olarak `ManyToManyField`'in arkasında **birleştirme tablosunu** oluşturur — `.add()`, `.remove()`, `.all()` gibi metotları kullanırsınız. (İlişkiye ek veri eklemek için `through` modeli kullanın.)

## OneToOneField — bire-bir

```python
class User(models.Model):
    username = models.CharField(max_length=50)

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)   # one profile per user
    bio = models.TextField()
```

`OneToOneField` katı bir bire-bir bağlantı sağlar — yaygın olarak bir modeli genişletmek için kullanılır (örn. bir User'ı genişleten Profile).

## on_delete seçenekleri (doğru seçmek önemlidir)

```text
CASCADE   → delete related objects too (delete author → delete their books)
PROTECT   → prevent deletion if related objects exist (raises an error)
SET_NULL  → set the FK to NULL (requires null=True) — keep the books, orphan them
SET_DEFAULT / SET(...) → set to a default/computed value
RESTRICT  → similar to PROTECT, with nuances
```

## İlişkiler arasında sorgulama

```python
# traverse relationships in queries with __ (double underscore)
Book.objects.filter(author__name="Tolkien")        # books whose author's name is Tolkien
Article.objects.filter(tags__name="python")         # articles tagged 'python'
```

## Neden önemli

İlişkileri doğru şekilde modellemek, Django'da ilişkisel verilerle çalışmanın temelini oluşturur — neredeyse her gerçek uygulamanın ilişkili varlıkları vardır (kullanıcılar ve gönderiler, siparişler ve öğeler, makaleler ve etiketler), bu nedenle üç ilişki alan türünü anlamak günlük işin temel parçasıdır.

Herbirini ne zaman kullanacağınızı bilmek — bire-çok için **ForeignKey** (yazara ait kitaplar gibi en yaygın), çok-çok için **ManyToManyField** (makaleler ve etiketler gibi, Django birleştirme tablosunu otomatik yönetir) ve bire-bir için **OneToOneField** (kullanıcıyı profile ile genişletmek gibi) — önemsiz olmayan herhangi bir veri modeli tasarlamak için gereklidir.

ORM, ilişkili verileri **Pythonic ve uygun hale getirir** (`book.author` ve `author.books.all()`'e doğal olarak erişmek, ilişkiler arasında `__` ile sorgulama yapmak), ancak iki yön dikkat gerektirir: doğru **`on_delete` davranışını seçmek** (zorunlu, önemli bir karar — `CASCADE` ilişkili nesneleri siler, `PROTECT` silmeyi engeller, `SET_NULL` bunları yetim bırakır — yanlış yapmak yanlışlıkla veri kaybı veya tutarlılık hatalarına neden olabilir) ve net ters erişim için `related_name` kullanmak.

İlişki modellemesini, `on_delete` seçeneklerini ve ilişkiler arası sorgulamayı anlamak, doğru ve iyi tasarlanmış Django veri modellerini oluşturmanın çekirdeğidir ve sorgu optimizasyonuyla doğrudan bağlantılıdır (ilişkileri naif şekilde geçiş yapmak N+1 problemlerine neden olur), bu da onu hem temel hem de sık sınavda görülen bilgi haline getirir.