  that all models would be available on all databases.
  
  With this setup installed, lets run some Django code::
  
      >>> # This retrieval will be performed on the 'credentials' database
      >>> fred = User.objects.get(username='fred')
      >>> fred.first_name = 'Frederick'
  
      >>> # This save will also be directed to 'credentials'
      >>> fred.save()
 
</s> remove     >>> # This save will also be directed to 'credentials'
 </s> add     >>> # This save will also be directed to 'auth_db' </s> remove So - what does this mean in practice? Say you want ``myapp`` to
exist on the ``other`` database, and you want all other models in a
master/slave relationship between the databases ``master``, ``slave1`` and
``slave2``. To implement this, you would need 2 routers::
 </s> add So - what does this mean in practice? Let's consider another sample
configuration. This one will have several databases: one for the
``auth`` application, and all other apps using a master/slave setup
with two read slaves. Here are the settings specifying these
databases:: </s> remove ``MyAppRouter`` is processed before the ``MasterSlaveRouter``, and as a
result, decisions concerning the models in ``myapp`` are processed
 </s> add ``AuthRouter`` is processed before the ``MasterSlaveRouter``, and as a
result, decisions concerning the models in ``auth`` are processed </s> remove         def db_for_read(self, model, **hints):
            "Point all operations on myapp models to 'other'"
            if model._meta.app_label == 'myapp':
                return 'other'
            return None

        def db_for_write(self, model, **hints):
            "Point all operations on myapp models to 'other'"
            if model._meta.app_label == 'myapp':
                return 'other'
            return None

        def allow_relation(self, obj1, obj2, **hints):
            "Allow any relation if a model in myapp is involved"
            if obj1._meta.app_label == 'myapp' or obj2._meta.app_label == 'myapp':
                return True
            return None

        def allow_syncdb(self, db, model):
            "Make sure the myapp app only appears on the 'other' db"
            if db == 'other':
                return model._meta.app_label == 'myapp'
            elif model._meta.app_label == 'myapp':
                return False
            return None
 </s> add Now we'll need to handle routing. First we want a router that knows to
send queries for the ``auth`` app to ``auth_db``::

    class AuthRouter(object):
        """
        A router to control all database operations on models in the
        auth application.
        """
	def db_for_read(self, model, **hints):
	    """
	    Attempts to read auth models go to auth_db.
	    """
	    if model._meta.app_label == 'auth':
	        return 'auth_db'
 	    return None

	def db_for_write(self, model, **hints):
	    """
	    Attempts to write auth models go to auth_db.
	    """
	    if model._meta.app_label == 'auth':
	        return 'auth_db'
	    return Non

	def allow_relation(self, obj1, obj2, **hints):
	    """
	    Allow relations if a model in the auth app is involved.
	    """
	    if obj1._meta.app_label == 'auth' or \
               obj2._meta.app_label == 'auth':
	       return True
	    return None

	def allow_syncdb(self, db, model):
	    """
	    Make sure the auth app only appears in the 'auth_db'
	    database.
	    """
	    if db == 'auth_db':
	        return model._meta.app_label == 'auth'
	    elif model._meta.app_label == 'auth':
	        return False
	    return None

And we also want a router that sends all other apps to the
master/slave configuration, and randomly chooses a slave to read
from::

    import random </s> remove     class MyAppRouter(object):
        """A router to control all database operations on models in
        the myapp application"""
 </s> add     DATABASES = {
        'auth_db': {
            'NAME': 'auth_db',
            'ENGINE': 'django.db.backends.mysql',
            'USER': 'mysql_user',
            'PASSWORD': 'swordfish',
        },
        'master': {
            'NAME': 'master',
            'ENGINE': 'django.db.backends.mysql',
            'USER': 'mysql_user',
            'PASSWORD': 'spam',
        },
        'slave1': {
            'NAME': 'slave1',
            'ENGINE': 'django.db.backends.mysql',
            'USER': 'mysql_user',
            'PASSWORD': 'eggs',
        },
        'slave2': {
            'NAME': 'slave2',
            'ENGINE': 'django.db.backends.mysql',
            'USER': 'mysql_user',
            'PASSWORD': 'bacon',
        },
    }
    >>> # This retrieval will be performed on the 'auth_db' database
  that all models would be available on all databases.
  
  With this setup installed, lets run some Django code::
  
    >>> # This retrieval will be performed on the 'auth_db' database
      >>> fred = User.objects.get(username='fred')
      >>> fred.first_name = 'Frederick'
  
      >>> # This save will also be directed to 'credentials'
      >>> fred.save()
keep keep keep keep replace keep keep keep keep keep
 Ticket 18657: Fix inconsistent DB names in router example.

This rewrites the entire example to use the same DB names throughout,
and also is hopefully a bit more sensibly described. Additionally, the
missing import of the random module for choosing a read slave is
included in the example now. 
docs/topics/db/multi-db.txt