Python SQLAlchemy sessioonihaldus: tehingute käsitlemise meisterlikkus andmete terviklikkuse tagamiseks

SQLAlchemy on võimas ja paindlik Pythoni teek, mis pakub laiaulatuslikku tööriistakomplekti andmebaasidega suhtlemiseks. SQLAlchemy südames on sessiooni kontseptsioon, mis toimib vahepeatusena kõikidele andmebaasis tehtavatele operatsioonidele. Korralik sessiooni- ja tehinguhaldus on andmete terviklikkuse säilitamiseks ja andmebaasi järjepideva käitumise tagamiseks ülioluline, eriti keerukates rakendustes, mis tegelevad samaaegsete päringutega.

SQLAlchemy sessioonide mõistmine

SQLAlchemy sessioon esindab tööühikut, vestlust andmebaasiga. See jälgib objektidele tehtud muudatusi, võimaldades teil neid andmebaasi salvestada ühe aatomilise operatsioonina. Mõelge sellest kui tööruumist, kus teete andmetes muudatusi enne nende ametlikku salvestamist. Ilma hästi hallatud sessioonita riskite andmete ebajärjepidevuse ja võimaliku rikkumisega.

Sessiooni loomine

Enne kui saate oma andmebaasiga suhtlema hakata, peate looma sessiooni. See hõlmab esmalt ühenduse loomist andmebaasiga SQLAlchemy mootori abil.

            from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# Andmebaasi ühenduse string
db_url = 'sqlite:///:memory:'  # Asendage oma andmebaasi URL-iga (nt PostgreSQL, MySQL)

# Looge mootor
engine = create_engine(db_url, echo=False) # echo=True genereeritud SQL-i nägemiseks

# Määratlege deklaratiivsete mudelite baas
Base = declarative_base()

# Määratlege lihtne mudel
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f""

# Looge tabel andmebaasis
Base.metadata.create_all(engine)

# Looge sessiooniklass
Session = sessionmaker(bind=engine)

# Looge sessiooni eksemplar
session = Session()

            

              
                Copy
              
            
          

Selles näites:

• Impordime vajalikud SQLAlchemy moodulid.
• Määratleme andmebaasi ühenduse stringi (`db_url`). See näide kasutab lihtsuse huvides mälusisest SQLite andmebaasi, kuid te asendaksite selle oma andmebaasisüsteemile sobiva ühenduse stringiga (nt PostgreSQL, MySQL). Spetsiifiline vorming varieerub sõltuvalt kasutatavast andmebaasi mootorist ja draiverist. Õige ühenduse stringi vormingu leidmiseks tutvuge SQLAlchemy dokumentatsiooni ja oma andmebaasi pakkuja dokumentatsiooniga.
• Loome `engine`-i kasutades `create_engine()`. Mootor vastutab ühenduste kogumi haldamise ja andmebaasiga suhtlemise eest. Parameeter `echo=True` võib olla abiks silumisel, kuna see prindib genereeritud SQL-laused konsooli.
• Määratleme baasklassi (`Base`) kasutades `declarative_base()`. Seda kasutatakse kõigi meie SQLAlchemy mudelite baasklassina.
• Määratleme `User` mudeli, kaardistades selle andmebaasi tabeliga nimega `users`.
• Loome tabeli andmebaasis kasutades `Base.metadata.create_all(engine)`.
• Loome sessiooniklassi kasutades `sessionmaker(bind=engine)`. See konfigureerib sessiooniklassi kasutama määratud mootorit.
• Lõpuks loome sessiooni eksemplari kasutades `Session()`.

Tehingute mõistmine

Tehing on andmebaasioperatsioonide jada, mida käsitletakse ühe loogilise tööühikuna. Tehingud järgivad ACID omadusi:

• Aatomilisus: Kõik tehingu operatsioonid kas õnnestuvad täielikult või ebaõnnestuvad täielikult. Kui mõni tehingu osa ebaõnnestub, võetakse kogu tehing tagasi.
• Järjepidevus: Tehing peab hoidma andmebaasi kehtivas olekus. See ei tohi rikkuda ühtegi andmebaasi piirangut ega reeglit.
• Isolatsioon: Samaaegsed tehingud on üksteisest isoleeritud. Ühe tehinguga tehtud muudatused ei ole teistele tehingutele nähtavad enne, kui esimene tehing on kinnitatud.
• Püsivus: Kui tehing on kinnitatud, on selle muudatused püsivad ja säilivad isegi süsteemi rikete korral.

SQLAlchemy pakub mehhanisme tehingute haldamiseks, tagades nende ACID omaduste säilimise.

Põhiline tehingute käsitlemine

Kõige levinumad tehinguoperatsioonid on kinnitamine (commit) ja tagasivõtmine (rollback).

Tehingute kinnitamine

Kui kõik tehingu operatsioonid on edukalt lõpule viidud, kinnitate tehingu. See salvestab muudatused andmebaasi.

            try:
    # Lisa uus kasutaja
    new_user = User(name='Alice Smith', email='alice.smith@example.com')
    session.add(new_user)

    # Kinnita tehing
    session.commit()
    print("Transaction committed successfully!")

except Exception as e:
    # Käsitle erindeid
    print(f"An error occurred: {e}")
    session.rollback()
    print("Transaction rolled back.")

finally:
    session.close()

            

              
                Copy
              
            
          

Selles näites:

• Lisame sessiooni uue `User` objekti.
• Kutsume välja `session.commit()`, et muudatused andmebaasi salvestada.
• Ümbritseme koodi `try...except...finally` plokiga, et käsitleda võimalikke erandeid.
• Kui tekib erand, kutsume välja `session.rollback()`, et tühistada kõik tehingu käigus tehtud muudatused.
• Kutsume alati `session.close()` välja `finally` plokis, et vabastada sessioon ja tagastada ühendus ühenduste kogumisse. See on ressursside lekke vältimiseks ülioluline. Sessioonide sulgemata jätmine võib põhjustada ühenduste ammendumist ja rakenduse ebastabiilsust.

Tehingute tagasivõtmine

Kui tehingu ajal tekib viga või kui otsustate, et muudatusi ei tohiks salvestada, võtate tehingu tagasi (rollback). See taastab andmebaasi oleku, mis oli enne tehingu algust.

            try:
    # Lisa kasutaja kehtetu e-posti aadressiga (näide tagasivõtmise sundimiseks)
    invalid_user = User(name='Bob Johnson', email='invalid-email')
    session.add(invalid_user)

    # Kinnitamine ebaõnnestub, kui e-posti aadressi ei valideerita andmebaasi tasemel
    session.commit()
    print("Transaction committed.")

except Exception as e:
    print(f"An error occurred: {e}")
    session.rollback()
    print("Transaction rolled back successfully.")

finally:
    session.close()

            

              
                Copy
              
            
          

Selles näites, kui `invalid_user` lisamine tekitab erandi (nt andmebaasi piirangu rikkumise tõttu), tühistab `session.rollback()` kutse katsetatud sisestuse, jättes andmebaasi muutmata.

Täiustatud tehinguhaldus

`with`-lause kasutamine tehingute ulatuse määramiseks

Pythonilikum ja robustsem viis tehingute haldamiseks on kasutada `with`-lauset. See tagab, et sessioon suletakse korrektselt, isegi kui tekivad erandid.

            from contextlib import contextmanager

@contextmanager
def session_scope():
    """Paku tehingulist ulatust operatsioonide seeria ümber."""
    session = Session()
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.close()

# Kasutamine:
with session_scope() as session:
    new_user = User(name='Charlie Brown', email='charlie.brown@example.com')
    session.add(new_user)
    # Operatsioonid 'with' ploki sees
    # Kui erandeid ei teki, kinnitatakse tehing automaatselt.
    # Kui tekib erand, võetakse tehing automaatselt tagasi.
    print("User added.")

print("Transaction completed (committed or rolled back).")

            

              
                Copy
              
            
          

Funktsioon `session_scope` on kontekstihaldur. Kui sisenete `with` plokki, luuakse uus sessioon. Kui väljute `with` plokist, sessioon kas kinnitatakse (kui erandeid ei esinenud) või võetakse tagasi (kui esines erand). Sessioon suletakse alati `finally` plokis.

Pesastatud tehingud (salvestuspunktid)

