Python SQLAlchemy Sessiebeheer: Transactieafhandeling Beheersen voor Data Integriteit

SQLAlchemy is een krachtige en flexibele Python-bibliotheek die een uitgebreide toolkit biedt voor interactie met databases. De kern van SQLAlchemy wordt gevormd door het concept van de sessie, die fungeert als een staging zone voor alle bewerkingen die u op uw database uitvoert. Correct sessie- en transactiebeheer is cruciaal voor het handhaven van de data-integriteit en het waarborgen van consistent databasegedrag, vooral in complexe applicaties die gelijktijdige verzoeken verwerken.

SQLAlchemy Sessies Begrijpen

Een SQLAlchemy Sessie vertegenwoordigt een werkeenheid, een gesprek met de database. Het houdt wijzigingen bij die zijn aangebracht aan objecten, waardoor u ze als een enkele atomaire bewerking naar de database kunt pushen. Beschouw het als een werkruimte waar u wijzigingen aanbrengt in gegevens voordat u ze officieel opslaat. Zonder een goed beheerde sessie riskeert u dataconsistenties en potentiële corruptie.

Een Sessie Creëren

Voordat u met uw database kunt communiceren, moet u een sessie aanmaken. Dit omvat eerst het tot stand brengen van een verbinding met de database met behulp van de engine van SQLAlchemy.

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

# Database verbindingsstring
db_url = 'sqlite:///:memory:'  # Vervang door uw database URL (bijv. PostgreSQL, MySQL)

# Maak een engine
engine = create_engine(db_url, echo=False) # echo=True om de gegenereerde SQL te zien

# Definieer een basis voor declaratieve modellen
Base = declarative_base()

# Definieer een eenvoudig model
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f""

# Maak de tabel in de database
Base.metadata.create_all(engine)

# Maak een sessie klasse
Session = sessionmaker(bind=engine)

# Instantieer een sessie
session = Session()

            

              
                Copy
              
            
          

In dit voorbeeld:

• Importeren we de benodigde SQLAlchemy modules.
• Definiëren we een database verbindingsstring (`db_url`). Dit voorbeeld gebruikt een in-memory SQLite database voor de eenvoud, maar u zou deze vervangen door een verbindingsstring die geschikt is voor uw databasesysteem (bijv. PostgreSQL, MySQL). Het specifieke formaat varieert afhankelijk van de database engine en driver die u gebruikt. Raadpleeg de SQLAlchemy documentatie en de documentatie van uw databaseprovider voor het juiste verbindingsstringformaat.
• Creëren we een `engine` met behulp van `create_engine()`. De engine is verantwoordelijk voor het beheren van de connection pool en de communicatie met de database. De parameter `echo=True` kan handig zijn voor het debuggen, omdat deze de gegenereerde SQL-statements naar de console afdrukt.
• Definiëren we een basisklasse (`Base`) met behulp van `declarative_base()`. Dit wordt gebruikt als de basisklasse voor al onze SQLAlchemy modellen.
• Definiëren we een `User` model, dat het koppelt aan een databasetabel met de naam `users`.
• Creëren we de tabel in de database met behulp van `Base.metadata.create_all(engine)`.
• Creëren we een sessieklasse met behulp van `sessionmaker(bind=engine)`. Dit configureert de sessieklasse om de opgegeven engine te gebruiken.
• Ten slotte instantieren we een sessie met behulp van `Session()`.

Transacties Begrijpen

Een transactie is een reeks databasebewerkingen die worden behandeld als een enkele logische werkeenheid. Transacties houden zich aan de ACID-eigenschappen:

• Atomiciteit: Alle bewerkingen in de transactie slagen volledig of mislukken volledig. Als een deel van de transactie mislukt, wordt de hele transactie teruggedraaid.
• Consistentie: De transactie moet de database in een geldige toestand houden. Het mag geen databasebeperkingen of regels schenden.
• Isolatie: Gelijktijdige transacties zijn van elkaar geïsoleerd. Wijzigingen die door de ene transactie zijn aangebracht, zijn niet zichtbaar voor andere transacties totdat de eerste transactie is vastgelegd.
• Duurzaamheid: Zodra een transactie is vastgelegd, zijn de wijzigingen permanent en overleven ze zelfs systeemfouten.

