Coordinate parallel transactions

with driver.session() as session:
    session.execute_write(lambda tx: tx.run("<QUERY 1>"))
    session.execute_write(lambda tx: tx.run("<QUERY 2>"))  # can read QUERY 1
    session.execute_write(lambda tx: tx.run("<QUERY 3>"))  # can read QUERY 1,2
    ...

from neo4j import GraphDatabase, Bookmarks


URI = "<URI for Neo4j database>"
AUTH = ("<Username>", "<Password>")

def main():
    with GraphDatabase.driver(URI, auth=AUTH) as driver:
        create_some_friends(driver)


def create_some_friends(driver):
    saved_bookmarks = Bookmarks()  # To collect the sessions' bookmarks

    # Create the first person and employment relationship.
    with driver.session() as session_a:
        session_a.execute_write(create_person, "Alice")
        session_a.execute_write(employ, "Alice", "Wayne Enterprises")
        saved_bookmarks += session_a.last_bookmarks()

    # Create the second person and employment relationship.
    with driver.session() as session_b:
        session_b.execute_write(create_person, "Bob")
        session_b.execute_write(employ, "Bob", "LexCorp")
        saved_bookmarks += session_b.last_bookmarks()

    # Create a friendship between the two people created above.
    with driver.session(bookmarks=saved_bookmarks) as session_c:
        session_c.execute_write(create_friendship, "Alice", "Bob")
        session_c.execute_read(print_friendships)


# Create a person node.
def create_person(tx, name):
    tx.run("CREATE (:Person {name: $name})", name=name)


# Create an employment relationship to a pre-existing company node.
# This relies on the person first having been created.
def employ(tx, person_name, company_name):
    tx.run("MATCH (person:Person {name: $person_name}) "
           "MATCH (company:Company {name: $company_name}) "
           "CREATE (person)-[:WORKS_FOR]->(company)",
           person_name=person_name, company_name=company_name)


# Create a friendship between two people.
def create_friendship(tx, name_a, name_b):
    tx.run("MATCH (a:Person {name: $name_a}) "
           "MATCH (b:Person {name: $name_b}) "
           "MERGE (a)-[:KNOWS]->(b)",
           name_a=name_a, name_b=name_b)


# Retrieve and display all friendships.
def print_friendships(tx):
    result = tx.run("MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name")
    for record in result:
        print("{} knows {}".format(record["a.name"], record["b.name"]))


if __name__ == "__main__":
    main()