Ticket #5106: backend-refactoring-v2.patch

django/contrib/auth/models.py

@@ -1 +1 @@
 from django.core import validators
 from django.core.exceptions import ImproperlyConfigured
-from django.db import backend, connection, models
+from django.db import connection, models
 from django.contrib.contenttypes.models import ContentType
 from django.utils.encoding import smart_str
 from django.utils.translation import ugettext_lazy as _
@@ -210 +210 @@
                     AND gp.%s = ug.%s
                     AND ct.%s = p.%s
                     AND ug.%s = %%s""" % (
-                backend.quote_name('app_label'), backend.quote_name('codename'),
-                backend.quote_name('auth_permission'), backend.quote_name('auth_group_permissions'),
-                backend.quote_name('auth_user_groups'), backend.quote_name('django_content_type'),
-                backend.quote_name('id'), backend.quote_name('permission_id'),
-                backend.quote_name('group_id'), backend.quote_name('group_id'),
-                backend.quote_name('id'), backend.quote_name('content_type_id'),
-                backend.quote_name('user_id'),)
+                connection.ops.quote_name('app_label'), connection.ops.quote_name('codename'),
+                connection.ops.quote_name('auth_permission'), connection.ops.quote_name('auth_group_permissions'),
+                connection.ops.quote_name('auth_user_groups'), connection.ops.quote_name('django_content_type'),
+                connection.ops.quote_name('id'), connection.ops.quote_name('permission_id'),
+                connection.ops.quote_name('group_id'), connection.ops.quote_name('group_id'),
+                connection.ops.quote_name('id'), connection.ops.quote_name('content_type_id'),
+                connection.ops.quote_name('user_id'),)
             cursor.execute(sql, [self.id])
             self._group_perm_cache = set(["%s.%s" % (row[0], row[1]) for row in cursor.fetchall()])
         return self._group_perm_cache

django/contrib/contenttypes/generic.py

@@ -4 +4 @@
 
 from django import oldforms
 from django.core.exceptions import ObjectDoesNotExist
-from django.db import backend
+from django.db import connection
 from django.db.models import signals
 from django.db.models.fields.related import RelatedField, Field, ManyToManyRel
 from django.db.models.loading import get_model
@@ -167 +167 @@
             model = rel_model,
             instance = instance,
             symmetrical = (self.field.rel.symmetrical and instance.__class__ == rel_model),
-            join_table = backend.quote_name(self.field.m2m_db_table()),
-            source_col_name = backend.quote_name(self.field.m2m_column_name()),
-            target_col_name = backend.quote_name(self.field.m2m_reverse_name()),
+            join_table = connection.ops.quote_name(self.field.m2m_db_table()),
+            source_col_name = connection.ops.quote_name(self.field.m2m_column_name()),
+            target_col_name = connection.ops.quote_name(self.field.m2m_reverse_name()),
             content_type = ContentType.objects.get_for_model(self.field.model),
             content_type_field_name = self.field.content_type_field_name,
             object_id_field_name = self.field.object_id_field_name

django/core/management.py

@@ -59 +59 @@
 
 def _get_installed_models(table_list):
     "Gets a set of all models that are installed, given a list of existing tables"
-    from django.db import backend, models
+    from django.db import connection, models
     all_models = []
     for app in models.get_apps():
         for model in models.get_models(app):
             all_models.append(model)
-    if backend.uses_case_insensitive_names:
-        converter = lambda x: x.upper()
+    if connection.capabilities.uses_case_insensitive_names:
+        converter = lambda x:x.upper()
     else:
         converter = lambda x: x
     return set([m for m in all_models if converter(m._meta.db_table) in map(converter, table_list)])
@@ -152 +152 @@
 
     Returns list_of_sql, pending_references_dict
     """
-    from django.db import backend, models
+    from django.db import connection, models
+
+    ops, capabilities = connection.ops, connection.capabilities
+    quote_name = ops.quote_name
 
     opts = model._meta
     final_output = []
@@ -166 +169 @@
             # database columns in this table.
             continue
         # Make the definition (e.g. 'foo VARCHAR(30)') for this field.
-        field_output = [style.SQL_FIELD(backend.quote_name(f.column)),
+        field_output = [style.SQL_FIELD(quote_name(f.column)),
             style.SQL_COLTYPE(col_type)]
         field_output.append(style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or '')))
-        if f.unique and (not f.primary_key or backend.allows_unique_and_pk):
+        if f.unique and (not f.primary_key or capabilities.allows_unique_and_pk):
             field_output.append(style.SQL_KEYWORD('UNIQUE'))
         if f.primary_key:
             field_output.append(style.SQL_KEYWORD('PRIMARY KEY'))
-        if tablespace and backend.supports_tablespaces and (f.unique or f.primary_key) and backend.autoindexes_primary_keys:
+        if tablespace and capabilities.supports_tablespaces and (f.unique or f.primary_key) \
+            and capabilities.autoindexes_primary_keys:
             # We must specify the index tablespace inline, because we
             # won't be generating a CREATE INDEX statement for this field.
-            field_output.append(backend.get_tablespace_sql(tablespace, inline=True))
+            field_output.append(ops.get_tablespace_sql(tablespace, inline=True))
         if f.rel:
             if f.rel.to in known_models:
                 field_output.append(style.SQL_KEYWORD('REFERENCES') + ' ' + \
-                    style.SQL_TABLE(backend.quote_name(f.rel.to._meta.db_table)) + ' (' + \
-                    style.SQL_FIELD(backend.quote_name(f.rel.to._meta.get_field(f.rel.field_name).column)) + ')' +
-                    backend.get_deferrable_sql()
+                    style.SQL_TABLE(quote_name(f.rel.to._meta.db_table)) + ' (' + \
+                    style.SQL_FIELD(quote_name(f.rel.to._meta.get_field(f.rel.field_name).column)) + ')' +
+                    ops.get_deferrable_sql()
                 )
             else:
                 # We haven't yet created the table to which this field
@@ -190 +194 @@
                 pr = pending_references.setdefault(f.rel.to, []).append((model, f))
         table_output.append(' '.join(field_output))
     if opts.order_with_respect_to:
-        table_output.append(style.SQL_FIELD(backend.quote_name('_order')) + ' ' + \
+        table_output.append(style.SQL_FIELD(quote_name('_order')) + ' ' + \
             style.SQL_COLTYPE(models.IntegerField().db_type()) + ' ' + \
             style.SQL_KEYWORD('NULL'))
     for field_constraints in opts.unique_together:
         table_output.append(style.SQL_KEYWORD('UNIQUE') + ' (%s)' % \
-            ", ".join([backend.quote_name(style.SQL_FIELD(opts.get_field(f).column)) for f in field_constraints]))
+            ", ".join([quote_name(style.SQL_FIELD(opts.get_field(f).column)) for f in field_constraints]))
 
-    full_statement = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + style.SQL_TABLE(backend.quote_name(opts.db_table)) + ' (']
+    full_statement = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + style.SQL_TABLE(quote_name(opts.db_table)) + ' (']
     for i, line in enumerate(table_output): # Combine and add commas.
         full_statement.append('    %s%s' % (line, i < len(table_output)-1 and ',' or ''))
     full_statement.append(')')
-    if opts.db_tablespace and backend.supports_tablespaces:
-        full_statement.append(backend.get_tablespace_sql(opts.db_tablespace))
+    if opts.db_tablespace and capabilities.supports_tablespaces:
+        full_statement.append(ops.get_tablespace_sql(opts.db_tablespace))
     full_statement.append(';')
     final_output.append('\n'.join(full_statement))
 
-    if opts.has_auto_field and hasattr(backend, 'get_autoinc_sql'):
+    if opts.has_auto_field:
         # Add any extra SQL needed to support auto-incrementing primary keys
-        autoinc_sql = backend.get_autoinc_sql(opts.db_table)
+        autoinc_sql = ops.get_autoinc_sql(opts.db_table)
         if autoinc_sql:
             for stmt in autoinc_sql:
                 final_output.append(stmt)
@@ -219 +223 @@
     """
     Get any ALTER TABLE statements to add constraints after the fact.
     """
-    from django.db import backend
+    from django.db import connection
     from django.db.backends.util import truncate_name
 
+    ops = connection.ops
     final_output = []
