Conas dhéanfá dáileog dhháta SQL a chomhiomlánaigh le FastAPI?

Question

Accepted Answer

Murab ionann is Django, tá **FastAPI gan bharúil** ar dhálraigí — roghnaíonn tú an leabharlann. Is é **SQLAlchemy** an rogha choitinn (go minic le **SQLModel**, arna scríobh ag údar FastAPI, a chumasc SQLAlchemy + Pydantic). Cuirtear seisiúin dhháta ar fáil trí dhíbirt ionchuir.

## Socrú 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)
```

## An seisiún DB a sholáthar trí dhíbirt

```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
```

Is é an patrún díbirt `yield` an gnáthbhealach chun seisiúin a bhainistiú: oscail ceann in aghaidh gach iarratais, isteach air, agus dún é ina dhiaidh sin go huathoibríoch — faigheann gach críochphointe seisiún geal, dúnta i gceart.

## SQLModel — SQLAlchemy + Pydantic in aon cheann amháin

```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
```

Cumasc SQLModel an tsamhail ORM agus an tsamhail Pydantic i aon rang amháin — laghdú dúbláil idir dháleog agus scéimeanna API.

## Imircí agus roghanna neamhsioncroinicithe

```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)
```

## Cén fáth a bhfuil sé tábhachtach

Tá comhiomlánaigh dháileoige riachtanach do bheagnach aon API bheo, agus ó bhí FastAPI gan bharúil i leith (murab ionann is ORM ionsuite Django), is eolais phraicticiúil thábhachtach a bhaint as an nganntir choitinn.

An patrún caighdeánach — **SQLAlchemy** (nó **SQLModel**, ar a chumasc an ORM agus samhlacha Pydantic go deas chun dúbláil a laghdú) le **seisiúin dhíbeirte i ndibrirt** trí an patrún `yield` — is ea a úsáideann beagnach gach aip FastAPI chun sonraí a choinneáil.

Is é an díbirt seisiúin-in-aghaidh-iarratais (oscail roimh ré, dún ina dhiaidh sin, go huathoibríoch) an bealach idiomasach, ceart chun nasc dhháta a bhainistiú, agus is gné táirgiúlachta suntasach í aontú SQLModel ar dhálraigí agus scéimeanna API ó údar FastAPI féin.

Tá a fhios conas an dáleog a shocrú, seisiúin a sholáthar trí DI, fiosruithe a dhéanamh, agus imircí (Alembic) agus an t-earráid neamhsioncroinicithe (drivéirí neamhsioncroinicithe a úsáid i críochphointí neamhsioncroinicithe, gan riamh blocshriantú sioncronach a dhéanamh) a láimhseáil — riachtanach chun feidhmchlár FastAPI sonraí-threoraithe a thógáil — mar gheall ar gur tugann FastAPI duit an saoirse a roghnú, is fiúntach a bheith ar an bhealach gnáthartha, fóill-bheathanaithe a bheith ar eolas chun feidhmchláir dhíoghalta a thógáil i gceart.