# Database Access

The Django ORM is a synchronous piece of code, and so if you want to access it from asynchronous code you need to do special handling to make sure its connections are closed properly.

If you’re using `SyncConsumer`, or anything based on it - like `JsonWebsocketConsumer` - you don’t need to do anything special, as all your code is already run in a synchronous mode and Channels will do the cleanup for you as part of the `SyncConsumer` code.

If you are writing asynchronous code, however, you will need to call database methods in a safe, synchronous context, using `database_sync_to_async` or by using the asynchronous methods prefixed with `a` like `Model.objects.aget()`.

## Database Connections

Channels can potentially open a lot more database connections than you may be used to if you are using threaded consumers (synchronous ones) - it can open up to one connection per thread.

If you wish to control the maximum number of threads used, set the `ASGI_THREADS` environment variable to the maximum number you wish to allow. By default, the number of threads is set to “the number of CPUs * 5” for Python 3.7 and below, and min(32, os.cpu_count() + 4) for Python 3.8+.

To avoid having too many threads idling in connections, you can instead rewrite your code to use async consumers and only dip into threads when you need to use Django’s ORM (using `database_sync_to_async`).

When using async consumers Channels will automatically call Django’s `close_old_connections` method when a new connection is started, when a connection is closed, and whenever anything is received from the client. This mirrors Django’s logic for closing old connections at the start and end of a request, to the extent possible. Connections are not automatically closed when sending data from a consumer since Channels has no way to determine if this is a one-off send (and connections could be closed) or a series of sends (in which closing connections would kill performance). Instead, if you have a long-lived async consumer you should periodically call `aclose_old_connections` (see below).

## database_sync_to_async

`channels.db.database_sync_to_async` is a version of `asgiref.sync.sync_to_async` that also cleans up database connections on exit.

To use it, write your ORM queries in a separate function or method, and then call it with `database_sync_to_async` like so:

    from channels.db import database_sync_to_async

    async def connect(self):
        self.username = await database_sync_to_async(get_name)()

    def get_name(self):
        return User.objects.all()[0].name

You can also use it as a decorator:

    from channels.db import database_sync_to_async

    async def connect(self):
        self.username = await get_name()

    @database_sync_to_async
    def get_name(self):
        return User.objects.all()[0].name

## aclose_old_connections

`channels.db.aclose_old_connections` is an async wrapper around Django’s `close_old_connections`. When using a long-lived `AsyncConsumer` that calls the Django ORM it is important to call this function periodically.

Preferrably, this function should be called before making the first query in a while. For example, it should be called if the Consumer is woken up by a channels layer event and needs to make a few ORM queries to determine what to send to the client. This function should be called before making those queries. Calling this function more than necessary is not necessarily a bad thing, but it does require a context switch to synchronous code and so incurs a small penalty.