How to avoid/fix django's DatabaseTransactionError

Question

I have the following (paraphrased) code that's subject to race conditions:

def calculate_and_cache(template, template_response):
    # run a fairly slow and intensive calculation:
    calculated_object = calculate_slowly(template, template_response)
    cached_calculation = Calculation(calculated=calculated_object,
                                     template=template,
                                     template_response=template_response)
    # try to save the calculation just computed:
    try:
        cached_calculation.save()
        return cached_calculation
    # if another thread beat you to saving this, catch the exception
    # but return the object that was just calculated
    except DatabaseError as error:
        log(error)
        return cached_calculation

And it's raising a DatabaseTransactionError:

TransactionManagementError: An error occurred in the current transaction.
You can't execute queries until the end of the 'atomic' block.

The docs have this to say about DTE's:

When exiting an atomic block, Django looks at whether it’s exited normally or with an exception to determine whether to commit or roll back.... If you attempt to run database queries before the rollback happens, Django will raise a TransactionManagementError.

But they also have this, much more vague thing to say about them as well:

TransactionManagementError is raised for any and all problems related to database transactions.

My questions, in order of ascending generality:

1. Will catching a DatabaseError actually address the race condition by letting the save() exit gracefully while still returning the object?
2. Where does the atomic block begin in the above code and where does it end?
3. What am I doing wrong and how can I fix it?

Answer 1

The Django docs on controlling transactions explicitly have an example of catching exceptions in atomic blocks.

In your case, you don't appear to be using the atomic decorator at all, so first you need to add the required import.

from django.db import transaction

Then you need to move the code that could raise a database error into an atomic block:

try:
    with transaction.atomic():
        cached_calculation.save()
    return cached_calculation
# if another thread beat you to saving this, catch the exception
# but return the object that was just calculated
except DatabaseError as error:
    log(error)
    return cached_calculation