SQLAlchemy toetab pesastatud tehinguid, kasutades salvestuspunkte (savepoints). Salvestuspunkt võimaldab teil naasta suurema tehingu sees kindlasse punkti, mõjutamata kogu tehingut.

            try:
    with session_scope() as session:
        user1 = User(name='David Lee', email='david.lee@example.com')
        session.add(user1)
        session.flush()  # Saada muudatused andmebaasi, kuid ära veel kinnita

        # Loo salvestuspunkt
        savepoint = session.begin_nested()

        try:
            user2 = User(name='Eve Wilson', email='eve.wilson@example.com')
            session.add(user2)
            session.flush()

            # Simuleeri viga
            raise ValueError("Simulated error during nested transaction")

        except Exception as e:
            print(f"Nested transaction error: {e}")
            savepoint.rollback()
            print("Nested transaction rolled back to savepoint.")

        # Jätka välimise tehinguga, user1 lisatakse ikkagi
        user3 = User(name='Frank Miller', email='frank.miller@example.com')
        session.add(user3)

except Exception as e:
    print(f"Outer transaction error: {e}")


# Kinnitamine kinnitab user1 ja user3, kuid mitte user2 pesastatud tagasivõtmise tõttu

try:
    with session_scope() as session:
        # Kontrolli, et eksisteerivad ainult user1 ja user3
        users = session.query(User).all()
        for user in users:
            print(user)
except Exception as e:
    print(f"Unexpected Exception: {e}") # Ei tohiks juhtuda

            

              
                Copy
              
            
          

Selles näites:

• Alustame välimist tehingut kasutades `session_scope()`.
• Lisame `user1` sessiooni ja teeme muudatustele `flush`-i andmebaasi. `flush()` saadab muudatused andmebaasi serverisse, kuid *ei* kinnita neid. See võimaldab teil näha, kas muudatused on kehtivad (nt piirangute rikkumisi pole) enne kogu tehingu kinnitamist.
• Loome salvestuspunkti kasutades `session.begin_nested()`.
• Pesastatud tehingu sees lisame `user2` ja simuleerime viga.
• Võtame pesastatud tehingu tagasi salvestuspunkti kasutades `savepoint.rollback()`. See tühistab ainult pesastatud tehingu sees tehtud muudatused (st `user2` lisamise).
• Jätkame välimise tehinguga ja lisame `user3`.
• Välimine tehing kinnitatakse, salvestades `user1` ja `user3` andmebaasi, samas kui `user2` jäetakse salvestuspunkti tagasivõtmise tõttu kõrvale.

Isolatsioonitasemete kontrollimine

Isolatsioonitasemed määravad, mil määral on samaaegsed tehingud üksteisest isoleeritud. Kõrgemad isolatsioonitasemed pakuvad suuremat andmete järjepidevust, kuid võivad vähendada konkurentsi ja jõudlust. SQLAlchemy võimaldab teil kontrollida oma tehingute isolatsioonitaset.

Levinud isolatsioonitasemed on järgmised:

• Read Uncommitted (kinnitamata lugemine): Madalaim isolatsioonitase. Tehingud näevad teiste tehingute poolt tehtud kinnitamata muudatusi. See võib viia räpaste lugemisteni (dirty reads).
• Read Committed (kinnitatud lugemine): Tehingud näevad ainult teiste tehingute poolt tehtud kinnitatud muudatusi. See hoiab ära räpased lugemised, kuid võib viia mittekorduvate lugemisteni (non-repeatable reads) ja fantoomlugemisteni (phantom reads).
• Repeatable Read (korratav lugemine): Tehingud näevad kogu tehingu vältel samu andmeid, isegi kui teised tehingud neid muudavad. See hoiab ära räpased ja mittekorduvad lugemised, kuid võib viia fantoomlugemisteni.
• Serializable (serialiseeritav): Kõrgeim isolatsioonitase. Tehingud on üksteisest täielikult isoleeritud. See hoiab ära räpased, mittekorduvad ja fantoomlugemised, kuid võib oluliselt vähendada konkurentsi.

Vaikimisi isolatsioonitase sõltub andmebaasisüsteemist. Saate määrata isolatsioonitaseme mootori loomisel või tehingu alustamisel.

Näide (PostgreSQL):

            from sqlalchemy.dialects.postgresql import dialect

# Määra isolatsioonitase mootori loomisel
engine = create_engine('postgresql://user:password@host:port/database',
                       connect_args={'options': '-c statement_timeout=1000'} # Näide ajalõpust
                      )

# Määra isolatsioonitase tehingu alustamisel (andmebaasispetsiifiline)
# PostgreSQL-i puhul on soovitatav see määrata ühendusele, mitte mootorile.

from sqlalchemy import event
from sqlalchemy.pool import Pool

