FastAPI Ma'lumotlar Bazasi Integratsiyasi: Asinxron Baza Operatsiyalarini Chuqur O'rganish

Zamonaviy veb-dasturlash dunyosida unumdorlik shunchaki xususiyat emas, balki asosiy talabdir. Foydalanuvchilar tez va sezgir ilovalarni kutishadi, dasturchilar esa bu talablarni qondirish uchun doimiy ravishda vositalar va usullarni izlaydilar. FastAPI Python ekotizimida o'zining asinxron tabiati tufayli aql bovar qilmaydigan tezligi bilan mashhur bo'lib, kuchli vositaga aylandi. Biroq, tezkor freymvork tenglamaning faqat bir qismidir. Agar ilovangiz vaqtining ko'p qismini sekin ma'lumotlar bazasini kutishga sarflasa, siz tirbandlikda qolib ketgan yuqori unumli dvigatel yaratgan bo'lasiz.

Aynan shu yerda asinxron ma'lumotlar bazasi operatsiyalari hal qiluvchi ahamiyatga ega bo'ladi. FastAPI ilovangizga butun jarayonni bloklamasdan ma'lumotlar bazasi so'rovlarini bajarishga imkon berish orqali, siz haqiqiy parallellikni ochib, nafaqat tez, balki yuqori darajada kengaytiriladigan ilovalarni yaratishingiz mumkin. Ushbu keng qamrovli qo'llanma sizni FastAPI bilan asinxron ma'lumotlar bazalarini integratsiya qilishning nima uchun, nima va qandayligi bilan tanishtiradi va global auditoriya uchun haqiqatan ham yuqori unumli xizmatlarni yaratish imkonini beradi.

Asosiy Konseptsiya: Nima Uchun Asinxron I/O Muhim

Kodga sho'ng'ishdan oldin, asinxron operatsiyalar hal qiladigan asosiy muammoni tushunish juda muhim: I/O (kiritish/chiqarish) bilan bog'liq kutish.

Oshxonadagi yuqori malakali oshpazni tasavvur qiling. Sinxron (yoki bloklovchi) modelda bu oshpaz bir vaqtning o'zida bitta vazifani bajarardi. U bir qozon suvni qaynatish uchun olovga qo'yib, keyin u qaynashini kutib turardi. Faqat suv qaynagandan keyingina u sabzavotlarni to'g'rashga o'tardi. Bu juda samarasiz. Oshpazning vaqti (CPU) kutish davrida (I/O operatsiyasi) behuda sarflanadi.

Endi asinxron (bloklamaydigan) modelni ko'rib chiqaylik. Oshpaz suvni qaynatishga qo'yadi va kutish o'rniga darhol sabzavotlarni to'g'rashni boshlaydi. U pechga patnis ham qo'yishi mumkin. U sekinroq operatsiyalar (suvning qaynashi yoki pishirish kabi) tugashini kutayotganda bir nechta jabhalarda ish olib borib, vazifalar o'rtasida almashishi mumkin. Vazifa tugagach (suv qaynaydi), oshpazga xabar beriladi va u o'sha taom uchun keyingi qadamni davom ettirishi mumkin.

Veb-ilovada ma'lumotlar bazasi so'rovlari, API chaqiruvlari va fayllarni o'qish suvning qaynashini kutishga tengdir. An'anaviy sinxron ilova bitta so'rovni qabul qilib, ma'lumotlar bazasiga so'rov yuboradi va keyin ma'lumotlar bazasi javob berguncha boshqa kiruvchi so'rovlarni bloklab, bo'sh turadi. Python'ning `asyncio` va FastAPI kabi freymvorklar bilan ishlaydigan asinxron ilova, qachonki biri I/O kutayotgan bo'lsa, ular o'rtasida samarali almashinish orqali minglab bir vaqtda ulanishlarni boshqara oladi.

Asinxron Ma'lumotlar Bazasi Operatsiyalarining Asosiy Afzalliklari:

• Parallellikning Oshishi: Bir xil apparat resurslari bilan bir vaqtning o'zida ancha ko'p sonli foydalanuvchilarga xizmat ko'rsatish.
• O'tkazuvchanlikning Yaxshilanishi: Sekundiga ko'proq so'rovlarni qayta ishlash, chunki ilova ma'lumotlar bazasini kutib qolmaydi.
• Foydalanuvchi Tajribasining Yaxshilanishi: Tezroq javob vaqtlari oxirgi foydalanuvchi uchun yanada sezgir va qoniqarli tajribaga olib keladi.
• Resurs Samaradorligi: CPU va xotiradan yaxshiroq foydalanish, bu esa infratuzilma xarajatlarini kamaytirishga olib kelishi mumkin.

Asinxron Dasturlash Muhitingizni Sozlash

Boshlash uchun sizga bir nechta asosiy komponentlar kerak bo'ladi. Biz ushbu misollar uchun ma'lumotlar bazasi sifatida PostgreSQL'dan foydalanamiz, chunki u asinxron drayverlar uchun ajoyib qo'llab-quvvatlashga ega. Biroq, bu tamoyillar asinxron drayverlarga ega bo'lgan MySQL va SQLite kabi boshqa ma'lumotlar bazalariga ham tegishli.

1. Asosiy Freymvork va Server

Birinchi navbatda, FastAPI va Uvicorn kabi ASGI serverini o'rnating.

            pip install fastapi uvicorn[standard]
            

              
                Copy
              
            
          

2. Asinxron Ma'lumotlar Bazasi Vositalarini Tanlash

Ma'lumotlar bazangiz bilan asinxron ravishda muloqot qilish uchun sizga ikkita asosiy komponent kerak:

1. Asinxron Ma'lumotlar Bazasi Drayveri: Bu ma'lumotlar bazasi bilan tarmoq orqali asinxron protokoldan foydalanib muloqot qiladigan past darajali kutubxona. PostgreSQL uchun `asyncpg` de-fakto standart bo'lib, o'zining ajoyib unumdorligi bilan mashhur.
2. Asinxron So'rovlar Yaratuvchisi yoki ORM: Bu so'rovlaringizni yozishning yuqori darajali, ko'proq Python'ga xos usulini ta'minlaydi. Biz ikkita mashhur variantni ko'rib chiqamiz:
   • databases: Xom SQL'ni bajarish uchun toza API taqdim etadigan oddiy, yengil asinxron so'rovlar yaratuvchisi.
   • SQLAlchemy 2.0+: Kuchli va ko'p funksiyali SQLAlchemy ORM'ning so'nggi versiyalari `asyncio` uchun tabiiy, birinchi darajali qo'llab-quvvatlashni o'z ichiga oladi. Bu ko'pincha murakkab ilovalar uchun afzal ko'rilgan tanlovdir.

3. O'rnatish

Keling, kerakli kutubxonalarni o'rnatamiz. Siz vositalardan birini tanlashingiz yoki tajriba qilish uchun ikkalasini ham o'rnatishingiz mumkin.

PostgreSQL uchun SQLAlchemy va `databases` bilan:

            # PostgreSQL uchun drayver
pip install asyncpg

# SQLAlchemy 2.0+ yondashuvi uchun
pip install sqlalchemy

# 'databases' kutubxonasi yondashuvi uchun
pip install databases[postgresql]
            

              
                Copy
              
            
          

Muhitimiz tayyor bo'lgach, keling, bu vositalarni FastAPI ilovasiga qanday integratsiya qilishni ko'rib chiqamiz.

1-Strategiya: `databases` Kutubxonasi Bilan Oddiylik

`databases` kutubxonasi ajoyib boshlanish nuqtasidir. U oddiy bo'lishi uchun ishlab chiqilgan va asinxron drayverlar ustidan yupqa qobiqni ta'minlab, sizga to'liq ORM murakkabligisiz asinxron xom SQL kuchini beradi.

1-Qadam: Ma'lumotlar Bazasiga Ulanish va Hayot Siklini Boshqarish

Haqiqiy ilovada har bir so'rovda ma'lumotlar bazasiga ulanish va uzilishni xohlamaysiz. Bu samarasiz. Buning o'rniga, ilova ishga tushganda ulanishlar pulini (connection pool) yaratamiz va u yopilganda uni chiroyli tarzda yopamiz. FastAPI'ning hodisa ishlovchilari (`@app.on_event("startup")` va `@app.on_event("shutdown")`) bu uchun juda mos keladi.

Keling, main_databases.py nomli fayl yaratamiz:

            import databases
import sqlalchemy
from fastapi import FastAPI

# --- Ma'lumotlar Bazasi Konfiguratsiyasi ---
# Haqiqiy ma'lumotlar bazasi URL manzilingiz bilan almashtiring
# asyncpg formati: "postgresql+asyncpg://user:password@host/dbname"
DATABASE_URL = "postgresql+asyncpg://user:password@localhost/testdb"

