Transacties en sessies beheren
Begrijp hoe u transacties en sessies in uw toepassingscode beheert voor robuuste en betrouwbare database-interacties.
Transacties en sessies beheren is een gratis De basis van Neo4j-grafiekdatabases-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject De basis van Neo4j-grafiekdatabases. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus De basis van Neo4j-grafiekdatabases bevat in totaal 4 lessen.
Waarom transacties belangrijk zijn
Wanneer je gegevens in een database bijwerkt, vooral kritieke informatie, wil je zeker weten dat de bewerking betrouwbaar is. Daar komen transacties van pas.
Transacties helpen de integriteit en consistentie van gegevens te behouden, zelfs als er tijdens een bewerking iets misgaat.
Transacties begrijpen
Een transactie is één logische werkeenheid. Het is een reeks bewerkingen die als één atomaire bewerking wordt uitgevoerd.
Je kunt het vergelijken met geld overmaken tussen bankrekeningen: óf zowel de afschrijving als de bijschrijving vindt plaats, óf geen van beide. Je wilt niet dat geld van de ene rekening verdwijnt zonder op een andere rekening aan te komen.
De ACID-test
Transacties worden vaak beschreven aan de hand van hun ACID-eigenschappen:
- Atomiciteit: alles of niets. Óf de volledige transactie slaagt, óf geen enkel deel ervan.
- Consistentie: zorgt ervoor dat de database van de ene geldige toestand naar een andere gaat.
- Isolatie: gelijktijdige transacties verstoren elkaar niet.
- Duurzaamheid: zodra een transactie is vastgelegd, zijn de wijzigingen permanent.
Verbinden met sessies
In Neo4j communiceer je met de database via sessies. Een sessie beheert het communicatiekanaal en biedt methoden om Cypher-query's uit te voeren.
Sessies zijn lichtgewicht en ontworpen om vaak te worden geopend en gesloten. Ze vormen je belangrijkste interface voor het uitvoeren van query's, ook query's binnen transacties.
Een eenvoudige leessessie
Voor eenvoudige leesbewerkingen heb je vaak geen expliciet transactiebeheer nodig. Het Neo4j-stuurprogramma regelt dit voor je met een leestranactie.
Zo haal je het aantal knooppunten op met een sessie:
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
USERNAME = "neo4j"
PASSWORD = "password"
driver = GraphDatabase.driver(URI, auth=(USERNAME, PASSWORD))
def get_node_count(tx):
result = tx.run("MATCH (n) RETURN count(n) AS count")
return result.single()["count"]
with driver.session() as session:
count = session.read_transaction(get_node_count)
print(f"Total nodes in graph: {count}")
driver.close()Expliciete schrijftansacties
Voor bewerkingen die de database wijzigen (zoals CREATE, MERGE, SET en DELETE) is het een goede gewoonte om expliciete schrijftansacties te gebruiken. Dit zorgt voor atomiciteit.
De methode write_transaction zorgt automatisch voor het vastleggen als de bewerking slaagt, of voor het terugdraaien als er een fout optreedt.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
USERNAME = "neo4j"
PASSWORD = "password"
driver = GraphDatabase.driver(URI, auth=(USERNAME, PASSWORD))
def create_person(tx, name):
tx.run("CREATE (p:Person {name: $name})", name=name)
print(f"Created Person: {name}")
with driver.session() as session:
session.write_transaction(create_person, "Alice")
session.write_transaction(create_person, "Bob")
driver.close()Vastleggen of terugdraaien?
Bij expliciete transacties worden je wijzigingen pas permanent opgeslagen wanneer je ze vastlegt. Als er een fout optreedt, wordt de transactie teruggedraaid en worden alle wijzigingen ongedaan gemaakt.
De methoden session.write_transaction() en session.read_transaction() regelen dit impliciet voor je. Als de functie die eraan is doorgegeven zonder fout wordt voltooid, wordt de transactie vastgelegd. Als er een uitzondering optreedt, wordt de transactie teruggedraaid.
Robuuste foutafhandeling
Het is essentieel om fouten binnen je transactielogica af te handelen. Elke niet-afgehandelde uitzondering zorgt ervoor dat de transactie wordt teruggedraaid, waardoor gedeeltelijke updates worden voorkomen.
Je kunt standaard Python-blokken try...except binnen je transactiefunctie gebruiken om specifieke fouten te beheren of opruimacties uit te voeren.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
USERNAME = "neo4j"
PASSWORD = "password"
driver = GraphDatabase.driver(URI, auth=(USERNAME, PASSWORD))
def create_unique_node(tx, label, name):
try:
# Attempt to create a node. For demo, we'll re-raise to show rollback
tx.run(f"CREATE (n:{label} {{name: $name}})", name=name)
print(f"Node created: {name}")
except Exception as e:
print(f"Error creating node {name}: {e}")
# Re-raise to trigger rollback for the entire write_transaction
raise
with driver.session() as session:
# First call will likely succeed (unless node exists)
try:
session.write_transaction(create_unique_node, "City", "London")
except Exception:
print("Transaction for 'London' rolled back due to error.")
# Second call, intentionally designed to fail for demonstration
# (e.g., if we had a unique constraint on City.name)
try:
# Forcing an error to demonstrate rollback
def force_error(tx):
tx.run("CREATE (x)")
raise ValueError("Simulated error!")
session.write_transaction(force_error)
except Exception:
print("Transaction rolled back due to simulated error.")
driver.close()Python-achtige contextbeheerders
Voor een nog fijnmazigere controle, of wanneer je meerdere bewerkingen binnen één transactie uitvoert, kun je de sessie als contextbeheerder gebruiken en het transactieobject expliciet beheren.
De methode session.begin_transaction() retourneert een transactieobject dat ook als contextbeheerder werkt.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
USERNAME = "neo4j"
PASSWORD = "password"
driver = GraphDatabase.driver(URI, auth=(USERNAME, PASSWORD))
with driver.session() as session:
with session.begin_transaction() as tx:
tx.run("CREATE (a:Item {id: 1, name: 'Laptop'})")
tx.run("CREATE (b:Item {id: 2, name: 'Mouse'})")
# If no error, transaction commits automatically here when 'with tx' block exits
print("Two items created in one transaction.")
driver.close()Transactie-uitdaging
Stel dat je twee eigenschappen van één knooppunt in Neo4j bijwerkt binnen een Python-toepassing. Als de tweede update mislukt door een netwerkfout, wat moet er dan gebeuren met de eerste update als die deel uitmaakte van dezelfde expliciete schrijftansactie?
Samenvatting en volgende stappen
We hebben de cruciale rol behandeld die transacties spelen bij het behouden van gegevensintegriteit en -consistentie in je Neo4j-toepassingen.
- Transacties volgen ACID-eigenschappen.
- Je gebruikt sessies om met de database te communiceren.
session.read_transaction()ensession.write_transaction()bieden handige, atomaire bewerkingen.- Fouten binnen een transactie leiden tot een automatische terugdraaiing, zodat er geen gedeeltelijke gegevens worden vastgelegd.
- Contextbeheerders bieden een Python-achtige manier om sessies en transacties te beheren.
Transacties begrijpen is essentieel voor het bouwen van robuuste en betrouwbare Neo4j-toepassingen.
Leer De basis van Neo4j-grafiekdatabases met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Transacties en sessies beheren” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad De basis van Neo4j-grafiekdatabases, waaronder “Transacties en sessies beheren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus De basis van Neo4j-grafiekdatabases bevat in totaal 4 lessen.
Wat leer ik in “Transacties en sessies beheren”?
Begrijp hoe u transacties en sessies in uw toepassingscode beheert voor robuuste en betrouwbare database-interacties. Je oefent met De basis van Neo4j-grafiekdatabases door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met De basis van Neo4j-grafiekdatabases te beginnen?
Ervaring vooraf is niet nodig. De basis van Neo4j-grafiekdatabases op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Transacties en sessies beheren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over De basis van Neo4j-grafiekdatabases?
Ja. Elke les over De basis van Neo4j-grafiekdatabases bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Verbinding maken met de Python-driver
- CRUD-bewerkingen programmatisch uitvoeren
- Transacties en sessies beheren
- Connection pooling en foutafhandeling