SQLAlchemy biedt mechanismen om transacties te beheren, zodat deze ACID-eigenschappen worden gehandhaafd.

Basis Transactieafhandeling

De meest voorkomende transactiebewerkingen zijn commit en rollback.

Transacties Vastleggen

Wanneer alle bewerkingen binnen een transactie succesvol zijn voltooid, commit u de transactie. Dit zet de wijzigingen door naar de database.

            try:
    # Voeg een nieuwe gebruiker toe
    new_user = User(name='Alice Smith', email='alice.smith@example.com')
    session.add(new_user)

    # Commit de transactie
    session.commit()
    print("Transactie succesvol vastgelegd!")

except Exception as e:
    # Behandel uitzonderingen
    print(f"Er is een fout opgetreden: {e}")
    session.rollback()
    print("Transactie teruggedraaid.")

finally:
    session.close()

            

              
                Copy
              
            
          

In dit voorbeeld:

• Voegen we een nieuw `User` object toe aan de sessie.
• Roepen we `session.commit()` aan om de wijzigingen naar de database te pushen.
• Omwikkelen we de code in een `try...except...finally` blok om mogelijke uitzonderingen af te handelen.
• Als er een uitzondering optreedt, roepen we `session.rollback()` aan om alle wijzigingen ongedaan te maken die tijdens de transactie zijn aangebracht.
• We roepen altijd `session.close()` aan in het `finally` blok om de sessie vrij te geven en de verbinding terug te sturen naar de connection pool. Dit is cruciaal om resource lekken te voorkomen. Het niet sluiten van sessies kan leiden tot connection exhaustion en applicatie instabiliteit.

Transacties Terugdraaien

Als er een fout optreedt tijdens een transactie, of als u besluit dat de wijzigingen niet moeten worden doorgevoerd, rollback u de transactie. Dit zet de database terug naar de staat van voor het begin van de transactie.

            try:
    # Voeg een gebruiker toe met een ongeldig e-mailadres (voorbeeld om een rollback te forceren)
    invalid_user = User(name='Bob Johnson', email='invalid-email')
    session.add(invalid_user)

    # De commit mislukt als de e-mail niet op databaseniveau wordt gevalideerd
    session.commit()
    print("Transactie vastgelegd.")

except Exception as e:
    print(f"Er is een fout opgetreden: {e}")
    session.rollback()
    print("Transactie succesvol teruggedraaid.")

finally:
    session.close()

            

              
                Copy
              
            
          

In dit voorbeeld, als het toevoegen van de `invalid_user` een uitzondering oplevert (bijv. vanwege een database constraint violation), zal de `session.rollback()` aanroep de poging tot invoeging ongedaan maken, waardoor de database ongewijzigd blijft.

Geavanceerd Transactiebeheer

De `with` Statement Gebruiken voor Transactie Scope

Een meer Pythonic en robuuste manier om transacties te beheren is het gebruik van de `with` statement. Dit zorgt ervoor dat de sessie correct wordt gesloten, zelfs als er uitzonderingen optreden.

            from contextlib import contextmanager

@contextmanager
def session_scope():
    """Biedt een transactionele scope rond een reeks bewerkingen."""
    session = Session()
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.close()

# Gebruik:
with session_scope() as session:
    new_user = User(name='Charlie Brown', email='charlie.brown@example.com')
    session.add(new_user)
    # Bewerkingen binnen het 'with' blok
    # Als er geen uitzonderingen optreden, wordt de transactie automatisch vastgelegd.
    # Als er een uitzondering optreedt, wordt de transactie automatisch teruggedraaid.
    print("Gebruiker toegevoegd.")

print("Transactie voltooid (vastgelegd of teruggedraaid).")

            

              
                Copy
              
            
          

