როგორ ინტეგრირებთ SQL მონაცემთა ბაზას FastAPI-თან?

Question

Accepted Answer

Django-სგან განსხვავებით, FastAPI არის **აზრზე დამოუკიდებელი** მონაცემთა ბაზებთან დაკავშირებით — თქვენ ირჩევთ ბიბლიოთეკას. საერთო არჩევანი არის **SQLAlchemy** (ხშირად **SQLModel**-თან, FastAPI-ს ავტორის მხრიდან, რომელიც აერთიანებს SQLAlchemy + Pydantic). მონაცემთა ბაზის სესიები უზრუნველყოფილია დამოკიდებულების ინჟექციის მეშვეობით.

## SQLAlchemy დაყენება

```python
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base

engine = create_engine("postgresql://user:pass@localhost/db")
SessionLocal = sessionmaker(bind=engine)
Base = declarative_base()

class User(Base):                        # an ORM model (maps to a table)
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String, unique=True)
```

## DB სესიის მიწოდება დამოკიდებულების მাধ্যმით

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                 # provide the session
    finally:
        db.close()               # ALWAYS close after the request (cleanup)

@app.get("/users/{id}")
def get_user(id: int, db: Session = Depends(get_db)):   # inject a session per request
    user = db.query(User).filter(User.id == id).first()
    if not user:
        raise HTTPException(404, "Not found")
    return user
```

`yield` დამოკიდებულების შაბლონი არის სტანდარტული გზა სესიების მართვისთვის: ერთი გახსენით თითოეული მოთხოვნის განმავლობაში, ჩაამატეთ იგი და დახურეთ იგი ავტომატურად — თითოეული endpoint მიიღებს სუფთა, სათანადოდ დახურულ სესიას.

## SQLModel — SQLAlchemy + Pydantic ერთში

```python
from sqlmodel import SQLModel, Field, Session, select

class User(SQLModel, table=True):        # ONE class = ORM model AND Pydantic model
    id: int | None = Field(default=None, primary_key=True)
    name: str
    email: str

@app.get("/users")
def list_users(db: Session = Depends(get_session)):
    return db.exec(select(User)).all()    # query; results are also valid response models
```

SQLModel აერთიანებს ORM მოდელს და Pydantic მოდელს ერთ კლასში — ამცირებს დუბლირებას მონაცემთა ბაზასა და API სქემებს შორის.

## მიგრაციები და async ვარიანტები

```text
✓ Migrations: use Alembic (SQLAlchemy's migration tool) for schema changes
✓ Async: use SQLAlchemy's async engine + async session for async endpoints
  (don't use a SYNC database driver inside async def — it blocks the event loop)
```

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

მონაცემთა ბაზის ინტეგრაცია აუცილებელია თითქმის ნებისმიერი რეალური API-სთვის, და რადგან FastAPI განზრახ არის **აზრზე დამოუკიდებელი** მასთან დაკავშირებით (Django-ს ჩაშენებული ORM-ის განსხვავებით), საერთო მიდგომის გაგება მნიშვნელოვანი პრაქტიკული ცოდნაა.

სტანდარტული შაბლონი — **SQLAlchemy** (ან **SQLModel**, რომელიც ელეგანტურად აერთიანებს ORM-ს და Pydantic მოდელებს დუბლირების შემცირებისთვის) **დამოკიდებულების ინჟექციით შეტანილი სესიებით** `yield` შაბლონის მეშვეობით — ეს არის ის, რაც თითქმის ყველა FastAPI აპლიკაცია იყენებს მონაცემების შენახვისთვის.

სესია-თითო-მოთხოვნის დამოკიდებულება (გახსენით ადრე, დახურეთ შემდეგ, ავტომატურად) არის იდიომატური, სწორი გზა მონაცემთა ბაზის კავშირების მართვისთვის, და SQLModel-ის მონაცემთა ბაზისა და API სქემების აერთიანება არის საყურადღებო პროდუქტიულობის ფიჩა FastAPI-ს საკუთარი ავტორის მხრიდან.

მონაცემთა ბაზის დაყენება, სესიების მიწოდება DI-ის მეშვეობით, შეკითხვების შესრულება და მიგრაციების დამუშავება (Alembic) და async გაფრთხოვება (async დრაივერების გამოყენება async endpoint-ებში, არასოდეს ბლოკირება სინქრონული)-ის გაკეთება აუცილებელია მონაცემებით ამოძრავებული FastAPI აპლიკაციების აგებისთვის — რადგან FastAPI გიჩნდებათ თავისუფლება ასარჩევად, ჩვეულებრივი, კარგად სამუშაო გზის ცოდნა ღირებული არის რეალური აპლიკაციების სწორად აგებისთვის.