-    if backend.supports_constraints:
+    if connection.capabilities.supports_constraints:
         opts = model._meta
         if model in pending_references:
             for rel_class, f in pending_references[model]:
@@ -236 +241 @@
                 # So we are careful with character usage here.
                 r_name = '%s_refs_%s_%x' % (r_col, col, abs(hash((r_table, table))))
                 final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)%s;' % \
-                    (backend.quote_name(r_table), truncate_name(r_name, backend.get_max_name_length()),
-                    backend.quote_name(r_col), backend.quote_name(table), backend.quote_name(col),
-                    backend.get_deferrable_sql()))
+                    (ops.quote_name(r_table), truncate_name(r_name, ops.get_max_name_length()),
+                    ops.quote_name(r_col), ops.quote_name(table), ops.quote_name(col),
+                    ops.get_deferrable_sql()))
             del pending_references[model]
     return final_output
 
 def _get_many_to_many_sql_for_model(model):
-    from django.db import backend, models
+    from django.db import connection, models
     from django.contrib.contenttypes import generic
 
+    ops, capabilities = connection.ops, connection.capabilities
+    quote_name = ops.quote_name
     opts = model._meta
     final_output = []
     for f in opts.many_to_many:
         if not isinstance(f.rel, generic.GenericRel):
             tablespace = f.db_tablespace or opts.db_tablespace
-            if tablespace and backend.supports_tablespaces and backend.autoindexes_primary_keys:
-                tablespace_sql = ' ' + backend.get_tablespace_sql(tablespace, inline=True)
+            if tablespace and capabilities.supports_tablespaces and capabilities.autoindexes_primary_keys:
+                tablespace_sql = ' ' + ops.get_tablespace_sql(tablespace, inline=True)
             else:
                 tablespace_sql = ''
             table_output = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + \
-                style.SQL_TABLE(backend.quote_name(f.m2m_db_table())) + ' (']
+                style.SQL_TABLE(quote_name(f.m2m_db_table())) + ' (']
             table_output.append('    %s %s %s%s,' % \
-                (style.SQL_FIELD(backend.quote_name('id')),
+                (style.SQL_FIELD(quote_name('id')),
                 style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type()),
                 style.SQL_KEYWORD('NOT NULL PRIMARY KEY'),
                 tablespace_sql))
             table_output.append('    %s %s %s %s (%s)%s,' % \
-                (style.SQL_FIELD(backend.quote_name(f.m2m_column_name())),
+                (style.SQL_FIELD(quote_name(f.m2m_column_name())),
                 style.SQL_COLTYPE(models.ForeignKey(model).db_type()),
                 style.SQL_KEYWORD('NOT NULL REFERENCES'),
-                style.SQL_TABLE(backend.quote_name(opts.db_table)),
-                style.SQL_FIELD(backend.quote_name(opts.pk.column)),
-                backend.get_deferrable_sql()))
+                style.SQL_TABLE(quote_name(opts.db_table)),
+                style.SQL_FIELD(quote_name(opts.pk.column)),
+                ops.get_deferrable_sql()))
             table_output.append('    %s %s %s %s (%s)%s,' % \
-                (style.SQL_FIELD(backend.quote_name(f.m2m_reverse_name())),
+                (style.SQL_FIELD(quote_name(f.m2m_reverse_name())),
                 style.SQL_COLTYPE(models.ForeignKey(f.rel.to).db_type()),
                 style.SQL_KEYWORD('NOT NULL REFERENCES'),
-                style.SQL_TABLE(backend.quote_name(f.rel.to._meta.db_table)),
-                style.SQL_FIELD(backend.quote_name(f.rel.to._meta.pk.column)),
-                backend.get_deferrable_sql()))
+                style.SQL_TABLE(quote_name(f.rel.to._meta.db_table)),
+                style.SQL_FIELD(quote_name(f.rel.to._meta.pk.column)),
+                ops.get_deferrable_sql()))
             table_output.append('    %s (%s, %s)%s' % \
                 (style.SQL_KEYWORD('UNIQUE'),
-                style.SQL_FIELD(backend.quote_name(f.m2m_column_name())),
-                style.SQL_FIELD(backend.quote_name(f.m2m_reverse_name())),
+                style.SQL_FIELD(quote_name(f.m2m_column_name())),
+                style.SQL_FIELD(quote_name(f.m2m_reverse_name())),
                 tablespace_sql))
             table_output.append(')')
-            if opts.db_tablespace and backend.supports_tablespaces:
+            if opts.db_tablespace and capabilities.supports_tablespaces:
                 # f.db_tablespace is only for indices, so ignore its value here.
-                table_output.append(backend.get_tablespace_sql(opts.db_tablespace))
+                table_output.append(ops.get_tablespace_sql(opts.db_tablespace))
             table_output.append(';')
             final_output.append('\n'.join(table_output))
 
             # Add any extra SQL needed to support auto-incrementing PKs
-            autoinc_sql = backend.get_autoinc_sql(f.m2m_db_table())
+            autoinc_sql = ops.get_autoinc_sql(f.m2m_db_table())
             if autoinc_sql:
                 for stmt in autoinc_sql:
                     final_output.append(stmt)
@@ -298 +305 @@
 
 def get_sql_delete(app):
     "Returns a list of the DROP TABLE SQL statements for the given app."
-    from django.db import backend, connection, models, get_introspection_module
+    from django.db import connection, models, get_introspection_module
     from django.db.backends.util import truncate_name
     introspection = get_introspection_module()
 
+    ops, capabilities = connection.ops, connections.capabilities
+    quote_name = ops.quote_name
+
     # This should work even if a connection isn't available
     try:
         cursor = connection.cursor()
@@ -313 +323 @@
         table_names = introspection.get_table_list(cursor)
     else:
         table_names = []
-    if backend.uses_case_insensitive_names:
+    if capabilities.uses_case_insensitive_names:
         table_name_converter = str.upper
     else:
         table_name_converter = lambda x: x
@@ -339 +349 @@
         if cursor and table_name_converter(model._meta.db_table) in table_names:
             # Drop the table now
             output.append('%s %s;' % (style.SQL_KEYWORD('DROP TABLE'),
-                style.SQL_TABLE(backend.quote_name(model._meta.db_table))))
-            if backend.supports_constraints and model in references_to_delete:
+                style.SQL_TABLE(quote_name(model._meta.db_table))))
+            if capabilities.supports_constraints and model in references_to_delete:
                 for rel_class, f in references_to_delete[model]:
                     table = rel_class._meta.db_table
                     col = f.column
@@ -349 +359 @@
                     r_name = '%s_refs_%s_%x' % (col, r_col, abs(hash((table, r_table))))
                     output.append('%s %s %s %s;' % \
                         (style.SQL_KEYWORD('ALTER TABLE'),
-                        style.SQL_TABLE(backend.quote_name(table)),
-                        style.SQL_KEYWORD(backend.get_drop_foreignkey_sql()),
-                        style.SQL_FIELD(truncate_name(r_name, backend.get_max_name_length()))))
+                        style.SQL_TABLE(quote_name(table)),
+                        style.SQL_KEYWORD(ops.get_drop_foreignkey_sql()),
+                        style.SQL_FIELD(truncate_name(r_name, ops.get_max_name_length()))))
                 del references_to_delete[model]
-            if model._meta.has_auto_field and hasattr(backend, 'get_drop_sequence'):
-                output.append(backend.get_drop_sequence(model._meta.db_table))
+            if model._meta.has_auto_field and hasattr(ops, 'get_drop_sequence'):
+                output.append(ops.get_drop_sequence(model._meta.db_table))
 
     # Output DROP TABLE statements for many-to-many tables.
     for model in app_models:
@@ -362 +372 @@
         for f in opts.many_to_many:
             if cursor and table_name_converter(f.m2m_db_table()) in table_names:
                 output.append("%s %s;" % (style.SQL_KEYWORD('DROP TABLE'),
-                    style.SQL_TABLE(backend.quote_name(f.m2m_db_table()))))
-                if hasattr(backend, 'get_drop_sequence'):
-                    output.append(backend.get_drop_sequence("%s_%s" % (model._meta.db_table, f.column)))
+                    style.SQL_TABLE(quote_name(f.m2m_db_table()))))
+                if hasattr(ops, 'get_drop_sequence'):
+                    output.append(ops.get_drop_sequence("%s_%s" % (model._meta.db_table, f.column)))
 
 
     app_label = app_models[0]._meta.app_label