De `session_scope` functie is een context manager. Wanneer u het `with` blok betreedt, wordt er een nieuwe sessie aangemaakt. Wanneer u het `with` blok verlaat, wordt de sessie ofwel vastgelegd (als er geen uitzonderingen zijn opgetreden) of teruggedraaid (als er wel een uitzondering is opgetreden). De sessie wordt altijd gesloten in het `finally` blok.

Geneste Transacties (Savepoints)

SQLAlchemy ondersteunt geneste transacties met behulp van savepoints. Met een savepoint kunt u terugkeren naar een specifiek punt binnen een grotere transactie, zonder dat dit de hele transactie beïnvloedt.

            try:
    with session_scope() as session:
        user1 = User(name='David Lee', email='david.lee@example.com')
        session.add(user1)
        session.flush()  # Stuur wijzigingen naar de database, maar commit nog niet

        # Maak een savepoint
        savepoint = session.begin_nested()

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

            # Simuleer een fout
            raise ValueError("Gesimuleerde fout tijdens geneste transactie")

        except Exception as e:
            print(f"Geneste transactiefout: {e}")
            savepoint.rollback()
            print("Geneste transactie teruggedraaid naar savepoint.")

        # Ga verder met de buitenste transactie, user1 wordt nog steeds toegevoegd
        user3 = User(name='Frank Miller', email='frank.miller@example.com')
        session.add(user3)

except Exception as e:
    print(f"Buitenste transactiefout: {e}")


#Commit zal user1 en user3 committen, maar niet user2 vanwege de geneste rollback

try:
    with session_scope() as session:
        #Verifieer dat alleen user1 en user3 bestaan
        users = session.query(User).all()
        for user in users:
            print(user)
except Exception as e:
    print(f"Onverwachte Uitzondering: {e}") #Zou niet mogen gebeuren

            

              
                Copy
              
            
          

In dit voorbeeld:

• We starten een buitenste transactie met behulp van `session_scope()`.
• We voegen `user1` toe aan de sessie en flushen de wijzigingen naar de database. `flush()` stuurt de wijzigingen naar de databaseserver, maar commit ze *niet*. Het stelt u in staat om te zien of de wijzigingen geldig zijn (bijv. geen constraint violations) voordat u de hele transactie commit.
• We maken een savepoint met behulp van `session.begin_nested()`.
• Binnen de geneste transactie voegen we `user2` toe en simuleren we een fout.
• We rollen de geneste transactie terug naar het savepoint met behulp van `savepoint.rollback()`. Dit maakt alleen de wijzigingen ongedaan die zijn aangebracht binnen de geneste transactie (d.w.z. de toevoeging van `user2`).
• We gaan verder met de buitenste transactie en voegen `user3` toe.
• De buitenste transactie wordt vastgelegd, waardoor `user1` en `user3` naar de database worden gepusht, terwijl `user2` wordt weggegooid vanwege de savepoint rollback.

Isolatieniveaus Beheren

Isolatieniveaus bepalen de mate waarin gelijktijdige transacties van elkaar zijn geïsoleerd. Hogere isolatieniveaus bieden een grotere dataconsistentie, maar kunnen de concurrency en prestaties verminderen. Met SQLAlchemy kunt u het isolatieniveau van uw transacties beheren.

Algemene isolatieniveaus zijn:

• Read Uncommitted: Het laagste isolatieniveau. Transacties kunnen niet-vastgelegde wijzigingen zien die door andere transacties zijn aangebracht. Dit kan leiden tot dirty reads.
• Read Committed: Transacties kunnen alleen vastgelegde wijzigingen zien die door andere transacties zijn aangebracht. Dit voorkomt dirty reads, maar kan leiden tot non-repeatable reads en phantom reads.
• Repeatable Read: Transacties kunnen dezelfde gegevens gedurende de hele transactie zien, zelfs als andere transacties deze wijzigen. Dit voorkomt dirty reads en non-repeatable reads, maar kan leiden tot phantom reads.
• Serializable: Het hoogste isolatieniveau. Transacties zijn volledig van elkaar geïsoleerd. Dit voorkomt dirty reads, non-repeatable reads en phantom reads, maar kan de concurrency aanzienlijk verminderen.