database = databases.Database(DATABASE_URL)

# SQLAlchemy model metama'lumotlari (jadval yaratish uchun)
metadata = sqlalchemy.MetaData()

# Namuna jadvalni aniqlash
notes = sqlalchemy.Table(
    "notes",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("title", sqlalchemy.String(100)),
    sqlalchemy.Column("content", sqlalchemy.String(500)),
)

# Jadval yaratish uchun dvigatel yaratish (bu qism sinxron)
# 'databases' kutubxonasi sxema yaratishni bajarmaydi
engine = sqlalchemy.create_engine(DATABASE_URL.replace("+asyncpg", ""))
metadata.create_all(engine)

# --- FastAPI Ilovasi ---
app = FastAPI(title="FastAPI with Databases Library")

@app.on_event("startup")
async def startup():
    print("Connecting to database...")
    await database.connect()
    print("Database connection established.")

@app.on_event("shutdown")
async def shutdown():
    print("Disconnecting from database...")
    await database.disconnect()
    print("Database connection closed.")

# --- API Endpoints ---
@app.get("/")
def read_root():
    return {"message": "Welcome to the Async Database API!"}

            

              
                Copy
              
            
          

Asosiy Nuqtalar:

• Biz DATABASE_URL'ni postgresql+asyncpg sxemasidan foydalanib aniqlaymiz.
• Global database obyekti yaratiladi.
• startup hodisa ishlovchisi ulanishlar pulini (connection pool) ishga tushiradigan await database.connect()'ni chaqiradi.
• shutdown hodisa ishlovchisi barcha ulanishlarni toza yopish uchun await database.disconnect()'ni chaqiradi.

2-Qadam: Asinxron CRUD Endpoints'larini Amalga Oshirish

Endi, Create, Read, Update va Delete (CRUD) operatsiyalarini bajarish uchun endpoints qo'shamiz. Ma'lumotlarni tekshirish va seriyalash uchun Pydantic'dan ham foydalanamiz.

Quyidagilarni main_databases.py faylingizga qo'shing:

            from pydantic import BaseModel
from typing import List, Optional

# --- Ma'lumotlarni tekshirish uchun Pydantic Modellari ---
class NoteIn(BaseModel):
    title: str
    content: str

class Note(BaseModel):
    id: int
    title: str
    content: str

# --- CRUD Endpoints ---

@app.post("/notes/", response_model=Note)
async def create_note(note: NoteIn):
    """Ma'lumotlar bazasida yangi qayd yaratish."""
    query = notes.insert().values(title=note.title, content=note.content)
    last_record_id = await database.execute(query)
    return {**note.dict(), "id": last_record_id}

@app.get("/notes/", response_model=List[Note])
async def read_all_notes():
    """Ma'lumotlar bazasidan barcha qaydlarni olish."""
    query = notes.select()
    return await database.fetch_all(query)

@app.get("/notes/{note_id}", response_model=Note)
async def read_note(note_id: int):
    """ID bo'yicha bitta qaydni olish."""
    query = notes.select().where(notes.c.id == note_id)
    result = await database.fetch_one(query)
    if result is None:
        raise HTTPException(status_code=404, detail="Qayd topilmadi")
    return result

@app.put("/notes/{note_id}", response_model=Note)
async def update_note(note_id: int, note: NoteIn):
    """Mavjud qaydni yangilash."""
    query = (
        notes.update()
        .where(notes.c.id == note_id)
        .values(title=note.title, content=note.content)
    )
    result = await database.execute(query)
    if result == 0:
        raise HTTPException(status_code=404, detail="Qayd topilmadi")
    return {**note.dict(), "id": note_id}

@app.delete("/notes/{note_id}")
async def delete_note(note_id: int):
    """ID bo'yicha qaydni o'chirish."""
    query = notes.delete().where(notes.c.id == note_id)
    result = await database.execute(query)
    if result == 0:
        raise HTTPException(status_code=404, detail="Qayd topilmadi")
    return {"message": "Qayd muvaffaqiyatli o'chirildi"}


            

              
                Copy
              
            
          

Asinxron Chaqiruvlar Tahlili:

• await database.execute(query): INSERT, UPDATE va DELETE kabi qatorlarni qaytarmaydigan operatsiyalar uchun ishlatiladi. U ta'sir etilgan qatorlar sonini yoki yangi yozuvning birlamchi kalitini qaytaradi.
• await database.fetch_all(query): Bir nechta qator kutiladigan SELECT so'rovlari uchun ishlatiladi. U yozuvlar ro'yxatini qaytaradi.
• await database.fetch_one(query): Ko'pi bilan bitta qator kutiladigan SELECT so'rovlari uchun ishlatiladi. U bitta yozuvni yoki None'ni qaytaradi.

E'tibor bering, har bir ma'lumotlar bazasi bilan o'zaro ta'sir await bilan boshlanadi. Aynan shu sehr hodisalar tsikliga ma'lumotlar bazasi javobini kutayotganda boshqa vazifalarga o'tishga imkon beradi va yuqori parallellikni ta'minlaydi.

2-Strategiya: Zamonaviy Gigant - SQLAlchemy 2.0+ Asinxron ORM

`databases` kutubxonasi oddiyligi uchun ajoyib bo'lsa-da, ko'plab yirik miqyosdagi ilovalar to'liq funksiyali Obyekt-Relatsion Xaritalash (ORM) dan foyda ko'radi. ORM sizga ma'lumotlar bazasi yozuvlari bilan Python obyektlari sifatida ishlash imkonini beradi, bu esa dasturchi unumdorligini va kodning saqlanuvchanligini sezilarli darajada yaxshilashi mumkin. SQLAlchemy Python dunyosidagi eng kuchli ORM bo'lib, uning 2.0+ versiyalari zamonaviy tabiiy asinxron interfeysni taqdim etadi.

1-Qadam: Asinxron Dvigatel (Engine) va Sessiyani Sozlash

SQLAlchemy'ning asinxron funksionalligining yadrosi `AsyncEngine` va `AsyncSession`da yotadi. Sozlash sinxron versiyadan biroz farq qiladi.

Yaxshiroq tuzilma uchun kodimizni bir nechta fayllarga ajratamiz: `database.py`, `models.py`, `schemas.py` va `main_sqlalchemy.py`.

database.py:

            from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql+asyncpg://user:password@localhost/testdb"

# Asinxron dvigatel yaratish
engine = create_async_engine(DATABASE_URL, echo=True)

# Sessiya fabrikasini yaratish
# expire_on_commit=False commit'dan keyin atributlarning eskirishini oldini oladi
AsyncSessionLocal = sessionmaker(
    bind=engine, class_=AsyncSession, expire_on_commit=False
)

            

              
                Copy
              
            
          

models.py:

            from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class Note(Base):
    __tablename__ = "notes"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(100), index=True)
    content = Column(String(500))

            

              
                Copy
              
            
          

schemas.py (Pydantic modellari):

            from pydantic import BaseModel

class NoteBase(BaseModel):
    title: str
    content: str

class NoteCreate(NoteBase):
    pass

class Note(NoteBase):
    id: int

    class Config:
        orm_mode = True

            

              
                Copy
              
            
          

Pydantic modelining konfiguratsiya sinfidagi `orm_mode = True` asosiy sehrli qismdir. Bu Pydantic'ga ma'lumotlarni nafaqat lug'atlardan, balki ORM model atributlaridan ham o'qishni buyuradi.

2-Qadam: Sessiyalarni Bog'liqlik Inyeksiyasi (Dependency Injection) Bilan Boshqarish

FastAPI'da ma'lumotlar bazasi sessiyalarini boshqarishning tavsiya etilgan usuli bu Bog'liqlik Inyeksiyasidir. Biz bitta so'rov uchun ma'lumotlar bazasi sessiyasini ta'minlaydigan va xato yuz berganda ham uning yopilishini kafolatlaydigan bog'liqlik yaratamiz.

Buni main_sqlalchemy.py faylingizga qo'shing:

            from fastapi import Depends, FastAPI, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select

from . import models, schemas
from .database import engine, AsyncSessionLocal

app = FastAPI()

# --- DB sessiyasini olish uchun bog'liqlik ---
async def get_db() -> AsyncSession:
    async with AsyncSessionLocal() as session:
        try:
            yield session
        finally:
            await session.close()

# --- Ma'lumotlar Bazasini Ishga Tushirish (jadvallarni yaratish uchun) ---
@app.on_event("startup")
async def startup_event():
    print("Initializing database schema...")
    async with engine.begin() as conn:
        # await conn.run_sync(models.Base.metadata.drop_all)
        await conn.run_sync(models.Base.metadata.create_all)
    print("Database schema initialized.")

            

              
                Copy
              
            
          

`get_db` bog'liqligi ushbu naqshning tamal toshidir. Uni ishlatadigan endpoint'ga har bir so'rov uchun u quyidagilarni bajaradi:

1. Yangi `AsyncSession` yaratadi.
2. Sessiyani endpoint funksiyasiga `yield` qiladi.
3. `finally` bloki ichidagi kod so'rov muvaffaqiyatli bo'lganmi yoki yo'qmi, qat'i nazar, sessiyaning yopilishini va ulanishning pulga qaytarilishini ta'minlaydi.

3-Qadam: SQLAlchemy ORM Bilan Asinxron CRUD'ni Amalga Oshirish

Endi biz o'z endpoints'larimizni yoza olamiz. Ular xom SQL yondashuviga qaraganda ancha toza va obyektga yo'naltirilgan ko'rinishga ega bo'ladi.

Ushbu endpoints'larni main_sqlalchemy.py ga qo'shing:

            
@app.post("/notes/", response_model=schemas.Note)
async def create_note(
    note: schemas.NoteCreate, db: AsyncSession = Depends(get_db)
):
    db_note = models.Note(title=note.title, content=note.content)
    db.add(db_note)
    await db.commit()
    await db.refresh(db_note)
    return db_note

@app.get("/notes/", response_model=list[schemas.Note])
async def read_all_notes(skip: int = 0, limit: int = 100, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).offset(skip).limit(limit))
    notes = result.scalars().all()
    return notes

@app.get("/notes/{note_id}", response_model=schemas.Note)
async def read_note(note_id: int, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Qayd topilmadi")
    return db_note

@app.put("/notes/{note_id}", response_model=schemas.Note)
async def update_note(
    note_id: int, note: schemas.NoteCreate, db: AsyncSession = Depends(get_db)
):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Qayd topilmadi")
    
    db_note.title = note.title
    db_note.content = note.content
    await db.commit()
    await db.refresh(db_note)
    return db_note

@app.delete("/notes/{note_id}")
async def delete_note(note_id: int, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Qayd topilmadi")
    
    await db.delete(db_note)
    await db.commit()
    return {"message": "Qayd muvaffaqiyatli o'chirildi"}

            

              
                Copy
              
            
          

SQLAlchemy Asinxron Naqshining Tahlili:

• db: AsyncSession = Depends(get_db): Bu bizning ma'lumotlar bazasi sessiyamizni endpoint'ga inyeksiya qiladi.
• await db.execute(...): Bu so'rovlarni bajarish uchun asosiy usuldir.
• result.scalars().all() / result.scalar_one_or_none(): Bu usullar so'rov natijasidan haqiqiy ORM obyektlarini ajratib olish uchun ishlatiladi.
• db.add(obj): Obyektni qo'shish uchun tayyorlaydi.
• await db.commit(): Tranzaksiyani ma'lumotlar bazasiga asinxron ravishda commit qiladi. Bu muhim `await` nuqtasidir.
• await db.refresh(obj): Commit'dan so'ng Python obyektini ma'lumotlar bazasidan olingan har qanday yangi ma'lumotlar bilan (masalan, avtomatik yaratilgan ID) yangilaydi.

Unumdorlik Masalalari va Eng Yaxshi Amaliyotlar

Shunchaki `async` va `await` dan foydalanish ajoyib boshlanishdir, lekin haqiqatan ham mustahkam va yuqori unumli ilovalarni yaratish uchun ushbu eng yaxshi amaliyotlarni hisobga oling.

1. Ulanishlar Pulini (Connection Pooling) Tushunish

`databases` ham, SQLAlchemy'ning `AsyncEngine`'i ham parda ortida ulanishlar pulini (connection pool) boshqaradi. Bu pul turli so'rovlar tomonidan qayta ishlatilishi mumkin bo'lgan ochiq ma'lumotlar bazasi ulanishlari to'plamini saqlaydi. Bu har bir so'rov uchun yangi TCP ulanishini o'rnatish va ma'lumotlar bazasi bilan autentifikatsiya qilish kabi qimmat operatsiyalardan qochishga yordam beradi. Siz o'zingizning aniq ish yukingiz uchun dvigatel konfiguratsiyasida pul hajmini (masalan, `pool_size`, `max_overflow`) sozlashingiz mumkin.

2. Hech Qachon Sinxron va Asinxron Ma'lumotlar Bazasi Chaqiruvlarini Aralashtirmang

Eng muhim yagona qoida - hech qachon `async def` funksiyasi ichida sinxron, bloklovchi I/O funksiyasini chaqirmaslik. Oddiy, sinxron ma'lumotlar bazasi chaqiruvi (masalan, `psycopg2`'ni to'g'ridan-to'g'ri ishlatish) butun hodisalar tsiklini bloklaydi, ilovangizni muzlatib qo'yadi va asinxronlikning maqsadini yo'qqa chiqaradi.

Agar siz mutlaqo sinxron kod qismini ishga tushirishingiz kerak bo'lsa (ehtimol, CPU bilan bog'liq kutubxona), hodisalar tsiklini bloklamaslik uchun FastAPI'ning `run_in_threadpool`'idan foydalaning:

            from fastapi.concurrency import run_in_threadpool