@@ -387 +397 @@
 
 def get_sql_flush():
     "Returns a list of the SQL statements used to flush the database"
-    from django.db import backend
-    statements = backend.get_sql_flush(style, _get_table_list(), _get_sequence_list())
-    return statements
+    from django.db import connection
+    return connection.ops.get_sql_flush(style, _get_table_list(), _get_sequence_list())
 get_sql_flush.help_doc = "Returns a list of the SQL statements required to return all tables in the database to the state they were in just after they were installed."
 get_sql_flush.args = ''
 
@@ -443 +452 @@
 
 def get_sql_sequence_reset(app):
     "Returns a list of the SQL statements to reset sequences for the given app."
-    from django.db import backend, models
-    return backend.get_sql_sequence_reset(style, models.get_models(app))
+    from django.db import connection, models
+    return connection.ops.get_sql_sequence_reset(style, models.get_models(app))
 get_sql_sequence_reset.help_doc = "Prints the SQL statements for resetting sequences for the given app name(s)."
 get_sql_sequence_reset.args = APP_ARGS
 
@@ -460 +469 @@
 
 def get_sql_indexes_for_model(model):
     "Returns the CREATE INDEX SQL statements for a single model"
-    from django.db import backend
+    from django.db import connection
     output = []
 
+    ops, capabilities = connection.ops, connection.capabilities
+
     for f in model._meta.fields:
-        if f.db_index and not ((f.primary_key or f.unique) and backend.autoindexes_primary_keys):
+        if f.db_index and not ((f.primary_key or f.unique) and capabilities.autoindexes_primary_keys):
             unique = f.unique and 'UNIQUE ' or ''
             tablespace = f.db_tablespace or model._meta.db_tablespace
-            if tablespace and backend.supports_tablespaces:
-                tablespace_sql = ' ' + backend.get_tablespace_sql(tablespace)
+            if tablespace and capabilities.supports_tablespaces:
+                tablespace_sql = ' ' + ops.get_tablespace_sql(tablespace)
             else:
                 tablespace_sql = ''
             output.append(
                 style.SQL_KEYWORD('CREATE %sINDEX' % unique) + ' ' + \
-                style.SQL_TABLE(backend.quote_name('%s_%s' % (model._meta.db_table, f.column))) + ' ' + \
+                style.SQL_TABLE(ops.quote_name('%s_%s' % (model._meta.db_table, f.column))) + ' ' + \
                 style.SQL_KEYWORD('ON') + ' ' + \
-                style.SQL_TABLE(backend.quote_name(model._meta.db_table)) + ' ' + \
-                "(%s)" % style.SQL_FIELD(backend.quote_name(f.column)) + \
+                style.SQL_TABLE(ops.quote_name(model._meta.db_table)) + ' ' + \
+                "(%s)" % style.SQL_FIELD(ops.quote_name(f.column)) + \
                 "%s;" % tablespace_sql
             )
     return output
@@ -501 +512 @@
 
 def syncdb(verbosity=1, interactive=True):
     "Creates the database tables for all apps in INSTALLED_APPS whose tables haven't already been created."
-    from django.db import backend, connection, transaction, models
+    from django.db import connection, transaction, models
     from django.conf import settings
 
     disable_termcolors()
@@ -522 +533 @@
     # Get a list of all existing database tables,
     # so we know what needs to be added.
     table_list = _get_table_list()
-    if backend.uses_case_insensitive_names:
+    if connection.capabilities.uses_case_insensitive_names:
         table_name_converter = str.upper
     else:
         table_name_converter = lambda x: x
@@ -1249 +1260 @@
 
 def createcachetable(tablename):
     "Creates the table needed to use the SQL cache backend"
-    from django.db import backend, connection, transaction, models
+    from django.db import connection, transaction, models
+    quote_name = connection.ops.quote_name
     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),
@@ -1259 +1271 @@
     table_output = []
     index_output = []
     for f in fields:
-        field_output = [backend.quote_name(f.name), f.db_type()]
+        field_output = [quote_name(f.name), f.db_type()]
         field_output.append("%sNULL" % (not f.null and "NOT " or ""))
         if f.unique:
             field_output.append("UNIQUE")
@@ -1268 +1280 @@
         if f.db_index:
             unique = f.unique and "UNIQUE " or ""
             index_output.append("CREATE %sINDEX %s_%s ON %s (%s);" % \
-                (unique, tablename, f.name, backend.quote_name(tablename),
-                backend.quote_name(f.name)))
+                (unique, tablename, f.name, quote_name(tablename),
+                quote_name(f.name)))
         table_output.append(" ".join(field_output))
-    full_statement = ["CREATE TABLE %s (" % backend.quote_name(tablename)]
+    full_statement = ["CREATE TABLE %s (" % quote_name(tablename)]
     for i, line in enumerate(table_output):
         full_statement.append('    %s%s' % (line, i < len(table_output)-1 and ',' or ''))
     full_statement.append(');')
@@ -1361 +1373 @@
     "Installs the provided fixture file(s) as data in the database."
     from django.db.models import get_apps
     from django.core import serializers
-    from django.db import connection, transaction, backend
+    from django.db import connection, transaction
     from django.conf import settings
     import sys
 
@@ -1450 +1462 @@
                             (format, fixture_name, humanize(fixture_dir))
 
     if count[0] > 0:
-        sequence_sql = backend.get_sql_sequence_reset(style, models)
+        sequence_sql = connection.ops.get_sql_sequence_reset(style, models)
         if sequence_sql:
             if verbosity > 1:
                 print "Resetting sequences"
@@ -1679 +1691 @@
         if not mod_list:
             parser.print_usage_and_exit()
         if action not in NO_SQL_TRANSACTION:
-            from django.db import backend
-            if backend.get_start_transaction_sql():
-                print style.SQL_KEYWORD(backend.get_start_transaction_sql())
+            from django.db import connection
+            if connection.ops.get_start_transaction_sql():
+                print style.SQL_KEYWORD(connections.ops.get_start_transaction_sql())
         for mod in mod_list:
             if action == 'reset':
                 output = action_mapping[action](mod, options.interactive)

django/db/__init__.py

@@ -8 +8 @@
     settings.DATABASE_ENGINE = 'dummy'
 
 try:
-    backend = __import__('django.db.backends.%s.base' % settings.DATABASE_ENGINE, {}, {}, [''])
+    backend = __import__('django.db.backends.%s.base' % settings.DATABASE_ENGINE, {}, {}, ['']).DatabaseWrapper
 except ImportError, e:
     # The database backend wasn't found. Display a helpful error message
     # listing all possible database backends.
@@ -16 +16 @@
     import os
     backend_dir = os.path.join(__path__[0], 'backends')
     available_backends = [f for f in os.listdir(backend_dir) if not f.startswith('_') and not f.startswith('.') and not f.endswith('.py') and not f.endswith('.pyc')]
-    available_backends.sort()
-    if settings.DATABASE_ENGINE not in available_backends:
-        raise ImproperlyConfigured, "%r isn't an available database backend. Available options are: %s" % \
+    if settings.DATABASE_ENGINE in available_backends:
+        raise # If there's some other error, this must be an error in Django itself.
+    
+    try:
+        backend = __import__(settings.DATABASE_ENGINE, {}, {}, [''])
+    except ImportError, e:
+        available_backends.sort()
+        raise ImproperlyConfigured, "%r isn't an available database backend. Available default options are: %s" % \
             (settings.DATABASE_ENGINE, ", ".join(map(repr, available_backends)))
-    else:
-        raise # If there's some other error, this must be an error in Django itself.
-
-get_introspection_module = lambda: __import__('django.db.backends.%s.introspection' % settings.DATABASE_ENGINE, {}, {}, [''])
-get_creation_module = lambda: __import__('django.db.backends.%s.creation' % settings.DATABASE_ENGINE, {}, {}, [''])
-runshell = lambda: __import__('django.db.backends.%s.client' % settings.DATABASE_ENGINE, {}, {}, ['']).runshell()
-
-connection = backend.DatabaseWrapper(**settings.DATABASE_OPTIONS)
-DatabaseError = backend.DatabaseError
-IntegrityError = backend.IntegrityError
+
+connection = backend(**settings.DATABASE_OPTIONS)
+DatabaseError = connection.DatabaseError
+IntegrityError = connection.IntegrityError
+get_introspection_module = lambda: connection.introspection
+get_creation_module = lambda: connection.creation
+runshell = lambda: connection.runshell()
 
 # Register an event that closes the database connection
 # when a Django request is finished.

