Ticket #12672: t12672-r12278.1.diff

django/core/management/commands/loaddata.py

@@ -8 +8 @@
 from django.core import serializers
 from django.core.management.base import BaseCommand
 from django.core.management.color import no_style
-from django.db import connections, transaction, DEFAULT_DB_ALIAS
+from django.db import connections, router, transaction, DEFAULT_DB_ALIAS
 from django.db.models import get_apps
 from django.utils.itercompat import product
 
@@ -31 +31 @@
         make_option('--database', action='store', dest='database',
             default=DEFAULT_DB_ALIAS, help='Nominates a specific database to load '
                 'fixtures into. Defaults to the "default" database.'),
-        make_option('-e', '--exclude', dest='exclude',action='append', default=[],
-            help='App to exclude (use multiple --exclude to exclude multiple apps).'),
     )
 
     def handle(self, *fixture_labels, **options):
         using = options.get('database', DEFAULT_DB_ALIAS)
-        excluded_apps = options.get('exclude', [])
 
         connection = connections[using]
         self.style = no_style()
@@ -171 +168 @@
                             try:
                                 objects = serializers.deserialize(format, fixture, using=using)
                                 for obj in objects:
-                                    if obj.object._meta.app_label not in excluded_apps:
+                                    if router.allow_syncdb(using, obj.object):
                                         objects_in_fixture += 1
                                         models.add(obj.object.__class__)
                                         obj.save(using=using)

django/core/management/commands/syncdb.py

@@ -16 +16 @@
         make_option('--database', action='store', dest='database',
             default=DEFAULT_DB_ALIAS, help='Nominates a database to synchronize. '
                 'Defaults to the "default" database.'),
-        make_option('-e', '--exclude', dest='exclude',action='append', default=[],
-            help='App to exclude (use multiple --exclude to exclude multiple apps).'),
     )
     help = "Create the database tables for all apps in INSTALLED_APPS whose tables haven't already been created."
 
@@ -26 +24 @@
         verbosity = int(options.get('verbosity', 1))
         interactive = options.get('interactive')
         show_traceback = options.get('traceback', False)
-        exclude = options.get('exclude', [])
 
         self.style = no_style()
 
@@ -59 +56 @@
         created_models = set()
         pending_references = {}
 
-        excluded_apps = set(models.get_app(app_label) for app_label in exclude)
-        included_apps = set(app for app in models.get_apps() if app not in excluded_apps)
-
         # Create the tables for each model
-        for app in included_apps:
+        for app in models.get_apps():
             app_name = app.__name__.split('.')[-2]
-            model_list = models.get_models(app, include_auto_created=True)
+            model_list = models.get_models(app, include_auto_created=True, using=db)
             for model in model_list:
                 # Create the model's database table, if it doesn't already exist.
                 if verbosity >= 2:
@@ -101 +95 @@
 
         # Install custom SQL for the app (but only if this
         # is a model we've just created)
-        for app in included_apps:
+        for app in models.get_apps():
             app_name = app.__name__.split('.')[-2]
             for model in models.get_models(app):
                 if model in created_models:
@@ -126 +120 @@
                             print "No custom SQL for %s.%s model" % (app_name, model._meta.object_name)
 
         # Install SQL indicies for all newly created models
-        for app in included_apps:
+        for app in models.get_apps():
             app_name = app.__name__.split('.')[-2]
             for model in models.get_models(app):
                 if model in created_models:
@@ -145 +139 @@
                             transaction.commit_unless_managed(using=db)
 
         from django.core.management import call_command
-        call_command('loaddata', 'initial_data', verbosity=verbosity, exclude=exclude, database=db)
+        call_command('loaddata', 'initial_data', verbosity=verbosity, database=db)

django/db/models/loading.py

@@ -4 +4 @@
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.datastructures import SortedDict
 from django.utils.importlib import import_module
+from django.db import router
 
 import sys
 import os
@@ -132 +133 @@
         self._populate()
         return self.app_errors
 
-    def get_models(self, app_mod=None, include_auto_created=False, include_deferred=False):
+    def get_models(self, app_mod=None, include_auto_created=False,
+                   include_deferred=False, using=None):
         """
         Given a module containing models, returns a list of the models.
         Otherwise returns a list of all installed models.
@@ -143 +145 @@
 
         By default, models created to satisfy deferred attribute
         queries are *not* included in the list of models. However, if
-        you specify include_deferred, they will be.
+        you specify include_deferred=True, they will be.
+
+        By default, if a model is defined, and matches the other arguments,
+        it will be returned. However, if a using argument is specified, only
+        models that are synchronized onto the named database will be returned.
         """
-        cache_key = (app_mod, include_auto_created, include_deferred)
+        cache_key = (app_mod, include_auto_created, include_deferred, using)
         try:
             return self._get_models_cache[cache_key]
         except KeyError:
@@ -160 +166 @@
             model_list.extend(
                 model for model in app.values()
                 if ((not model._deferred or include_deferred)
-                    and (not model._meta.auto_created or include_auto_created))
+                    and (not model._meta.auto_created or include_auto_created)
+                    and (using is None or router.allow_syncdb(using, model)))
             )
         self._get_models_cache[cache_key] = model_list
         return model_list

django/db/utils.py

@@ -120 +120 @@
             if allow is not None:
                 return allow
         return obj1._state.db == obj2._state.db
+
+    def allow_syncdb(self, db, model):
+        for router in self.routers:
+            allow = router.allow_syncdb(db, model)
+            if allow is not None:
+                return allow
+        return True

docs/ref/django-admin.txt

@@ -423 +423 @@
 have specified that you want to load data onto the ``master``
 database.
 
-Excluding applications from loading
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. versionadded:: 1.2
-
-The :djadminopt:`--exclude` option may be provided to prevent specific
-applications from being loaded.
-
-For example, if you wanted to exclude models from ``django.contrib.auth``
-from being loaded into your database, you would call::
-
-    django-admin.py loaddata mydata.json --exclude auth
-
-This will look for for a JSON fixture called ``mydata`` in all the
-usual locations - including the ``fixtures`` directory of the
-``django.contrib.auth`` application. However, any fixture object that
-identifies itself as belonging to the ``auth`` application (e.g.,
-instance of ``auth.User``) would be ignored by loaddata.
-
 makemessages
 ------------
 

docs/topics/db/multi-db.txt

@@ -66 +66 @@
     $ ./manage.py syncdb --database=users
 
 If you don't want every application to be synchronized onto a
-particular database. you can specify the :djadminopt:`--exclude`
-argument to :djadmin:`syncdb`. The :djadminopt:`--exclude` option lets
-you prevent a specific application or applications from being
-synchronized. For example, if you don't want the ``sales`` application
-to be in the ``users`` database, you could run::
-
-    $ ./manage.py syncdb --database=users --exclude=sales
+particular database, you can define a :ref:`database
+router<topics-db-multi-db-routing>` that implements a policy
+constraining the availability of particular models.
 
 Alternatively, if you want fine-grained control of synchronization,
 you can pipe all or part of the output of :djadmin:`sqlall` for a