@event.listens_for(Pool, "connect")
def set_isolation_level(dbapi_connection, connection_record):
    existing_autocommit = dbapi_connection.autocommit
    dbapi_connection.autocommit = True
    cursor = dbapi_connection.cursor()
    cursor.execute("SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE")
    dbapi_connection.autocommit = existing_autocommit
    cursor.close()


# Seejärel kasutavad SQLAlchemy kaudu loodud tehingud konfigureeritud isolatsioonitaset.

            

              
                Copy
              
            
          

Tähtis: Isolatsioonitasemete määramise meetod on andmebaasispetsiifiline. Õige süntaksi leidmiseks vaadake oma andmebaasi dokumentatsiooni. Isolatsioonitasemete vale seadistamine võib põhjustada ootamatut käitumist või vigu.

Konkurentsi käsitlemine

Kui mitu kasutajat või protsessi pääsevad samadele andmetele samaaegselt juurde, on andmete rikkumise vältimiseks ja andmete järjepidevuse tagamiseks ülioluline konkurentsi õigesti käsitleda. SQLAlchemy pakub mitmeid mehhanisme konkurentsi käsitlemiseks, sealhulgas optimistlikku ja pessimistlikku lukustamist.

Optimistlik lukustamine

Optimistlik lukustamine eeldab, et konfliktid on haruldased. See kontrollib enne tehingu kinnitamist teiste tehingute poolt tehtud muudatusi. Kui tuvastatakse konflikt, võetakse tehing tagasi.

Optimistliku lukustamise rakendamiseks lisate tavaliselt oma tabelisse versiooniveeru. Seda veergu suurendatakse automaatselt iga kord, kui rida uuendatakse.

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

Base = declarative_base()

class Article(Base):
    __tablename__ = 'articles'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    content = Column(String)
    version = Column(Integer, nullable=False, default=1)

    def __repr__(self):
        return f""

# try-catch ploki sees

def update_article(session, article_id, new_content):
    article = session.query(Article).filter_by(id=article_id).first()

    if article is None:
        raise ValueError("Article not found")

    original_version = article.version

    # Uuenda sisu ja suurenda versiooni
    article.content = new_content
    article.version += 1

    # Proovi uuendada, kontrollides versiooniveergu WHERE klauslis
    rows_affected = session.query(Article).filter(
        Article.id == article_id,
        Article.version == original_version
    ).update({
        Article.content: new_content,
        Article.version: article.version
    }, synchronize_session=False)

    if rows_affected == 0:
        session.rollback()
        raise ValueError("Conflict: Article has been updated by another transaction.")
    
    session.commit()

            

              
                Copy
              
            
          

Selles näites:

• Lisame `Article` mudelile `version` veeru.
• Enne artikli uuendamist salvestame praeguse versiooninumbri.
• `UPDATE`-lauses lisame `WHERE`-klausli, mis kontrollib, kas versiooniveerg on endiselt võrdne salvestatud versiooninumbriga. `synchronize_session=False` takistab SQLAlchemy-l uuendatud objekti uuesti laadimast; me tegeleme versioonihaldusega ise.
• Kui versiooniveergu on muutnud teine tehing, ei mõjuta `UPDATE`-lause ühtegi rida (rows_affected on 0) ja me tekitame erandi.
• Võtame tehingu tagasi ja teavitame kasutajat konflikti tekkimisest.

Pessimistlik lukustamine

Pessimistlik lukustamine eeldab, et konfliktid on tõenäolised. See omandab enne rea või tabeli muutmist lukustuse. See takistab teistel tehingutel andmete muutmist, kuni lukustus vabastatakse.

SQLAlchemy pakub mitmeid funktsioone lukustuste omandamiseks, näiteks `with_for_update()`.

            # Näide PostgreSQL-i kasutamisega
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base

# Andmebaasi seadistus (asenda oma tegeliku andmebaasi URL-iga)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False) # Määra echo tõeseks, kui soovid näha genereeritud SQL-i
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    value = Column(Integer)

    def __repr__(self):
        return f""

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

# Funktsioon elemendi uuendamiseks (try/except sees)
def update_item_value(session, item_id, new_value):
    # Omanda elemendile pessimistlik lukustus
    item = session.query(Item).filter(Item.id == item_id).with_for_update().first()

    if item is None:
        raise ValueError("Item not found")

    # Uuenda elemendi väärtust
    item.value = new_value
    session.commit()
    return True

            

              
                Copy
              
            
          

Selles näites:

• Kasutame `with_for_update()`, et omandada `Item` reale lukustus enne selle uuendamist. See takistab teistel tehingutel rea muutmist, kuni praegune tehing on kinnitatud või tagasi võetud. Funktsioon `with_for_update()` on andmebaasispetsiifiline; üksikasjade saamiseks vaadake oma andmebaasi dokumentatsiooni. Mõnedel andmebaasidel võivad olla erinevad lukustusmehhanismid või süntaks.

Tähtis: Pessimistlik lukustamine võib vähendada konkurentsi ja jõudlust, seega kasutage seda ainult vajadusel.

Erinditöötluse parimad praktikad

Nõuetekohane erinditöötlus on andmete terviklikkuse tagamiseks ja rakenduste krahhide vältimiseks ülioluline. Ümbritsege oma andmebaasioperatsioonid alati `try...except` plokkidega ja käsitlege erandeid asjakohaselt.

Siin on mõned parimad praktikad erinditöötluseks:

• Püüdke spetsiifilisi erandeid: Vältige üldiste erandite, nagu `Exception`, püüdmist. Püüdke spetsiifilisi erandeid, nagu `sqlalchemy.exc.IntegrityError` või `sqlalchemy.exc.OperationalError`, et käsitleda erinevat tüüpi vigu erinevalt.
• Võtke tehingud tagasi: Võtke tehing alati tagasi, kui tekib erand.
• Logige erandid: Logige erandid, et aidata probleeme diagnoosida ja parandada. Lisage oma logidesse võimalikult palju konteksti (nt kasutaja ID, sisendandmed, ajatempel).
• Tõstke erandid uuesti sobival juhul: Kui te ei saa erandit käsitleda, tõstke see uuesti, et kõrgema taseme käsitleja saaks sellega tegeleda.
• Puhastage ressursid: Sulgege alati sessioon ja vabastage kõik muud ressursid `finally` plokis.

            import logging
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
from sqlalchemy.exc import IntegrityError, OperationalError

# Seadista logimine
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Andmebaasi seadistus (asenda oma tegeliku andmebaasi URL-iga)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False)
Base = declarative_base()

class Product(Base):
    __tablename__ = 'products'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    price = Column(Integer)

    def __repr__(self):
        return f""

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

# Funktsioon toote lisamiseks
def add_product(session, name, price):
    try:
        new_product = Product(name=name, price=price)
        session.add(new_product)
        session.commit()
        logging.info(f"Product '{name}' added successfully.")
        return True
    except IntegrityError as e:
        session.rollback()
        logging.error(f"IntegrityError: {e}")
        # Käsitle andmebaasi piirangute rikkumisi (nt topeltnimi)
        return False
    except OperationalError as e:
        session.rollback()
        logging.error(f"OperationalError: {e}")
        # Käsitle ühenduse vigu või muid operatiivseid probleeme
        return False
    except Exception as e:
        session.rollback()
        logging.exception(f"An unexpected error occurred: {e}")
        # Käsitle muid ootamatuid vigu
        return False
    finally:
        session.close()

            

              
                Copy
              
            
          

Selles näites:

• Seadistame logimise, et salvestada sündmusi protsessi käigus.
• Püüame spetsiifilisi erandeid nagu `IntegrityError` (piirangute rikkumiste jaoks) ja `OperationalError` (ühenduse vigade jaoks).
• Võtame tehingu tagasi `except` plokkides.
• Logime erandid kasutades `logging` moodulit. Meetod `logging.exception()` lisab automaatselt logisõnumile stack trace'i.
• Tõstame erandi uuesti, kui me ei saa seda käsitleda.
• Sulgeme sessiooni `finally` plokis.

Andmebaasiühenduste kogumine (Connection Pooling)

SQLAlchemy kasutab ühenduste kogumist (connection pooling), et andmebaasiühendusi tõhusalt hallata. Ühenduste kogum hoiab andmebaasiga avatud ühenduste komplekti, võimaldades rakendustel taaskasutada olemasolevaid ühendusi uute loomise asemel iga päringu jaoks. See võib oluliselt parandada jõudlust, eriti rakendustes, mis tegelevad suure hulga samaaegsete päringutega.