django/db/backends/__init__.py

@@ +1 @@
+from django.utils.functional import curry
+from django.db.backends import util
+
+try:
+    # Only exists in Python 2.4+
+    from threading import local
+except ImportError:
+    # Import copy of _thread_local.py from Python 2.4
+    from django.utils._threading_local import local
+
+
+class BaseDatabaseWrapper(local):
+
+    """base class for defining a new db connection wrapper
+    
+    Derivatives should add a _cursor method, introspection property,
+    creation property, and a runshell method
+    """
+
+    ops = capabilities = orm_map = DatabaseError = IntegrityError = None
+
+    def __init__(self, **kwargs):
+        self.connection = None
+        self.queries = []
+        self.options = kwargs
+
+    def _commit(self):
+        if self.connection is not None:
+            return self.connection.commit()
+
+    def _rollback(self):
+        if self.connection is not None:
+            return self.connection.rollback()
+
+    def close(self):
+        if self.connection is not None:
+            self.connection.close()
+            self.connection = None
+
+    def cursor(self):
+        from django.conf import settings
+        cursor = self._cursor(settings)
+        if settings.DEBUG:
+            return self.make_debug_cursor(cursor)
+        return cursor
+
+    def make_debug_cursor(self, cursor):
+        from django.db.backends import util
+        return util.CursorDebugWrapper(cursor, self)
+
+    def introspection(self):
+        raise NotImplemented(self, 'introspection')
+
+    def creation(self):
+        raise NotImplemented(self, 'creation')
+
+    introspection, creation = map(property, (introspection, creation))
+
+    def runshell(self):
+        raise NotImplemented(self, 'runshell')
+
+
+class BackendCapabilities(object):
+
+    defaults = dict(allows_group_by_ordinal=True, allows_unique_and_pk=True,
+        autoindexes_primary_keys=True, needs_datetime_string_cast=True,
+        needs_upper_for_iops=False, supports_constraints=True,
+        supports_tablespaces=False, uses_case_insensitive_names=False)
+
+    def __init__(self, **kwargs):
+        self.__dict__.update(self.defaults)
+        self.__dict__.update(kwargs)
+
+
+def _throw_unsupported(method, self, *args, **kwargs):
+    raise NotImplemented(self, method)
+
+class BackendOps(object):
+
+    required_methods = ["%s_sql" % x for x in
+        ('autoinc', 'date_extract', 'date_trunc', 'datetime_cast',
+        'deferrable', 'drop_foreignkey', 'fulltext_search', 'limit_offset',
+        'random_function', 'start_transaction', 'tablespace')]
+    required_methods += ['last_insert_id', 'max_name_length',
+        'pk_default_value', 'sequence_name', 'get_trigger_name']
+    required_methods = ["get_%s" % x for x in required_methods]
+    required_methods = tuple(required_methods)
+    # listcomps leak variables; we don't need 'x' in the namespace
+    targets = [curry(_throw_unsupported, x) for x in required_methods]
+    locals().update(zip(required_methods, targets))
+    for x in ('sequence_reset', 'flush'):
+        x = 'get_sql_%s' % x
+        required_methods += (x,)
+        locals()[x] = curry(_throw_unsupported, x)
+
+    del x, targets
+
+    def quote_name(name):
+        if name.startswith(self.start_quote) and name.endswith(self.end_quote):
+            return name # already quoted.
+        return '%s%s%s' % (self.start_quote, name, self.end_quote)
+
+    quote_name = staticmethod(quote_name)
+
+    dictfetchone = staticmethod(util.dictfetchone)
+    dictfetchmany = staticmethod(util.dictfetchmany)
+    dictfetchall = staticmethod(util.dictfetchall)
+
+    # list of methods to pull from old style db layout
+    methods = required_methods + ('get_drop_sequence', 'quote_name',
+       'dictfetchone', 'dictfetchmany', 'dictfetchall',)
+
+    def __init__(self, quote_chars='""'):
+        self.start_quote, self.end_quote = quote_chars[0:2]
+
+
+class OldLayoutBaseDatabaseWrapper(BaseDatabaseWrapper):
+
+    """
+    Convenience class used for mapping <=0.96 style backend
+    layouts into current form.
+    
+    Generally speaking, you want BaseDatabaseWrapper, not this class.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(OldLayoutBaseDatabaseWrapper, self).__init__(*args, **kwargs)
+        mod = __import__(self.__class__.__module__, {}, {}, [''])
+        d = BackendCapabilities.defaults.copy()
+        for k, v in d.iteritems():
+            if hasattr(mod, k):
+                d[k] = getattr(mod, k)
+        # generate a few mappings via inspection of the module.
+        self.capabilities = BackendCapabilities(**d)
+        self.orm_map = mod.OPERATOR_MAPPING.copy()
+        self.ops = ops = BackendOps()
+        for op in ops.methods:
+            if hasattr(mod, op):
+                setattr(ops, op, getattr(mod, op))
+        self.DatabaseError = mod.DatabaseError
+        self.IntegrityError = mod.IntegrityError
+
+
+    def _base_namespace(self):
+        # when py2.4 is the default, convert this to a rsplit limit=1
+        return '.'.join(self.__class__.__module__.split(".")[:-1])
+
+    def introspection(self):
+        return __import__(self._base_namespace + '.introspection', {}, {}, [''])
+
+    def creation(self):
+        return __import__(self._base_namespace + '.creation', {}, {}, [''])
+
+    def runshell(self):
+        return __import__(self._base_namespace + '.client', {}, {}, ['']).runshell
+
+    _base_namespace, introspection, creation, runshell = map(property, 
+        (_base_namespace, introspection, creation, runshell))

django/db/backends/ado_mssql/base.py

@@ -48 +48 @@
     return res
 Database.convertVariantToPython = variantToPython
 
-try:
-    # Only exists in Python 2.4+
-    from threading import local
-except ImportError:
-    # Import copy of _thread_local.py from Python 2.4
-    from django.utils._threading_local import local
-
-class DatabaseWrapper(local):
-    def __init__(self, **kwargs):
-        self.connection = None
-        self.queries = []
-
-    def cursor(self):
-        from django.conf import settings
+from django.db.backends import OldLayoutBaseDatabaseWrapper
+
+class DatabaseWrapper(OldLayoutBaseDatabaseWrapper):
+
+    def _cursor(self, settings):
         if self.connection is None:
             if settings.DATABASE_NAME == '' or settings.DATABASE_USER == '':
                 from django.core.exceptions import ImproperlyConfigured
@@ -71 +62 @@
             # TODO: Handle DATABASE_PORT.
             conn_string = "PROVIDER=SQLOLEDB;DATA SOURCE=%s;UID=%s;PWD=%s;DATABASE=%s" % (settings.DATABASE_HOST, settings.DATABASE_USER, settings.DATABASE_PASSWORD, settings.DATABASE_NAME)
             self.connection = Database.connect(conn_string)
-        cursor = self.connection.cursor()
-        if settings.DEBUG:
-            return util.CursorDebugWrapper(cursor, self)
-        return cursor
-
-    def _commit(self):
-        if self.connection is not None:
-            return self.connection.commit()
-
-    def _rollback(self):
-        if self.connection is not None:
-            return self.connection.rollback()
-
-    def close(self):
-        if self.connection is not None:
-            self.connection.close()
-            self.connection = None
+        return self.connection.cursor()
+
 
 allows_group_by_ordinal = True
 allows_unique_and_pk = True

django/db/backends/mysql/base.py

@@ -53 +53 @@
 # standard util.CursorDebugWrapper can be used. Also, using sql_mode
 # TRADITIONAL will automatically cause most warnings to be treated as errors.
 
-try:
-    # Only exists in Python 2.4+
-    from threading import local
-except ImportError:
-    # Import copy of _thread_local.py from Python 2.4
-    from django.utils._threading_local import local
-
-class DatabaseWrapper(local):
+
+from django.db.backends import OldLayoutBaseDatabaseWrapper
+
+class DatabaseWrapper(OldLayoutBaseDatabaseWrapper):
+
+    DatabaseError = Database.DatabaseError
+    IntegrityError = Database.IntegrityError
+
     def __init__(self, **kwargs):
-        self.connection = None
-        self.queries = []
+        super(DatabaseWrapper, self).__init__(**kwargs)
         self.server_version = None
-        self.options = kwargs
 
     def _valid_connection(self):
         if self.connection is not None:
@@ -77 +75 @@
                 self.connection = None
         return False
 
-    def cursor(self):
-        from django.conf import settings
+    def _cursor(self, settings):
         from warnings import filterwarnings
         if not self._valid_connection():
             kwargs = {
@@ -100 +97 @@
                 kwargs['port'] = int(settings.DATABASE_PORT)
             kwargs.update(self.options)
             self.connection = Database.connect(**kwargs)
-            cursor = self.connection.cursor()
-        else:
-            cursor = self.connection.cursor()
+        cursor = self.connection.cursor()
         if settings.DEBUG:
             filterwarnings("error", category=Database.Warning)
-            return util.CursorDebugWrapper(cursor, self)
         return cursor
 
-    def _commit(self):
-        if self.connection is not None:
-            self.connection.commit()
-
     def _rollback(self):
-        if self.connection is not None:
-            try:
-                self.connection.rollback()
-            except Database.NotSupportedError:
-                pass
-
-    def close(self):
-        if self.connection is not None:
-            self.connection.close()
-            self.connection = None
+        try:
+            OldLayoutBaseDatabaseWrapper._rollback(self)
+        except Database.NotSupportedError:
+            pass
 
     def get_server_version(self):
         if not self.server_version:

django/db/backends/mysql_old/base.py

@@ -63 +63 @@
         else:
             return getattr(self.cursor, attr)
 
-try:
-    # Only exists in Python 2.4+
-    from threading import local
-except ImportError:
-    # Import copy of _thread_local.py from Python 2.4
-    from django.utils._threading_local import local
+from django.db.backends import OldLayoutBaseDatabaseWrapper
 
-class DatabaseWrapper(local):
+class DatabaseWrapper(OldLayoutBaseDatabaseWrapper):
     def __init__(self, **kwargs):
-        self.connection = None
-        self.queries = []
+        super(DatabaseWrapper, self).__init__(**kwargs)
         self.server_version = None
-        self.options = kwargs
 
     def _valid_connection(self):
         if self.connection is not None:
@@ -87 +80 @@
                 self.connection = None
         return False
 
-    def cursor(self):
-        from django.conf import settings
+    def _cursor(self, settings):
         if not self._valid_connection():
             kwargs = {
                 # Note: use_unicode intentonally not set to work around some
@@ -119 +111 @@
                     self.connection.set_character_set('utf8')
         else:
             cursor = self.connection.cursor()
-        if settings.DEBUG:
-            return util.CursorDebugWrapper(MysqlDebugWrapper(cursor), self)
+        
         return cursor
 
-    def _commit(self):
-        if self.connection is not None:
-            self.connection.commit()
+    def make_debug_cursor(self, cursor):
+        return OldLayoutBaseDatabaseWrapper.make_debug_cursor(self, MysqlDebugWrapper(cursor))
 
     def _rollback(self):
-        if self.connection is not None:
-            try:
-                self.connection.rollback()
-            except Database.NotSupportedError:
-                pass
-
-    def close(self):
-        if self.connection is not None:
-            self.connection.close()
-            self.connection = None
+        try:
+            OldLayoutBaseDatabaseWrapper._rollback(self)
+        except Database.NotSupportedError:
+            pass
 
     def get_server_version(self):
         if not self.server_version:

django/db/backends/oracle/base.py

@@ -23 +23 @@
 DatabaseError = Database.Error
 IntegrityError = Database.IntegrityError
 
-try:
-    # Only exists in Python 2.4+
-    from threading import local
-except ImportError:
-    # Import copy of _thread_local.py from Python 2.4
-    from django.utils._threading_local import local
+from django.db.backends import OldLayoutBaseDatabaseWrapper
 
-class DatabaseWrapper(local):
-    def __init__(self, **kwargs):
-        self.connection = None
-        self.queries = []
-        self.options = kwargs
+class DatabaseWrapper(OldLayoutBaseDatabaseWrapper):
 
     def _valid_connection(self):
         return self.connection is not None
 
-    def cursor(self):
+    def _cursor(self, settings):
         if not self._valid_connection():
             if len(settings.DATABASE_HOST.strip()) == 0:
                 settings.DATABASE_HOST = 'localhost'
@@ -55 +46 @@
         # Set oracle date to ansi date format.
         cursor.execute("ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD'")
         cursor.execute("ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'")
-        if settings.DEBUG:
-            return util.CursorDebugWrapper(cursor, self)
         return cursor
 
-    def _commit(self):
-        if self.connection is not None:
-            return self.connection.commit()
-
-    def _rollback(self):
-        if self.connection is not None:
-            return self.connection.rollback()
-
-    def close(self):
-        if self.connection is not None:
-            self.connection.close()
-            self.connection = None
 
 allows_group_by_ordinal = False
 allows_unique_and_pk = False        # Suppress UNIQUE/PK for Oracle (ORA-02259)

django/db/backends/postgresql/base.py

@@ -15 +15 @@
 DatabaseError = Database.DatabaseError
 IntegrityError = Database.IntegrityError
 
-try:
-    # Only exists in Python 2.4+
-    from threading import local
-except ImportError:
-    # Import copy of _thread_local.py from Python 2.4
-    from django.utils._threading_local import local
+from django.db.backends import OldLayoutBaseDatabaseWrapper
 
 class UnicodeCursorWrapper(object):
     """
