Yadda suke aiki da models da ORM?

Question

Accepted Answer

**Model** shine jerin tushen Python wanda ke bayyana tsarin bayanannika — kowane model ya dace da teburin database, kuma kowane sifa ta dace da ginshiki. **ORM (Object-Relational Mapper)** yana ba ka damar yin hulɗa da database ta amfani da abubuwan Python da hanyoyi, maimakon rubuta raw SQL.

## Ayyana model

```python
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)       # → VARCHAR column
    body = models.TextField()                        # → TEXT column
    published = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)  # set on creation
    views = models.IntegerField(default=0)

def __str__(self):
        return self.title                            # readable representation (admin, shell)
```

Kowane fili na model ya dace da ginshiki na database tare da nau'in da ya dace. Guduwar migrations yana bubugin teburin da ya dace — ba ka taɓa rubuta `CREATE TABLE` da kanka.

## CRUD tare da ORM (babu SQL)

```python
# CREATE
article = Article.objects.create(title="Hello", body="...")

# READ — query with Python methods
Article.objects.all()                            # all rows → SELECT *
Article.objects.get(id=1)                         # one row by primary key
Article.objects.filter(published=True)            # WHERE published = true
Article.objects.filter(title__icontains="django") # WHERE title ILIKE '%django%'
Article.objects.exclude(views=0).order_by("-created_at")  # complex queries, chained

# UPDATE
article.title = "Updated"
article.save()
Article.objects.filter(published=False).update(published=True)  # bulk update

# DELETE
article.delete()
```

ORM yana fassara waɗannan kiran Python zuwa SQL ta atomatik. Field lookups (`__icontains`, `__gte`, `__in`, da sauransu) suna bayyana yanayin WHERE ta hanyar Python.

## Me ya sa aka buƙaci ORM? Fa'idodi da ambaliya

```text
✓ Write database code in Python — no SQL, more readable, less error-prone
✓ Database-agnostic — the same code works on PostgreSQL, MySQL, SQLite
✓ SECURITY — parameterized queries by default → prevents SQL injection
✓ Integrates with migrations, admin, forms (define the model once)
⚠️ Trade-off: can generate inefficient queries (e.g. N+1) if used carelessly —
   sometimes you need select_related/prefetch_related or raw SQL for complex cases
```

## Models sune tushen gida guda (DRY)

```text
One model definition drives: the database schema (migrations), the admin interface,
ModelForms, and serializers (DRF) — define it once, reuse everywhere.
```

## Me ya sa hakan yake matukar muhimmi

Models da ORM sune abubuwan mahimmanci a cikin Django — su ne yadda kake bayyana da aiki da bayananin aikinka, wanda shine zuciya na mafi yawan aikace-aikacen yanar gida.

Ganewar su aje dole: models suna bayyana tsarin bayanannika (linzumin azuzuwan teburi, sifofin zuwa ginshiki) kuma suna zama **tushen gida guda** wanda ke jagorancin tsarin database, jirgin admin, fomu, da shirye-shiryen API (falsafar DRY).

ORM yana ba ka damar rubuta ayyukan database a cikin mahallin Python mai asancewa, **maimakon SQL**, tare da manyan fa'idodi: jujjuyawar database (kodai guda ya aiki akan bangarorin daban-daban), haɗuwa mai karfi tare da sauran Django, kuma a ainihi **tsaro** (yana amfani da jigon buɗe-buɗe ta tiyaga, sakewa injection SQL).

Sanin yadda aka ayyana models tare da sifofin da suka dace, aiki CRUD, da neman amfani da tsarin kawar ORM shine abokin ƙasa a gina duk aikace-aikacen Django.

Daidai mahimmaci kuma shine fahimtar **ambaliya** na ORM — cewa neman amfani mai satsi na iya zama rashin inganci (`N+1` matsala) ba tare da hankali ba — wanda yake geji ga fasahohin ingantawa.

Matsin model/ORM shine abin da aikace-aikacen Django suke kudan lokaci-lokacin su a ciki, wanda yake sa shi tushe, maƙasusu abin kowaici.