SQLAlchemy `create_engine()` funktsioon loob automaatselt ühenduste kogumi. Saate konfigureerida ühenduste kogumit, edastades argumente `create_engine()` funktsioonile.

Levinud ühenduste kogumi parameetrid on järgmised:

• pool_size: Maksimaalne ühenduste arv kogumis.
• max_overflow: Ühenduste arv, mida saab luua üle `pool_size` piiri.
• pool_recycle: Sekundite arv, mille järel ühendus taaskasutatakse.
• pool_timeout: Sekundite arv, mida oodatakse ühenduse vabanemist.

            engine = create_engine('postgresql://user:password@host:port/database',
                       pool_size=5, # Maksimaalne kogumi suurus
                       max_overflow=10, # Maksimaalne ületäitumine
                       pool_recycle=3600, # Taaskasuta ühendused 1 tunni pärast
                       pool_timeout=30
                      )

            

              
                Copy
              
            
          

Tähtis: Valige sobivad ühenduste kogumi seaded vastavalt oma rakenduse vajadustele ja andmebaasiserveri võimekusele. Halvasti konfigureeritud ühenduste kogum võib põhjustada jõudlusprobleeme või ühenduste ammendumist.

Asünkroonsed tehingud (Async SQLAlchemy)

Kaasaegsete rakenduste jaoks, mis nõuavad suurt konkurentsi, eriti need, mis on ehitatud asünkroonsete raamistikega nagu FastAPI või AsyncIO, pakub SQLAlchemy asünkroonset versiooni nimega Async SQLAlchemy.

Async SQLAlchemy pakub SQLAlchemy põhikomponentide asünkroonseid versioone, võimaldades teil teha andmebaasioperatsioone sündmuste ahelat blokeerimata. See võib oluliselt parandada teie rakenduste jõudlust ja skaleeritavust.

Siin on põhiline näide Async SQLAlchemy kasutamisest:

            from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, Integer, String
import asyncio

# Andmebaasi seadistus (asenda oma tegeliku andmebaasi URL-iga)
db_url = 'postgresql+asyncpg://user:password@host:port/database'
engine = create_async_engine(db_url, echo=False)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f""

async def create_db_and_tables():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)


async def add_user(name, email):
    async with AsyncSession(engine) as session:
        new_user = User(name=name, email=email)
        session.add(new_user)
        await session.commit()

async def main():
    await create_db_and_tables()
    await add_user("Async User", "async.user@example.com")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

Peamised erinevused sünkroonsest SQLAlchemy-st:

• Kasutatakse `create_async_engine` funktsiooni `create_engine` asemel.
• Kasutatakse `AsyncSession` klassi `Session` asemel.
• Kõik andmebaasioperatsioonid on asünkroonsed ja neid tuleb oodata kasutades `await`.
• Tuleb kasutada asünkroonseid andmebaasi draivereid (nt `asyncpg` PostgreSQL-i jaoks).

Tähtis: Async SQLAlchemy nõuab andmebaasi draiverit, mis toetab asünkroonseid operatsioone. Veenduge, et teil on õige draiver installitud ja konfigureeritud.

Kokkuvõte

SQLAlchemy sessiooni- ja tehinguhalduse meisterlikkus on oluline robustsete ja usaldusväärsete Pythoni rakenduste loomiseks, mis suhtlevad andmebaasidega. Mõistes sessioonide, tehingute, isolatsioonitasemete ja konkurentsi kontseptsioone ning järgides erinditöötluse ja ühenduste kogumise parimaid praktikaid, saate tagada andmete terviklikkuse ja optimeerida oma rakenduste jõudlust.

Olenemata sellest, kas ehitate väikest veebirakendust või suuremahulist ettevõtte süsteemi, pakub SQLAlchemy teile vajalikke tööriistu andmebaasi interaktsioonide tõhusaks haldamiseks. Pidage meeles, et alati tuleb eelistada andmete terviklikkust ja käsitleda võimalikke vigu sujuvalt, et tagada oma rakenduste usaldusväärsus.

Kaaluge edasijõudnute teemade uurimist, näiteks:

• Kahefaasiline kinnitamine (2PC): Mitut andmebaasi hõlmavate tehingute jaoks.
• Killustamine (Sharding): Andmete jaotamiseks mitme andmebaasiserveri vahel.
• Andmebaasi migratsioonid: Kasutades tööriistu nagu Alembic andmebaasi skeemimuudatuste haldamiseks.