@@ -64 +59 @@
 
 postgres_version = None
 
-class DatabaseWrapper(local):
-    def __init__(self, **kwargs):
-        self.connection = None
-        self.queries = []
-        self.options = kwargs
+class DatabaseWrapper(OldLayoutBaseDatabaseWrapper):
 
-    def cursor(self):
-        from django.conf import settings
+    def _cursor(self, settings):
         set_tz = False
         if self.connection is None:
             set_tz = True
@@ -98 +88 @@
         if not postgres_version:
             cursor.execute("SELECT version()")
             postgres_version = [int(val) for val in cursor.fetchone()[0].split()[1].split('.')]
-        if settings.DEBUG:
-            return util.CursorDebugWrapper(cursor, self)
         return cursor
 
-    def _commit(self):
-        if self.connection is not None:
-            return self.connection.commit()
-
-    def _rollback(self):
-        if self.connection is not None:
-            return self.connection.rollback()
-
-    def close(self):
-        if self.connection is not None:
-            self.connection.close()
-            self.connection = None
-
 allows_group_by_ordinal = True
 allows_unique_and_pk = True
 autoindexes_primary_keys = True

django/db/backends/postgresql_psycopg2/base.py

@@ -5 +5 @@
 """
 
 from django.db.backends import util
+from django.db.backends import OldLayoutBaseDatabaseWrapper
+
 try:
     import psycopg2 as Database
     import psycopg2.extensions
@@ -15 +17 @@
 DatabaseError = Database.DatabaseError
 IntegrityError = Database.IntegrityError
 
-try:
-    # Only exists in Python 2.4+
-    from threading import local
-except ImportError:
-    # Import copy of _thread_local.py from Python 2.4
-    from django.utils._threading_local import local
-
 psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
 
 postgres_version = None
 
-class DatabaseWrapper(local):
-    def __init__(self, **kwargs):
-        self.connection = None
-        self.queries = []
-        self.options = kwargs
+class DatabaseWrapper(OldLayoutBaseDatabaseWrapper):
 
-    def cursor(self):
-        from django.conf import settings
+    def _cursor(self, settings):
         set_tz = False
         if self.connection is None:
             set_tz = True
@@ -60 +50 @@
         if not postgres_version:
             cursor.execute("SELECT version()")
             postgres_version = [int(val) for val in cursor.fetchone()[0].split()[1].split('.')]
-        if settings.DEBUG:
-            return util.CursorDebugWrapper(cursor, self)
         return cursor
 
-    def _commit(self):
-        if self.connection is not None:
-            return self.connection.commit()
-
-    def _rollback(self):
-        if self.connection is not None:
-            return self.connection.rollback()
-
-    def close(self):
-        if self.connection is not None:
-            self.connection.close()
-            self.connection = None
 
 allows_group_by_ordinal = True
 allows_unique_and_pk = True

django/db/backends/sqlite3/base.py

@@ -34 +34 @@
 Database.register_converter("decimal", util.typecast_decimal)
 Database.register_adapter(decimal.Decimal, util.rev_typecast_decimal)
 
-try:
-    # Only exists in Python 2.4+
-    from threading import local
-except ImportError:
-    # Import copy of _thread_local.py from Python 2.4
-    from django.utils._threading_local import local
-
-class DatabaseWrapper(local):
-    def __init__(self, **kwargs):
-        self.connection = None
-        self.queries = []
-        self.options = kwargs
-
-    def cursor(self):
-        from django.conf import settings
+from django.db.backends import OldLayoutBaseDatabaseWrapper
+
+class DatabaseWrapper(OldLayoutBaseDatabaseWrapper):
+
+    def _cursor(self, settings):
         if self.connection is None:
             kwargs = {
                 'database': settings.DATABASE_NAME,
@@ -60 +50 @@
             self.connection.create_function("django_extract", 2, _sqlite_extract)
             self.connection.create_function("django_date_trunc", 2, _sqlite_date_trunc)
             self.connection.create_function("regexp", 2, _sqlite_regexp)
-        cursor = self.connection.cursor(factory=SQLiteCursorWrapper)
-        if settings.DEBUG:
-            return util.CursorDebugWrapper(cursor, self)
-        else:
-            return cursor
-
-    def _commit(self):
-        if self.connection is not None:
-            self.connection.commit()
-
-    def _rollback(self):
-        if self.connection is not None:
-            self.connection.rollback()
+        return self.connection.cursor(factory=SQLiteCursorWrapper)
 
     def close(self):
         from django.conf import settings
         # If database is in memory, closing the connection destroys the
         # database.  To prevent accidental data loss, ignore close requests on
         # an in-memory db.
-        if self.connection is not None and settings.DATABASE_NAME != ":memory:":
-            self.connection.close()
-            self.connection = None
+        if settings.DATABASE_NAME != ':memory:':
+            OldLayoutBaseDatabaseWrapper.close(self)
+
 
 class SQLiteCursorWrapper(Database.Cursor):
     """

