Ticket #15888: 15888-code-1.diff

django/contrib/gis/db/backends/spatialite/creation.py

@@ -54 +54 @@
             interactive=False,
             database=self.connection.alias)
 
-        from django.core.cache import get_cache
-        from django.core.cache.backends.db import BaseDatabaseCache
-        for cache_alias in settings.CACHES:
-            cache = get_cache(cache_alias)
-            if isinstance(cache, BaseDatabaseCache):
-                call_command('createcachetable', cache._table, database=self.connection.alias)
+        call_command('createcachetable', database=self.connection.alias)
 
         # Get a cursor (even though we don't need one yet). This has
         # the side effect of initializing the test database.

django/core/management/commands/createcachetable.py

@@ -1 +1 @@
 from optparse import make_option
 
+from django.conf import settings
+from django.core.cache import get_cache
 from django.core.cache.backends.db import BaseDatabaseCache
-from django.core.management.base import LabelCommand, CommandError
+from django.core.management.base import BaseCommand, CommandError
 from django.db import connections, router, transaction, models, DEFAULT_DB_ALIAS
 from django.db.utils import DatabaseError
 from django.utils.encoding import force_text
 
 
-class Command(LabelCommand):
-    help = "Creates the table needed to use the SQL cache backend."
-    args = "<tablename>"
-    label = 'tablename'
+class Command(BaseCommand):
+    help = "Creates the tables needed to use the SQL cache backend."
 
-    option_list = LabelCommand.option_list + (
+    option_list = BaseCommand.option_list + (
         make_option('--database', action='store', dest='database',
             default=DEFAULT_DB_ALIAS, help='Nominates a database onto '
-                'which the cache table will be installed. '
+                'which the cache tables will be installed. '
                 'Defaults to the "default" database.'),
     )
 
     requires_model_validation = False
 
-    def handle_label(self, tablename, **options):
+    def handle(self, *tablenames, **options):
         db = options.get('database')
+        self.verbosity = int(options.get('verbosity'))
+        if len(tablenames):
+            # Legacy behaviour, tablename specified as argument
+            for tablename in tablenames:
+                self.create_table(db, tablename)
+        else:
+            for cache_alias in settings.CACHES:
+                cache = get_cache(cache_alias)
+                if isinstance(cache, BaseDatabaseCache):
+                    self.create_table(db, cache._table)
+
+    def create_table(self, database, tablename):
         cache = BaseDatabaseCache(tablename, {})
-        if not router.allow_syncdb(db, cache.cache_model_class):
+        if not router.allow_syncdb(database, cache.cache_model_class):
             return
-        connection = connections[db]
+        connection = connections[database]
         fields = (
             # "key" is a reserved word in MySQL, so use "cache_key" instead.
             models.CharField(name='cache_key', max_length=255, unique=True, primary_key=True),
@@ -57 +69 @@
         try:
             curs.execute("\n".join(full_statement))
         except DatabaseError as e:
-            transaction.rollback_unless_managed(using=db)
+            transaction.rollback_unless_managed(using=database)
             raise CommandError(
                 "Cache table '%s' could not be created.\nThe error was: %s." %
                     (tablename, force_text(e)))
         for statement in index_output:
             curs.execute(statement)
-        transaction.commit_unless_managed(using=db)
+        transaction.commit_unless_managed(using=database)
+        if self.verbosity > 1:
+            self.stdout.write("Cache table '%s' created." % tablename)

django/db/backends/creation.py

@@ -303 +303 @@
             interactive=False,
             database=self.connection.alias)
 
-        from django.core.cache import get_cache
-        from django.core.cache.backends.db import BaseDatabaseCache
-        for cache_alias in settings.CACHES:
-            cache = get_cache(cache_alias)
-            if isinstance(cache, BaseDatabaseCache):
-                call_command('createcachetable', cache._table,
-                             database=self.connection.alias)
+        call_command('createcachetable', database=self.connection.alias)
 
         # Get a cursor (even though we don't need one yet). This has
         # the side effect of initializing the test database.

tests/regressiontests/cache/tests.py

@@ -796 +796 @@
     return 'CUSTOM-' + '-'.join([key_prefix, str(version), key])
 
 
+@override_settings(
+    CACHES={
+        'default': {
+            'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
+            'LOCATION': 'test cache table',
+        },
+    },
+)
 class DBCacheTests(BaseCacheTests, TransactionTestCase):
     backend_name = 'django.core.cache.backends.db.DatabaseCache'
 
     def setUp(self):
         # Spaces are used in the table name to ensure quoting/escaping is working
         self._table_name = 'test cache table'
-        management.call_command('createcachetable', self._table_name, verbosity=0, interactive=False)
+        management.call_command('createcachetable', verbosity=0, interactive=False)
         self.cache = get_cache(self.backend_name, LOCATION=self._table_name, OPTIONS={'MAX_ENTRIES': 30})
         self.prefix_cache = get_cache(self.backend_name, LOCATION=self._table_name, KEY_PREFIX='cacheprefix')
         self.v2_cache = get_cache(self.backend_name, LOCATION=self._table_name, VERSION=2)
@@ -831 +839 @@
                 "Cache table 'test cache table' could not be created"):
             management.call_command(
                'createcachetable',
-                self._table_name,
                 verbosity=0,
                 interactive=False
             )
@@ -858 +865 @@
             return db == 'other'
 
 
+@override_settings(
+    CACHES={
+        'default': {
+            'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
+            'LOCATION': 'my_cache_table',
+        },
+    },
+)
 class CreateCacheTableForDBCacheTests(TestCase):
     multi_db = True
 
@@ -867 +882 @@
             router.routers = [DBCacheRouter()]
             # cache table should not be created on 'default'
             with self.assertNumQueries(0, using='default'):
-                management.call_command('createcachetable', 'cache_table',
+                management.call_command('createcachetable',
                                         database='default',
                                         verbosity=0, interactive=False)
             # cache table should be created on 'other'
             # one query is used to create the table and another one the index
             with self.assertNumQueries(2, using='other'):
-                management.call_command('createcachetable', 'cache_table',
+                management.call_command('createcachetable',
                                         database='other',
                                         verbosity=0, interactive=False)
         finally: