Using Transaction Functions for Retries

Neo4j Aura manages the health and maintenance of your AuraDB Instance cluster behind the scenes. In most instances, the specifics of the cluster are not needed for your application to make use of it.

However, there is an edge case when your application may need to retry a transaction due to the current leader of the cluster becoming unavailable.

Neo4j Aura employs Client-side routing, which means that in such situations, further operations can only resume after the driver's routing table has been updated.

It is possible for a transaction to be interrupted by either the constituent parts of the AuraDB Instance temporarily losing their connections to one another or for the network connection between your application and the cluster to be lost prior to committing.
If either of those scenarios were to happen, the driver would report an error similar to the following:

Caused by: org.neo4j.driver.v1.exceptions.ServiceUnavailableException: Connection
to the database terminated. This can happen due to network instabilities, or due
to restarts of the database.

For this reason, Neo4j Aura supports using transaction functions to retry transactions.
The behaviour is described as this in our documentation here and applies to all different language drivers:

Transient errors trigger a retry
Transactions are idempotent and, as such, produce the same results for each execution
Queries as part of a transaction end up being run only once at most as part of the retries.

An example from our documentation of a transaction function using Java is:

public void addPerson( final String name )
{
    try ( Session session = driver.session() )
    {
        session.writeTransaction( new TransactionWork<Integer>()
        {
            @Override
            public Integer execute( Transaction tx )
            {
                return createPersonNode( tx, name );
            }
        } );
    }
}

private static int createPersonNode( Transaction tx, String name )
{
    tx.run( "CREATE (a:Person {name: $name})", parameters( "name", name ) );
    return 1;
}

Transaction functions can be used to handle any transient connection problems that occur between your application and your AuraDB Instance.

Should your application continue to receive errors even after performing a reasonable number of retries, please create a support ticket for assistance.

For further details for each of the drivers, please check the relevant section of our documentation:

Tags: transactionsTags: auraTags: cloudTags: privateTags: driverTags: transactionTags: retryTags: functionTags: recommended

Articles in this section

Comments

Articles in this section

Related articles