django/db/models/base.py

@@ -6 +6 @@
 from django.db.models.fields.related import OneToOneRel, ManyToOneRel
 from django.db.models.query import delete_objects
 from django.db.models.options import Options, AdminOptions
-from django.db import connection, backend, transaction
+from django.db import connection, transaction
 from django.db.models import signals
 from django.db.models.loading import register_models, get_model
 from django.dispatch import dispatcher
@@ -207 +207 @@
         non_pks = [f for f in self._meta.fields if not f.primary_key]
         cursor = connection.cursor()
 
+        ops = connection.ops
+        quote_name = ops.quote_name
         # First, try an UPDATE. If that doesn't update anything, do an INSERT.
         pk_val = self._get_pk_val()
         pk_set = bool(pk_val)
@@ -214 +216 @@
         if pk_set:
             # Determine whether a record with the primary key already exists.
             cursor.execute("SELECT COUNT(*) FROM %s WHERE %s=%%s" % \
-                (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)),
+                (quote_name(self._meta.db_table), quote_name(self._meta.pk.column)),
                 self._meta.pk.get_db_prep_lookup('exact', pk_val))
             # If it does already exist, do an UPDATE.
             if cursor.fetchone()[0] > 0:
                 db_values = [f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, False)) for f in non_pks]
                 if db_values:
                     cursor.execute("UPDATE %s SET %s WHERE %s=%%s" % \
-                        (backend.quote_name(self._meta.db_table),
-                        ','.join(['%s=%%s' % backend.quote_name(f.column) for f in non_pks]),
-                        backend.quote_name(self._meta.pk.column)),
+                        (quote_name(self._meta.db_table),
+                        ','.join(['%s=%%s' % quote_name(f.column) for f in non_pks]),
+                        quote_name(self._meta.pk.column)),
                         db_values + self._meta.pk.get_db_prep_lookup('exact', pk_val))
             else:
                 record_exists = False
         if not pk_set or not record_exists:
-            field_names = [backend.quote_name(f.column) for f in self._meta.fields if not isinstance(f, AutoField)]
+            field_names = [quote_name(f.column) for f in self._meta.fields if not isinstance(f, AutoField)]
             db_values = [f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True)) for f in self._meta.fields if not isinstance(f, AutoField)]
             # If the PK has been manually set, respect that.
             if pk_set:
@@ -236 +238 @@
                 db_values += [f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True)) for f in self._meta.fields if isinstance(f, AutoField)]
             placeholders = ['%s'] * len(field_names)
             if self._meta.order_with_respect_to:
-                field_names.append(backend.quote_name('_order'))
+                field_names.append(quote_name('_order'))
                 # TODO: This assumes the database supports subqueries.
                 placeholders.append('(SELECT COUNT(*) FROM %s WHERE %s = %%s)' % \
-                    (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.order_with_respect_to.column)))
+                    (quote_name(self._meta.db_table), quote_name(self._meta.order_with_respect_to.column)))
                 db_values.append(getattr(self, self._meta.order_with_respect_to.attname))
             if db_values:
                 cursor.execute("INSERT INTO %s (%s) VALUES (%s)" % \
-                    (backend.quote_name(self._meta.db_table), ','.join(field_names),
+                    (quote_name(self._meta.db_table), ','.join(field_names),
                     ','.join(placeholders)), db_values)
             else:
                 # Create a new record with defaults for everything.
                 cursor.execute("INSERT INTO %s (%s) VALUES (%s)" %
-                    (backend.quote_name(self._meta.db_table),
-                     backend.quote_name(self._meta.pk.column),
-                     backend.get_pk_default_value()))
+                    (quote_name(self._meta.db_table),
+                     quote_name(self._meta.pk.column),
+                     ops.get_pk_default_value()))
             if self._meta.has_auto_field and not pk_set:
-                setattr(self, self._meta.pk.attname, backend.get_last_insert_id(cursor, self._meta.db_table, self._meta.pk.column))
+                setattr(self, self._meta.pk.attname, ops.get_last_insert_id(cursor, self._meta.db_table, self._meta.pk.column))
         transaction.commit_unless_managed()
 
         # Run any post-save hooks.
@@ -326 +328 @@
     def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
         op = is_next and '>' or '<'
         where = '(%s %s %%s OR (%s = %%s AND %s.%s %s %%s))' % \
-            (backend.quote_name(field.column), op, backend.quote_name(field.column),
-            backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column), op)
+            (connection.ops.quote_name(field.column), op, connection.ops.quote_name(field.column),
+            connection.ops.quote_name(self._meta.db_table), connection.ops.quote_name(self._meta.pk.column), op)
         param = smart_str(getattr(self, field.attname))
         q = self.__class__._default_manager.filter(**kwargs).order_by((not is_next and '-' or '') + field.name, (not is_next and '-' or '') + self._meta.pk.name)
         q._where.append(where)
@@ -343 +345 @@
             op = is_next and '>' or '<'
             order_field = self._meta.order_with_respect_to
             where = ['%s %s (SELECT %s FROM %s WHERE %s=%%s)' % \
-                (backend.quote_name('_order'), op, backend.quote_name('_order'),
-                backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)),
-                '%s=%%s' % backend.quote_name(order_field.column)]
+                (connection.ops.quote_name('_order'), op, connection.ops.quote_name('_order'),
+                connection.ops.quote_name(self._meta.db_table), connection.ops.quote_name(self._meta.pk.column)),
+                '%s=%%s' % connection.ops.quote_name(order_field.column)]
             params = [self._get_pk_val(), getattr(self, order_field.attname)]
             obj = self._default_manager.order_by('_order').extra(where=where, params=params)[:1].get()
             setattr(self, cachename, obj)