Het standaard isolatieniveau is afhankelijk van het databasesysteem. U kunt het isolatieniveau instellen bij het aanmaken van de engine of bij het starten van een transactie.

Voorbeeld (PostgreSQL):

            from sqlalchemy.dialects.postgresql import dialect

# Stel het isolatieniveau in bij het aanmaken van de engine
engine = create_engine('postgresql://user:password@host:port/database',
                       connect_args={'options': '-c statement_timeout=1000'} #Voorbeeld van timeout
                      )

# Stel het isolatieniveau in bij het starten van een transactie (databasespecifiek)
# Voor postgresql wordt aanbevolen om het in te stellen op de verbinding, niet op de engine.

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


# Vervolgens zullen transacties die via SQLAlchemy worden aangemaakt, het geconfigureerde isolatieniveau gebruiken.

            

              
                Copy
              
            
          

Belangrijk: De methode voor het instellen van isolatieniveaus is databasespecifiek. Raadpleeg uw databasedocumentatie voor de juiste syntaxis. Het onjuist instellen van isolatieniveaus kan leiden tot onverwacht gedrag of fouten.

Concurrency Afhandelen

Wanneer meerdere gebruikers of processen tegelijkertijd toegang hebben tot dezelfde gegevens, is het cruciaal om concurrency correct af te handelen om datacorruptie te voorkomen en dataconsistentie te waarborgen. SQLAlchemy biedt verschillende mechanismen voor het afhandelen van concurrency, waaronder optimistisch vergrendelen en pessimistisch vergrendelen.

Optimistisch Vergrendelen

Optimistisch vergrendelen gaat ervan uit dat conflicten zeldzaam zijn. Het controleert op wijzigingen die zijn aangebracht door andere transacties voordat een transactie wordt vastgelegd. Als er een conflict wordt gedetecteerd, wordt de transactie teruggedraaid.

Om optimistisch vergrendelen te implementeren, voegt u doorgaans een versiekolom toe aan uw tabel. Deze kolom wordt automatisch verhoogd wanneer de rij wordt bijgewerkt.

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

#Binnen het try catch blok

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

    if article is None:
        raise ValueError("Artikel niet gevonden")

    original_version = article.version

    # Update de inhoud en verhoog de versie
    article.content = new_content
    article.version += 1

    # Probeer bij te werken, controleer de versiekolom in de WHERE-clausule
    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: Artikel is bijgewerkt door een andere transactie.")
    
    session.commit()

            

              
                Copy
              
            
          

In dit voorbeeld:

• We voegen een `version` kolom toe aan het `Article` model.
• Voordat we het artikel bijwerken, slaan we het huidige versienummer op.
• In de `UPDATE` statement nemen we een `WHERE` clausule op die controleert of de versiekolom nog steeds gelijk is aan het opgeslagen versienummer. `synchronize_session=False` voorkomt dat SQLAlchemy het bijgewerkte object opnieuw laadt; we handelen de versiebeheer expliciet af.
• Als de versiekolom is gewijzigd door een andere transactie, heeft de `UPDATE` statement geen invloed op rijen (rows_affected is 0) en genereren we een uitzondering.
• We rollen de transactie terug en informeren de gebruiker dat er een conflict is opgetreden.

Pessimistisch Vergrendelen

Pessimistisch vergrendelen gaat ervan uit dat conflicten waarschijnlijk zijn. Het verkrijgt een lock op een rij of tabel voordat deze wordt gewijzigd. Dit voorkomt dat andere transacties de gegevens wijzigen totdat de lock is vrijgegeven.

SQLAlchemy biedt verschillende functies voor het verkrijgen van locks, zoals `with_for_update()`.

            # Voorbeeld met behulp van PostgreSQL
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base

