Using a Database Router for Context-Based Database Selection

Based on the Django documentation on multi-database support, the most appropriate approach to achieve your goal would be to implement a temporary database router within a context manager. The execute_wrapper approach you tried won't work because it doesn't control which database connection is selected for a query - it only wraps the execution once a connection is already chosen.

Here's how you could implement this using a database router:

PYTHONCopied
from contextlib import contextmanager
from threading import local
from django.conf import settings

# Thread-local storage to track the current database
_thread_local = local()

class ContextualRouter:
    """
    A database router that routes queries to a database specified in a context.
    """
    def db_for_read(self, model, **hints):
        return getattr(_thread_local, 'database', None)
    
    def db_for_write(self, model, **hints):
        return getattr(_thread_local, 'database', None)
    
    def allow_relation(self, obj1, obj2, **hints):
        return True
    
    def allow_migrate(self, db, app_label, model_name=None, **hints):
        return True

@contextmanager
def using_database(database_name):
    """
    Context manager that routes all database operations to the specified database.
    
    Usage:
        with using_database('replica'):
            Model1.objects.filter(...)
            Model2.objects.filter(...)
    """
    # Store the original database setting
    old_database = getattr(_thread_local, 'database', None)
    
    # Set the new database
    _thread_local.database = database_name
    
    try:
        yield
    finally:
        # Restore the original database setting
        if old_database:
            _thread_local.database = old_database
        else:
            delattr(_thread_local, 'database')

To use this approach, you need to add the ContextualRouter to your DATABASE_ROUTERS setting:

PYTHONCopied
# In settings.py
DATABASE_ROUTERS = ['path.to.your.module.ContextualRouter']

Then you can use it as you described:

PYTHONCopied
with using_database('replica'):
    # These queries will use the 'replica' database
    Model1.objects.filter(...)
    Model2.objects.filter(...)

# These queries will use the default database
Model1.objects.filter(...)
Model2.objects.filter(...)

Important Considerations

1. Router Priority: This approach works because manually specified databases (using .using()) take priority over router allocations. If a query explicitly specifies a database with .using(), the router won't override it.

2. Thread Safety: The implementation uses thread-local storage to ensure that the context is isolated to the current thread, which is important in a multi-threaded environment like Django.

3. Router Order: If you have multiple routers, make sure this router is placed first in the DATABASE_ROUTERS list, or ensure that other routers return None for models that should be handled by this contextual router.

4. Cross-Database Relationships: Be aware that Django has limitations with cross-database relationships, as mentioned in the documentation. If your models have relationships across databases, you might encounter referential integrity issues.

This approach provides a clean, context-based way to route queries to specific databases without having to modify each query individually.