@@ -430 +432 @@
     cursor = connection.cursor()
     # Example: "UPDATE poll_choices SET _order = %s WHERE poll_id = %s AND id = %s"
     sql = "UPDATE %s SET %s = %%s WHERE %s = %%s AND %s = %%s" % \
-        (backend.quote_name(ordered_obj._meta.db_table), backend.quote_name('_order'),
-        backend.quote_name(ordered_obj._meta.order_with_respect_to.column),
-        backend.quote_name(ordered_obj._meta.pk.column))
+        (connection.ops.quote_name(ordered_obj._meta.db_table), connection.ops.quote_name('_order'),
+        connection.ops.quote_name(ordered_obj._meta.order_with_respect_to.column),
+        connection.ops.quote_name(ordered_obj._meta.pk.column))
     rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name)
     cursor.executemany(sql, [(i, rel_val, j) for i, j in enumerate(id_list)])
     transaction.commit_unless_managed()
@@ -441 +443 @@
     cursor = connection.cursor()
     # Example: "SELECT id FROM poll_choices WHERE poll_id = %s ORDER BY _order"
     sql = "SELECT %s FROM %s WHERE %s = %%s ORDER BY %s" % \
-        (backend.quote_name(ordered_obj._meta.pk.column),
-        backend.quote_name(ordered_obj._meta.db_table),
-        backend.quote_name(ordered_obj._meta.order_with_respect_to.column),
-        backend.quote_name('_order'))
+        (connection.ops.quote_name(ordered_obj._meta.pk.column),
+        connection.ops.quote_name(ordered_obj._meta.db_table),
+        connection.ops.quote_name(ordered_obj._meta.order_with_respect_to.column),
+        connection.ops.quote_name('_order'))
     rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name)
     cursor.execute(sql, [rel_val])
     return [r[0] for r in cursor.fetchall()]

django/db/models/fields/related.py

@@ -1 @@
-from django.db import backend, transaction
+from django.db import connection, transaction
 from django.db.models import signals, get_model
 from django.db.models.fields import AutoField, Field, IntegerField, PositiveIntegerField, PositiveSmallIntegerField, get_ul_class
 from django.db.models.related import RelatedObject
@@ -400 +400 @@
         superclass = rel_model._default_manager.__class__
         RelatedManager = create_many_related_manager(superclass)
 
-        qn = backend.quote_name
+        qn = connection.ops.quote_name
         manager = RelatedManager(
             model=rel_model,
             core_filters={'%s__pk' % self.related.field.name: instance._get_pk_val()},
@@ -441 +441 @@
         superclass = rel_model._default_manager.__class__
         RelatedManager = create_many_related_manager(superclass)
 
-        qn = backend.quote_name
+        qn = connection.ops.quote_name
         manager = RelatedManager(
             model=rel_model,
             core_filters={'%s__pk' % self.field.related_query_name(): instance._get_pk_val()},

django/db/models/options.py

@@ -63 +63 @@
         del self.meta
 
     def _prepare(self, model):
-        from django.db import backend
+        from django.db import connection
         from django.db.backends.util import truncate_name
         if self.order_with_respect_to:
             self.order_with_respect_to = self.get_field(self.order_with_respect_to)
@@ -80 +80 @@
         if not self.db_table:
             self.db_table = "%s_%s" % (self.app_label, self.module_name)
             self.db_table = truncate_name(self.db_table,
-                                          backend.get_max_name_length())
+                                          connection.ops.get_max_name_length())
 
     def add_field(self, field):
         # Insert the given field in the order in which it was created, using

django/db/models/query.py

@@ -64 +64 @@
         return f
 
 def orderlist2sql(order_list, opts, prefix=''):
+    quote_name = connection.ops.quote_name
+    get_rand_sql = connection.ops.get_random_function_sql
     if prefix.endswith('.'):
-        prefix = backend.quote_name(prefix[:-1]) + '.'
+        prefix = quote_name(prefix[:-1]) + '.'
     output = []
     for f in handle_legacy_orderlist(order_list):
         if f.startswith('-'):
-            output.append('%s%s DESC' % (prefix, backend.quote_name(orderfield2column(f[1:], opts))))
+            output.append('%s%s DESC' % (prefix, quote_name(orderfield2column(f[1:], opts))))
         elif f == '?':
-            output.append(backend.get_random_function_sql())
+            output.append(get_rand_sql())
         else:
-            output.append('%s%s ASC' % (prefix, backend.quote_name(orderfield2column(f, opts))))
+            output.append('%s%s ASC' % (prefix, quote_name(orderfield2column(f, opts))))
     return ', '.join(output)
 
 def quote_only_if_word(word):
     if re.search('\W', word): # Don't quote if there are spaces or non-word chars.
         return word
     else:
-        return backend.quote_name(word)
+        return connection.ops.quote_name(word)
 
 class _QuerySet(object):
     "Represents a lazy database lookup for a set of objects"
@@ -235 +237 @@
 
         cursor = connection.cursor()
         if self._distinct:
-            id_col = "%s.%s" % (backend.quote_name(self.model._meta.db_table),
-                    backend.quote_name(self.model._meta.pk.column))
+            id_col = "%s.%s" % (connection.ops.quote_name(self.model._meta.db_table),
+                    connection.ops.quote_name(self.model._meta.pk.column))
             cursor.execute("SELECT COUNT(DISTINCT(%s))" % id_col + sql, params)
         else:
             cursor.execute("SELECT COUNT(*)" + sql, params)
@@ -312 +314 @@
         if id_list == []:
             return {}
         qs = self._clone()
-        qs._where.append("%s.%s IN (%s)" % (backend.quote_name(self.model._meta.db_table), backend.quote_name(self.model._meta.pk.column), ",".join(['%s'] * len(id_list))))
+        qs._where.append("%s.%s IN (%s)" % (connection.ops.quote_name(self.model._meta.db_table),
+            connection.ops.quote_name(self.model._meta.pk.column), ",".join(['%s'] * len(id_list))))
         qs._params.extend(id_list)
         return dict([(obj._get_pk_val(), obj) for obj in qs.iterator()])
 
@@ -483 +486 @@
     def _get_sql_clause(self):
         opts = self.model._meta
 
+        quote_name = connection.ops.quote_name
         # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z.
-        select = ["%s.%s" % (backend.quote_name(opts.db_table), backend.quote_name(f.column)) for f in opts.fields]
+        select = ["%s.%s" % (quote_name(opts.db_table), quote_name(f.column)) for f in opts.fields]
         tables = [quote_only_if_word(t) for t in self._tables]
         joins = SortedDict()
         where = self._where[:]
@@ -505 +509 @@
 
         # Add any additional SELECTs.
         if self._select:
-            select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), backend.quote_name(s[0])) for s in self._select.items()])
+            select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), quote_name(s[0])) for s in self._select.items()])
 
         # Start composing the body of the SQL statement.
-        sql = [" FROM", backend.quote_name(opts.db_table)]
+        sql = [" FROM", quote_name(opts.db_table)]
 
         # Compose the join dictionary into SQL describing the joins.
         if joins:
@@ -531 +535 @@
             ordering_to_use = opts.ordering
         for f in handle_legacy_orderlist(ordering_to_use):
             if f == '?': # Special case.
-                order_by.append(backend.get_random_function_sql())
+                order_by.append(connection.ops.get_random_function_sql())
             else:
                 if f.startswith('-'):
                     col_name = f[1:]
@@ -541 +545 @@
                     order = "ASC"
                 if "." in col_name:
                     table_prefix, col_name = col_name.split('.', 1)
-                    table_prefix = backend.quote_name(table_prefix) + '.'
+                    table_prefix = quote_name(table_prefix) + '.'
                 else:
                     # Use the database table as a column prefix if it wasn't given,
                     # and if the requested column isn't a custom SELECT.
                     if "." not in col_name and col_name not in (self._select or ()):
-                        table_prefix = backend.quote_name(opts.db_table) + '.'
+                        table_prefix = quote_name(opts.db_table) + '.'
                     else:
                         table_prefix = ''
-                order_by.append('%s%s %s' % (table_prefix, backend.quote_name(orderfield2column(col_name, opts)), order))
+                order_by.append('%s%s %s' % (table_prefix, quote_name(orderfield2column(col_name, opts)), order))
         if order_by:
             sql.append("ORDER BY " + ", ".join(order_by))
 
         # LIMIT and OFFSET clauses
         if self._limit is not None:
-            sql.append("%s " % backend.get_limit_offset_sql(self._limit, self._offset))
+            sql.append("%s " % connection.ops.get_limit_offset_sql(self._limit, self._offset))
         else:
             assert self._offset is None, "'offset' is not allowed without 'limit'"
 
         return select, " ".join(sql), params
 
 # Use the backend's QuerySet class if it defines one, otherwise use _QuerySet.
-if hasattr(backend, 'get_query_set_class'):
-    QuerySet = backend.get_query_set_class(_QuerySet)
+if hasattr(connection.ops, 'get_query_set_class'):
+    QuerySet = connection.ops.get_query_set_class(_QuerySet)
 else:
     QuerySet = _QuerySet
 
@@ -605 +609 @@
             field_names = [f.attname for f in fields]
 
         columns = [f.column for f in fields]
-        select = ['%s.%s' % (backend.quote_name(self.model._meta.db_table), backend.quote_name(c)) for c in columns]
+        select = ['%s.%s' % (connection.ops.quote_name(self.model._meta.db_table), connection.ops.quote_name(c)) for c in columns]
         if extra_select:
-            select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), backend.quote_name(s[0])) for s in extra_select])
+            select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), connection.ops.quote_name(s[0])) for s in extra_select])
             field_names.extend([f[0] for f in extra_select])
 
         cursor = connection.cursor()
@@ -635 +639 @@
         self._order_by = () # Clear this because it'll mess things up otherwise.
         if self._field.null:
             self._where.append('%s.%s IS NOT NULL' % \
-                (backend.quote_name(self.model._meta.db_table), backend.quote_name(self._field.column)))
+                (connection.ops.quote_name(self.model._meta.db_table), connection.ops.quote_name(self._field.column)))
         try:
             select, sql, params = self._get_sql_clause()
         except EmptyResultSet:
             raise StopIteration
 
-        table_name = backend.quote_name(self.model._meta.db_table)
-        field_name = backend.quote_name(self._field.column)
+        table_name = connection.ops.quote_name(self.model._meta.db_table)
+        field_name = connection.ops.quote_name(self._field.column)
 
-        if backend.allows_group_by_ordinal:
+        if connection.capabilities.allows_group_by_ordinal:
             group_by = '1'
         else:
-            group_by = backend.get_date_trunc_sql(self._kind,
+            group_by = connection.ops.get_date_trunc_sql(self._kind,
                                                   '%s.%s' % (table_name, field_name))
 
         sql = 'SELECT %s %s GROUP BY %s ORDER BY 1 %s' % \
-            (backend.get_date_trunc_sql(self._kind, '%s.%s' % (backend.quote_name(self.model._meta.db_table),
-            backend.quote_name(self._field.column))), sql, group_by, self._order)
+            (connection.ops.get_date_trunc_sql(self._kind, '%s.%s' % (connection.ops.quote_name(self.model._meta.db_table),
+            connection.ops.quote_name(self._field.column))), sql, group_by, self._order)
         cursor = connection.cursor()
         cursor.execute(sql, params)
 
         has_resolve_columns = hasattr(self, 'resolve_columns')
-        needs_datetime_string_cast = backend.needs_datetime_string_cast
+        needs_datetime_string_cast = connection.capabilities.needs_datetime_string_cast
         dates = []
         # It would be better to use self._field here instead of DateTimeField(),
         # but in Oracle that will result in a list of datetime.date instead of
@@ -779 +783 @@
 
 def get_where_clause(lookup_type, table_prefix, field_name, value):
     if table_prefix.endswith('.'):
-        table_prefix = backend.quote_name(table_prefix[:-1])+'.'
-    field_name = backend.quote_name(field_name)
-    if type(value) == datetime.datetime and backend.get_datetime_cast_sql():
-        cast_sql = backend.get_datetime_cast_sql()
+        table_prefix = connection.ops.quote_name(table_prefix[:-1])+'.'
+    field_name = connection.ops.quote_name(field_name)
+    if type(value) == datetime.datetime and connection.ops.get_datetime_cast_sql():
+        cast_sql = connection.ops.get_datetime_cast_sql()
     else:
         cast_sql = '%s'
-    if lookup_type in ('iexact', 'icontains', 'istartswith', 'iendswith') and backend.needs_upper_for_iops:
+    if lookup_type in ('iexact', 'icontains', 'istartswith', 'iendswith') and connection.capabilities.needs_upper_for_iops:
         format = 'UPPER(%s%s) %s'
     else:
         format = '%s%s %s'
     try:
         return format % (table_prefix, field_name,
-                         backend.OPERATOR_MAPPING[lookup_type] % cast_sql)
+                         connection.orm_map[lookup_type] % cast_sql)
     except KeyError:
         pass
     if lookup_type == 'in':
@@ -803 +807 @@
     elif lookup_type in ('range', 'year'):
         return '%s%s BETWEEN %%s AND %%s' % (table_prefix, field_name)
     elif lookup_type in ('month', 'day'):
-        return "%s = %%s" % backend.get_date_extract_sql(lookup_type, table_prefix + field_name)
+        return "%s = %%s" % connection.ops.get_date_extract_sql(lookup_type, table_prefix + field_name)
     elif lookup_type == 'isnull':
         return "%s%s IS %sNULL" % (table_prefix, field_name, (not value and 'NOT ' or ''))
     elif lookup_type == 'search':
-        return backend.get_fulltext_search_sql(table_prefix + field_name)
+        return connection.ops.get_fulltext_search_sql(table_prefix + field_name)
     elif lookup_type in ('regex', 'iregex'):
         if settings.DATABASE_ENGINE == 'oracle':
             if lookup_type == 'regex':
@@ -846 +850 @@
     if max_depth and cur_depth > max_depth:
         return None
 
-    qn = backend.quote_name
+    qn = connection.ops.quote_name
     for f in opts.fields:
         if f.rel and not f.null:
             db_table = f.rel.to._meta.db_table
@@ -944 +948 @@
     return choices
 
 def lookup_inner(path, lookup_type, value, opts, table, column):
-    qn = backend.quote_name
+    qn = connection.ops.quote_name
     joins, where, params = SortedDict(), [], []
     current_opts = opts
     current_table = table
@@ -1108 +1112 @@
 
 def delete_objects(seen_objs):
     "Iterate through a list of seen classes, and remove any instances that are referred to"
-    qn = backend.quote_name
+    qn = connection.ops.quote_name
     ordered_classes = seen_objs.keys()
     ordered_classes.reverse()
 

django/test/utils.py

@@ -119 +119 @@
         cursor = connection.cursor()
         _set_autocommit(connection)
         try:
-            cursor.execute("CREATE DATABASE %s %s" % (backend.quote_name(TEST_DATABASE_NAME), suffix))
+            cursor.execute("CREATE DATABASE %s %s" % (connection.ops.quote_name(TEST_DATABASE_NAME), suffix))
         except Exception, e:            
             sys.stderr.write("Got an error creating the test database: %s\n" % e)
             if not autoclobber:
@@ -128 +128 @@
                 try:
                     if verbosity >= 1:
                         print "Destroying old test database..."                
-                    cursor.execute("DROP DATABASE %s" % backend.quote_name(TEST_DATABASE_NAME))
+                    cursor.execute("DROP DATABASE %s" % connection.ops.quote_name(TEST_DATABASE_NAME))
                     if verbosity >= 1:
                         print "Creating test database..."
-                    cursor.execute("CREATE DATABASE %s %s" % (backend.quote_name(TEST_DATABASE_NAME), suffix))
+                    cursor.execute("CREATE DATABASE %s %s" % (connection.ops.quote_name(TEST_DATABASE_NAME), suffix))
                 except Exception, e:
                     sys.stderr.write("Got an error recreating the test database: %s\n" % e)
                     sys.exit(2)
@@ -173 +173 @@
         cursor = connection.cursor()
         _set_autocommit(connection)
         time.sleep(1) # To avoid "database is being accessed by other users" errors.
-        cursor.execute("DROP DATABASE %s" % backend.quote_name(TEST_DATABASE_NAME))
+        cursor.execute("DROP DATABASE %s" % connection.ops.quote_name(TEST_DATABASE_NAME))
         connection.close()