# Database setup (vervang door uw daadwerkelijke database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False) #Zet echo op true als je de gegenereerde SQL wilt zien
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)

#Functie om het item bij te werken (binnen een try/except)
def update_item_value(session, item_id, new_value):
    # Verkrijg een pessimistische lock op het item
    item = session.query(Item).filter(Item.id == item_id).with_for_update().first()

    if item is None:
        raise ValueError("Item niet gevonden")

    # Update de waarde van het item
    item.value = new_value
    session.commit()
    return True

            

              
                Copy
              
            
          

In dit voorbeeld:

• We gebruiken `with_for_update()` om een lock te verkrijgen op de `Item` rij voordat we deze bijwerken. Dit voorkomt dat andere transacties de rij wijzigen totdat de huidige transactie is vastgelegd of teruggedraaid. De `with_for_update()` functie is databasespecifiek; raadpleeg uw databasedocumentatie voor details. Sommige databases kunnen verschillende vergrendelingsmechanismen of syntaxis hebben.

Belangrijk: Pessimistisch vergrendelen kan de concurrency en prestaties verminderen, dus gebruik het alleen wanneer dat nodig is.

Best Practices voor Uitzonderingsafhandeling

Een goede uitzonderingsafhandeling is cruciaal om de data-integriteit te waarborgen en applicatie crashes te voorkomen. Omwikkel uw databasebewerkingen altijd in `try...except` blokken en behandel uitzonderingen op de juiste manier.

Hier zijn enkele best practices voor uitzonderingsafhandeling:

• Vang specifieke uitzonderingen op: Vermijd het opvangen van generieke uitzonderingen zoals `Exception`. Vang specifieke uitzonderingen op zoals `sqlalchemy.exc.IntegrityError` of `sqlalchemy.exc.OperationalError` om verschillende soorten fouten anders te behandelen.
• Rol transacties terug: Rol de transactie altijd terug als er een uitzondering optreedt.
• Log uitzonderingen: Log uitzonderingen om te helpen bij het diagnosticeren en oplossen van problemen. Voeg zoveel mogelijk context toe aan uw logs (bijv. de gebruikers-ID, de invoergegevens, de timestamp).
• Herhaal uitzonderingen wanneer dat nodig is: Als u een uitzondering niet kunt afhandelen, herhaal deze dan zodat een handler op een hoger niveau er mee om kan gaan.
• Maak resources schoon: Sluit altijd de sessie en geef alle andere resources vrij in een `finally` blok.

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

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

# Database setup (vervang door uw daadwerkelijke database URL)
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)

# Functie om een product toe te voegen
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}' succesvol toegevoegd.")
        return True
    except IntegrityError as e:
        session.rollback()
        logging.error(f"IntegrityError: {e}")
        #Behandel database constraint violations (bijv. dubbele naam)
        return False
    except OperationalError as e:
        session.rollback()
        logging.error(f"OperationalError: {e}")
        #Behandel verbindingsfouten of andere operationele problemen
        return False
    except Exception as e:
        session.rollback()
        logging.exception(f"Er is een onverwachte fout opgetreden: {e}")
        # Behandel alle andere onverwachte fouten
        return False
    finally:
        session.close()

            

              
                Copy
              
            
          

In dit voorbeeld:

• We configureren logging om gebeurtenissen tijdens het proces vast te leggen.
• We vangen specifieke uitzonderingen op zoals `IntegrityError` (voor constraint violations) en `OperationalError` (voor verbindingsfouten).
• We rollen de transactie terug in de `except` blokken.
• We loggen de uitzonderingen met behulp van de `logging` module. De `logging.exception()` methode bevat automatisch de stack trace in het logbericht.
• We herhalen de uitzondering als we deze niet kunnen afhandelen.
• We sluiten de sessie in het `finally` blok.

Database Connection Pooling

SQLAlchemy maakt gebruik van connection pooling om databaseverbindingen efficiënt te beheren. Een connection pool onderhoudt een set open verbindingen met de database, waardoor applicaties bestaande verbindingen kunnen hergebruiken in plaats van nieuwe verbindingen aan te maken voor elk verzoek. Dit kan de prestaties aanzienlijk verbeteren, vooral in applicaties die een groot aantal gelijktijdige verzoeken verwerken.

De `create_engine()` functie van SQLAlchemy maakt automatisch een connection pool aan. U kunt de connection pool configureren door argumenten door te geven aan `create_engine()`.

Algemene connection pool parameters zijn:

• pool_size: Het maximale aantal verbindingen in de pool.
• max_overflow: Het aantal verbindingen dat kan worden aangemaakt boven de pool_size.
• pool_recycle: Het aantal seconden waarna een verbinding wordt gerecycled.
• pool_timeout: Het aantal seconden dat moet worden gewacht voordat een verbinding beschikbaar komt.

            engine = create_engine('postgresql://user:password@host:port/database',
                       pool_size=5, #Maximale pool grootte
                       max_overflow=10, #Maximale overflow
                       pool_recycle=3600, #Recycle verbindingen na 1 uur
                       pool_timeout=30
                      )

            

              
                Copy
              
            
          

Belangrijk: Kies de juiste connection pool instellingen op basis van de behoeften van uw applicatie en de mogelijkheden van uw databaseserver. Een slecht geconfigureerde connection pool kan leiden tot prestatieproblemen of connection exhaustion.

Asynchrone Transacties (Async SQLAlchemy)

Voor moderne applicaties die een hoge concurrency vereisen, vooral applicaties die zijn gebouwd met asynchrone frameworks zoals FastAPI of AsyncIO, biedt SQLAlchemy een asynchrone versie genaamd Async SQLAlchemy.

Async SQLAlchemy biedt asynchrone versies van de core SQLAlchemy componenten, waardoor u databasebewerkingen kunt uitvoeren zonder de event loop te blokkeren. Dit kan de prestaties en schaalbaarheid van uw applicaties aanzienlijk verbeteren.

Hier is een basisvoorbeeld van het gebruik van Async SQLAlchemy:

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

# Database setup (vervang door uw daadwerkelijke database URL)
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
              
            
          

Belangrijkste verschillen met synchrone SQLAlchemy:

• `create_async_engine` wordt gebruikt in plaats van `create_engine`.
• `AsyncSession` wordt gebruikt in plaats van `Session`.
• Alle databasebewerkingen zijn asynchroon en moeten worden afgewacht met behulp van `await`.
• Asynchrone database drivers (bijv. `asyncpg` voor PostgreSQL) moeten worden gebruikt.

Belangrijk: Async SQLAlchemy vereist een database driver die asynchrone bewerkingen ondersteunt. Zorg ervoor dat u de juiste driver hebt geïnstalleerd en geconfigureerd.

Conclusie

Het beheersen van SQLAlchemy sessie- en transactiebeheer is essentieel voor het bouwen van robuuste en betrouwbare Python-applicaties die communiceren met databases. Door de concepten van sessies, transacties, isolatieniveaus en concurrency te begrijpen, en door best practices te volgen voor uitzonderingsafhandeling en connection pooling, kunt u de data-integriteit waarborgen en de prestaties van uw applicaties optimaliseren.

Of u nu een kleine webapplicatie of een grootschalig bedrijfssysteem bouwt, SQLAlchemy biedt de tools die u nodig hebt om uw database interacties effectief te beheren. Vergeet niet om altijd prioriteit te geven aan data-integriteit en potentiële fouten elegant af te handelen om de betrouwbaarheid van uw applicaties te waarborgen.

Overweeg geavanceerde onderwerpen te verkennen, zoals:

• Two-Phase Commit (2PC): Voor transacties die meerdere databases omvatten.
• Sharding: Voor het distribueren van gegevens over meerdere databaseservers.
• Database migraties: Met behulp van tools zoals Alembic om database schema wijzigingen te beheren.