async def get_authors(pattern):
    # Create a new context to call concurrently
    async with db.new_connections():
        return [
            author.name
            async for author in Authors.objects.filter(name__icontains=pattern)
        ]

async def get_books(pattern):
    # Create a new context to call concurrently
    async with db.new_connections():
        return [
            book.title
            async for book in Book.objects.filter(name__icontains=pattern)
        ]

async def my_view(request):
    # Query authors and books concurrently
    task_authors = asyncio.create_task(get_authors("an"))
    task_books = asyncio.create_task(get_books("di"))
    return render(
        request,
        "template.html",
        {
            "books": await task_books,
            "authors": await task_authors,
        },
    )

async def my_view(request):
    task_authors = get_authors("an")
    task_books = get_books("di")
    return render(
        request,
        "template.html",
        {
            "books": await task_books,
            "authors": await task_authors,
        },
    )

async def get_authors(pattern):
    # without new connection
    return [
        author.name
        async for author in Authors.objects.filter(name__icontains=pattern)
    ]

async def get_books(pattern):
    # create new connection and put it on stack
    async with db.new_connections():
        return [
            book.title
            async for book in Book.objects.filter(name__icontains=pattern)
        ]
        # delete connection from the stack

    # delete parent connection from the stack
    await async_connections['default'].close()

async def my_view(request):
    async with db.new_connections():
        # Query authors and books concurrently
        task_authors = asyncio.create_task(get_authors("an"))
        task_books = asyncio.create_task(get_books("di"))

        return render(
            request,
            "template.html",
            {
                "books": await task_books,
                "authors": await task_authors,
            },
        )

def concurrent_async_db(func):
    if not inspect.iscoroutinefunction(func):
        raise TypeError("Function decorated with @concurrent_async_db must be an async function")

    async def concurrent(*args, **kwargs):
        # Clean up or isolate DB connection state before calling the real function
        # or something like this async_connections.refresh()
        async_connections['default'] = None
        return await func(*args, **kwargs)

    @wraps(func)
    def wrapper(*args, **kwargs):
        # we use asyncio.create_task coz without it, the concurrent connection doesn't have any sense
        return asyncio.create_task(concurrent(*args, **kwargs))

    return wrapper

@concurrent_async_db
async def get_authors(pattern):
    return [
        author.name
        async for author in Authors.objects.filter(name__icontains=pattern)
    ]

async def my_view(request):
    async with db.new_connections():
        # Query authors and books concurrently
        task_authors = asyncio.create_task(get_authors("an"))
        task_books = asyncio.create_task(get_books("di"))

        return render(
            request,
            "template.html",
            {
                "books": await task_books,
                "authors": await task_authors,
            },
        )

class AsyncConnectionHandler(BaseAsyncConnectionHandler):
  
    ...

    def create_connection(self, alias):
         db = self.settings[alias]
         backend = load_backend(db["ENGINE"])

         if not hasattr(backend, 'AsyncDatabaseWrapper'):
             raise self.exception_class(
                 f"The async connection '{alias}' doesn't exist."
             )

         return backend.AsyncDatabaseWrapper(db, alias)

await User.objects.aget(id=user_id)

class QuerySet(AltersData):
    def count(self):
        if self._result_cache is not None:
            return len(self._result_cache)

        return self.query.get_count(using=self.db)

    async def acount(self):
        return await sync_to_async(self.count)()

class RawQuery:

    def _execute_query(self):
        connection = connections[self.using]
        ...

    async def _execute_query(self):
        connection = async_connections[self.using]
        ...

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        # ...
    },
}

connections = ConnectionHandler()
async_connections = AsyncConnectionHandler()

connection = async_connections[DEFAULT_DB_ALIAS]

async with connection.cursor() as cursor:
    await cursor.execute("""select 1""")

connection = connections[DEFAULT_DB_ALIAS]

with connection.cursor() as cursor:
    cursor.execute("""select 1""")

import asyncio

class AsyncResource:
    async def __aenter__(self):
        print("Enter context")
        return self

    async def __aexit__(self, exc_type, exc, tb):
        print("Exiting context: start")
        await asyncio.sleep(2)
        print("Exiting context: end")


async def task_that_uses_resource():
    async with AsyncResource():
        await asyncio.sleep(1)


async def main():
    task = asyncio.create_task(task_that_uses_resource())

    # Let the task run a bit and then cancel it
    await asyncio.sleep(1.5)
    print("Cancelling the task...")
    task.cancel()

    try:
        await task
    except asyncio.CancelledError:
        print("Task was cancelled!")


asyncio.run(main())

# use sync context manager instead
@contextmanager
def independent_connection(self):
    active_connection = self.all(initialized_only=True)

    try:
        for conn in active_connection:
            del self[conn.alias]
        yield
    finally:
        # run async code in a separate coroutine without await
        asyncio.create_task(self.close_all())
        for conn in active_connection:
            self[conn.alias] = conn

from asyncio import shield


class new_connection:

    ...

    async def __aexit__(self, exc_type, exc_value, traceback):
        await shield(self._aexit(exc_type, exc_value, traceback))

    async def _aexit(self, exc_type, exc_value, traceback):
        autocommit = await self.conn.aget_autocommit()
        if autocommit is False:
            if exc_type is None and self.force_rollback is False:
                await self.conn.acommit()
            else:
                await self.conn.arollback()
        await self.conn.aclose()

        await async_connections.pop_connection(self.using)

import asyncio

from django.db import new_connection, async_connections, DEFAULT_DB_ALIAS
from django.test import TransactionTestCase, skipUnlessDBFeature



@skipUnlessDBFeature("supports_async")
class NestedConnectionTest(TransactionTestCase):

    available_apps = ["async"]

    async def test_nesting_error1(self):
        async def aget_autocommit_new():
            raise asyncio.CancelledError

        async with new_connection() as conn1:
            assert async_connections.count == 1
            main_connection = async_connections.get_connection(DEFAULT_DB_ALIAS)

            aget_autocommit_old = conn1.aget_autocommit
            try:
                async with new_connection() as conn2:
                    assert async_connections.count == 2
                    conn2.aget_autocommit = aget_autocommit_new
            except:
                pass

            conn1.aget_autocommit = aget_autocommit_old

            assert main_connection == async_connections.get_connection(DEFAULT_DB_ALIAS)
            assert async_connections.count == 1

    async def __aexit__(self, exc_type, exc_value, traceback):
        try:
            autocommit = await self.conn.aget_autocommit()
            if autocommit is False:
                if exc_type is None and self.force_rollback is False:
                    await self.conn.acommit()
                else:
                    await self.conn.arollback()
        finally:
            await self.conn.aclose()
            await async_connections.pop_connection(self.using)