Does cancelling an async Django view roll back ORM work running via sync_to_async?

No, cancelling an async Django view does not automatically roll back ORM work running via sync_to_async. If a client disconnects, the ASGI handler raises asyncio.CancelledError at the next await point in the coroutine, but this cancellation does not propagate into the separate thread where the synchronous ORM code is executing.

Execution Behavior

When you use sync_to_async, Django offloads the synchronous database operation to a thread pool. The relationship between the async view and the worker thread is as follows:

• The Coroutine: The async view is interrupted immediately at the await point when the CancelledError is raised.
• The Worker Thread: The thread executing the ORM logic is unaware of the coroutine's cancellation. It continues to execute the synchronous function to completion.
• The Transaction: Because the thread finishes its task normally, Django's default autocommit behavior will commit any changes made during that function call, regardless of whether the client is still connected.

Ensuring Atomicity

To prevent partial writes during a disconnect, you cannot rely on the async view's lifecycle. You must define the transaction boundary within the synchronous code itself.

Recommended Pattern

Wrap the database logic in transaction.atomic() inside the function being called by sync_to_async. This ensures that if an actual database error occurs, the work is rolled back. However, note that since the thread continues to run even after the view is cancelled, the transaction will still commit unless the synchronous code itself encounters an exception.

from django.db import transaction
from asgiref.sync import sync_to_async

def update_user_profile(user_id, data):
    with transaction.atomic():
        # All ORM work here is treated as a single unit
        user = User.objects.select_for_update().get(id=user_id)
        user.profile_data = data
        user.save()

async def my_async_view(request):
    try:
        await sync_to_async(update_user_profile)(request.user.id, request.POST)
    except asyncio.CancelledError:
        # The thread is still running update_user_profile,
        # but we can handle the cleanup of the async context here.
        raise

Verification Steps

To verify this behavior in your environment (assuming Django 3.1+ and an ASGI server like Daphne or Uvicorn):

1. Create a view that calls a sync_to_async function containing a time.sleep(10) followed by a database write.
2. Trigger the request and immediately terminate the client connection.
3. Observe that the database record is still created after 10 seconds, confirming the thread continues independently of the cancelled coroutine.

Diagnostic Detail: Are you using a custom thread executor or a non-standard database backend? Certain specialized executors may handle thread interruption differently than the default asgiref implementation.