@app.get("/run-sync-task/")
async def run_sync_task():
    # 'some_blocking_io_function' - oddiy sinxron funksiya
    result = await run_in_threadpool(some_blocking_io_function, arg1, arg2)
    return {"result": result}

            

              
                Copy
              
            
          

3. Asinxron Tranzaksiyalardan Foydalaning

Operatsiya birgalikda muvaffaqiyatli yoki muvaffaqiyatsiz bo'lishi kerak bo'lgan (atomar operatsiya) bir nechta ma'lumotlar bazasi o'zgarishlarini o'z ichiga olganda, siz tranzaksiyadan foydalanishingiz kerak. Ikkala kutubxona ham buni asinxron kontekst menejeri orqali qo'llab-quvvatlaydi.

`databases` bilan:

            async def transfer_funds():
    async with database.transaction():
        await database.execute(query_for_debit)
        await database.execute(query_for_credit)

            

              
                Copy
              
            
          

SQLAlchemy bilan:

            async def transfer_funds(db: AsyncSession = Depends(get_db)):
    async with db.begin(): # Bu tranzaksiyani boshlaydi
        # Hisoblarni topish
        account_from = ...
        account_to = ...
        # Balanslarni yangilash
        account_from.balance -= 100
        account_to.balance += 100
    # Tranzaksiya blokdan chiqishda avtomatik ravishda commit qilinadi
    # yoki istisno yuz berganda orqaga qaytariladi.

            

              
                Copy
              
            
          

4. Faqat Kerakli Narsani Tanlang

Faqat bir nechta ustun kerak bo'lganda `SELECT *` dan saqlaning. Tarmoq orqali kamroq ma'lumot uzatish I/O kutish vaqtini qisqartiradi. SQLAlchemy bilan siz `options(load_only(model.col1, model.col2))` yordamida qaysi ustunlarni olishni belgilashingiz mumkin.

Xulosa: Asinxron Kelajakni Qabul Qiling

Asinxron ma'lumotlar bazasi operatsiyalarini FastAPI ilovangizga integratsiya qilish uning to'liq unumdorlik salohiyatini ochishning kalitidir. Ilovangiz ma'lumotlar bazasini kutayotganda bloklanmasligini ta'minlash orqali siz qiyinchiliksiz global foydalanuvchilar bazasiga xizmat ko'rsatishga qodir bo'lgan aql bovar qilmaydigan darajada tez, kengaytiriladigan va samarali xizmatlarni yaratishingiz mumkin.

Biz ikkita kuchli strategiyani ko'rib chiqdik:

• `databases` kutubxonasi SQL yozishni afzal ko'radigan va oddiy, tez asinxron interfeysga muhtoj bo'lgan dasturchilar uchun sodda, yengil yondashuvni taklif etadi.
• SQLAlchemy 2.0+ dasturchi unumdorligi va saqlanuvchanlik birinchi o'rinda turadigan murakkab ilovalar uchun ideal tanlov bo'lgan tabiiy asinxron API'ga ega to'liq funksiyali, mustahkam ORM'ni taqdim etadi.

Ular orasidagi tanlov loyihangiz ehtiyojlariga bog'liq, ammo asosiy tamoyil bir xil bo'lib qoladi: bloklamaydigan tarzda fikrlang. Ushbu naqshlar va eng yaxshi amaliyotlarni qabul qilish orqali siz shunchaki kod yozmayapsiz; siz zamonaviy vebning yuqori parallellik talablari uchun tizimlarni loyihalashtiryapsiz. Bugunoq o'zingizning navbatdagi yuqori unumli FastAPI ilovangizni yaratishni boshlang va asinxron Python kuchini o'z tajribangizda his eting.