Ticket #5461: 5461-r8225.diff

django/test/simple.py

@@ -3 +3 @@
-from django.db.models import get_app, get_apps
-from django.test import _doctest as doctest
-from django.test.utils import setup_test_environment, teardown_test_environment
-from django.test.utils import create_test_db, destroy_test_db
-from django.test.testcases import OutputChecker, DocTestRunner
-
-# The module name for tests outside models.py
@@ -139 +138 @@
-        suite.addTest(test)
-
-    old_name = settings.DATABASE_NAME
-
+
+
-    result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
-
+connection.creation.
-    
-    teardown_test_environment()
-    

django/test/utils.py

@@ -1 +1 @@
-import sys, time, os
-from django.conf import settings
-, get_creation_module
+
-from django.core import mail
-from django.core.management import call_command
-from django.test import signals
-from django.template import Template
-from django.utils.translation import deactivate
-
-# The prefix to put on the default database name when creating
-# the test database.
-TEST_DATABASE_PREFIX = 'test_'
-
-def instrumented_test_render(self, context):
-    """
-    An instrumented Template render method, providing a signal
@@ -70 +65 @@
-
-    del mail.outbox
-
-def _set_autocommit(connection):
-    "Make sure a connection is in autocommit mode."
-    if hasattr(connection.connection, "autocommit"):
-        if callable(connection.connection.autocommit):
-            connection.connection.autocommit(True)
-        else:
-            connection.connection.autocommit = True
-    elif hasattr(connection.connection, "set_isolation_level"):
-        connection.connection.set_isolation_level(0)
-
-def get_mysql_create_suffix():
-    suffix = []
-    if settings.TEST_DATABASE_CHARSET:
-        suffix.append('CHARACTER SET %s' % settings.TEST_DATABASE_CHARSET)
-    if settings.TEST_DATABASE_COLLATION:
-        suffix.append('COLLATE %s' % settings.TEST_DATABASE_COLLATION)
-    return ' '.join(suffix)
-
-def get_postgresql_create_suffix():
-    assert settings.TEST_DATABASE_COLLATION is None, "PostgreSQL does not support collation setting at database creation time."
-    if settings.TEST_DATABASE_CHARSET:
-        return "WITH ENCODING '%s'" % settings.TEST_DATABASE_CHARSET
-    return ''
-
-def create_test_db(verbosity=1, autoclobber=False):
-    """
-    Creates a test database, prompting the user for confirmation if the
-    database already exists. Returns the name of the test database created.
-    """
-    # If the database backend wants to create the test DB itself, let it
-    creation_module = get_creation_module()
-    if hasattr(creation_module, "create_test_db"):
-        creation_module.create_test_db(settings, connection, verbosity, autoclobber)
-        return
-
-    if verbosity >= 1:
-        print "Creating test database..."
-    # If we're using SQLite, it's more convenient to test against an
-    # in-memory database. Using the TEST_DATABASE_NAME setting you can still choose
-    # to run on a physical database.
-    if settings.DATABASE_ENGINE == "sqlite3":
-        if settings.TEST_DATABASE_NAME and settings.TEST_DATABASE_NAME != ":memory:":
-            TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME
-            # Erase the old test database
-            if verbosity >= 1:
-                print "Destroying old test database..."
-            if os.access(TEST_DATABASE_NAME, os.F_OK):
-                if not autoclobber:
-                    confirm = raw_input("Type 'yes' if you would like to try deleting the test database '%s', or 'no' to cancel: " % TEST_DATABASE_NAME)
-                if autoclobber or confirm == 'yes':
-                  try:
-                      if verbosity >= 1:
-                          print "Destroying old test database..."
-                      os.remove(TEST_DATABASE_NAME)
-                  except Exception, e:
-                      sys.stderr.write("Got an error deleting the old test database: %s\n" % e)
-                      sys.exit(2)
-                else:
-                    print "Tests cancelled."
-                    sys.exit(1)
-            if verbosity >= 1:
-                print "Creating test database..."
-        else:
-            TEST_DATABASE_NAME = ":memory:"
-    else:
-        suffix = {
-            'postgresql': get_postgresql_create_suffix,
-            'postgresql_psycopg2': get_postgresql_create_suffix,
-            'mysql': get_mysql_create_suffix,
-        }.get(settings.DATABASE_ENGINE, lambda: '')()
-        if settings.TEST_DATABASE_NAME:
-            TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME
-        else:
-            TEST_DATABASE_NAME = TEST_DATABASE_PREFIX + settings.DATABASE_NAME
-
-        qn = connection.ops.quote_name
-
-        # Create the test database and connect to it. We need to autocommit
-        # if the database supports it because PostgreSQL doesn't allow
-        # CREATE/DROP DATABASE statements within transactions.
-        cursor = connection.cursor()
-        _set_autocommit(connection)
-        try:
-            cursor.execute("CREATE DATABASE %s %s" % (qn(TEST_DATABASE_NAME), suffix))
-        except Exception, e:
-            sys.stderr.write("Got an error creating the test database: %s\n" % e)
-            if not autoclobber:
-                confirm = raw_input("Type 'yes' if you would like to try deleting the test database '%s', or 'no' to cancel: " % TEST_DATABASE_NAME)
-            if autoclobber or confirm == 'yes':
-                try:
-                    if verbosity >= 1:
-                        print "Destroying old test database..."
-                    cursor.execute("DROP DATABASE %s" % qn(TEST_DATABASE_NAME))
-                    if verbosity >= 1:
-                        print "Creating test database..."
-                    cursor.execute("CREATE DATABASE %s %s" % (qn(TEST_DATABASE_NAME), suffix))
-                except Exception, e:
-                    sys.stderr.write("Got an error recreating the test database: %s\n" % e)
-                    sys.exit(2)
-            else:
-                print "Tests cancelled."
-                sys.exit(1)
-
-    connection.close()
-    settings.DATABASE_NAME = TEST_DATABASE_NAME
-
-    call_command('syncdb', verbosity=verbosity, interactive=False)
-
-    if settings.CACHE_BACKEND.startswith('db://'):
-        cache_name = settings.CACHE_BACKEND[len('db://'):]
-        call_command('createcachetable', cache_name)
-
-    # Get a cursor (even though we don't need one yet). This has
-    # the side effect of initializing the test database.
-    cursor = connection.cursor()
-
-    return TEST_DATABASE_NAME
-
-def destroy_test_db(old_database_name, verbosity=1):
-    # If the database wants to drop the test DB itself, let it
-    creation_module = get_creation_module()
-    if hasattr(creation_module, "destroy_test_db"):
-        creation_module.destroy_test_db(settings, connection, old_database_name, verbosity)
-        return
-
-    if verbosity >= 1:
-        print "Destroying test database..."
-    connection.close()
-    TEST_DATABASE_NAME = settings.DATABASE_NAME
-    settings.DATABASE_NAME = old_database_name
-    if settings.DATABASE_ENGINE == "sqlite3":
-        if TEST_DATABASE_NAME and TEST_DATABASE_NAME != ":memory:":
-            # Remove the SQLite database file
-            os.remove(TEST_DATABASE_NAME)
-    else:
-        # Remove the test database to clean up after
-        # ourselves. Connect to the previous database (not the test database)
-        # to do so, because it's not allowed to delete a database while being
-        # connected to it.
-        cursor = connection.cursor()
-        _set_autocommit(connection)
-        time.sleep(1) # To avoid "database is being accessed by other users" errors.
-        cursor.execute("DROP DATABASE %s" % connection.ops.quote_name(TEST_DATABASE_NAME))
-        connection.close()

django/db/models/fields/__init__.py

@@ -7 +7 @@
-except ImportError:
-    from django.utils import _decimal as decimal    # for Python 2.3
-
-, get_creation_module
+
-from django.db.models import signals
-from django.db.models.query_utils import QueryWrapper
-from django.dispatch import dispatcher
@@ -145 +145 @@
-        # as the TextField Django field type, which means XMLField's
-        # get_internal_type() returns 'TextField'.
-        #
-DATA_TYPES
+data_types
-        # is that it cannot handle database column types that aren't already
-        # mapped to one of the built-in Django field types. In this case, you
-        # can implement db_type() instead of get_internal_type() to specify
-        # exactly which wacky database column type you want to use.
-        data = DictWrapper(self.__dict__, connection.ops.quote_name, "qn_")
-        try:
-get_creation_module().DATA_TYPES
+connection.creation.data_types
-        except KeyError:
-            return None
-

django/db/__init__.py

@@ -14 +14 @@
-    # backends that ships with Django, so look there first.
-    _import_path = 'django.db.backends.'
-    backend = __import__('%s%s.base' % (_import_path, settings.DATABASE_ENGINE), {}, {}, [''])
-    creation = __import__('%s%s.creation' % (_import_path, settings.DATABASE_ENGINE), {}, {}, [''])
-except ImportError, e:
-    # If the import failed, we might be looking for a database backend
-    # distributed external to Django. So we'll try that next.
-    try:
-        _import_path = ''
-        backend = __import__('%s.base' % settings.DATABASE_ENGINE, {}, {}, [''])
-        creation = __import__('%s.creation' % settings.DATABASE_ENGINE, {}, {}, [''])
-    except ImportError, e_user:
-        # The database backend wasn't found. Display a helpful error message
-        # listing all possible (built-in) database backends.
@@ -29 +27 @@
-        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:
-
-
+\nError was: %s
+, e_user
-        else:
-            raise # If there's some other error, this must be an error in Django itself.
-
-def _import_database_module(import_path='', module_name=''):
-    """Lazily import a database module when requested."""
-    return __import__('%s%s.%s' % (import_path, settings.DATABASE_ENGINE, module_name), {}, {}, [''])
-
-# We don't want to import the introspect module unless someone asks for it, so
-# lazily load it on demmand.
-get_introspection_module = curry(_import_database_module, _import_path, 'introspection')
-
-def get_creation_module():
-    return creation
-
-# We want runshell() to work the same way, but we have to treat it a
-# little differently (since it just runs instead of returning a module like
-# the above) and wrap the lazily-loaded runshell() method.
-runshell = lambda: _import_database_module(_import_path, "client").runshell()
-
-# Convenient aliases for backend bits.
-connection = backend.DatabaseWrapper(**settings.DATABASE_OPTIONS)
-DatabaseError = backend.DatabaseError

django/db/backends/postgresql/base.py

@@ -4 +4 @@
-Requires psycopg 1: http://initd.org/projects/psycopg1
-"""
-
+from django.db.backends import BaseDatabaseFeatures
+from django.db.backends import BaseDatabaseValidation
+from django.db.backends import BaseDatabaseWrapper
+from django.db.backends import util
+from django.db.backends.postgresql.client import DatabaseClient
+from django.db.backends.postgresql.creation import DatabaseCreation
+from django.db.backends.postgresql.introspection import DatabaseIntrospection
+from django.db.backends.postgresql.operations import DatabaseOperations
-from django.utils.encoding import smart_str, smart_unicode
-
-
+
-try:
-    import psycopg as Database
-except ImportError, e:
@@ -62 +69 @@
-class DatabaseFeatures(BaseDatabaseFeatures):
-    pass # This backend uses all the defaults.
-
+class DatabaseValidation(BaseDatabaseValidation):
+    pass
+
-class DatabaseWrapper(BaseDatabaseWrapper):
-    features = DatabaseFeatures()
-    ops = DatabaseOperations()
-    operators = {
-        'exact': '= %s',
-        'iexact': 'ILIKE %s',
@@ -82 +90 @@
-        'iendswith': 'ILIKE %s',
-    }
-
+    def __init__(self, *args, **kwargs):
+        super(DatabaseWrapper, self).__init__(*args, **kwargs)
+        
+        self.features = DatabaseFeatures()
+        self.ops = DatabaseOperations()
+        self.client = DatabaseClient()
+        self.creation = DatabaseCreation(self)
+        self.introspection = DatabaseIntrospection(self)
+        self.validation = DatabaseValidation()
+
-    def _cursor(self, settings):
-        set_tz = False
-        if self.connection is None:

django/db/backends/postgresql/client.py

@@ +1 @@
+from django.db.backends import BaseDatabaseClient
-from django.conf import settings
-import os
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+

django/db/backends/postgresql/introspection.py

@@ -1 @@
-.postgresql.base import DatabaseOperations
+ import BaseDatabaseIntrospection
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-def get_indexes(cursor, table_name):
-    """
-    Returns a dictionary of fieldname -> infodict for the given table,
-    where each infodict is in the format:
-        {'primary_key': boolean representing whether it's the primary key,
-         'unique': boolean representing whether it's a unique index}
-    """
-    # This query retrieves each index on the given table, including the
-    # first associated field name
-    cursor.execute("""
-        SELECT attr.attname, idx.indkey, idx.indisunique, idx.indisprimary
-        FROM pg_catalog.pg_class c, pg_catalog.pg_class c2,
-            pg_catalog.pg_index idx, pg_catalog.pg_attribute attr
-        WHERE c.oid = idx.indrelid
-            AND idx.indexrelid = c2.oid
-            AND attr.attrelid = c.oid
-            AND attr.attnum = idx.indkey[0]
-            AND c.relname = %s""", [table_name])
-    indexes = {}
-    for row in cursor.fetchall():
-        # row[1] (idx.indkey) is stored in the DB as an array. It comes out as
-        # a string of space-separated integers. This designates the field
-        # indexes (1-based) of the fields that have indexes on the table.
-        # Here, we skip any indexes across multiple fields.
-        if ' ' in row[1]:
-            continue
-        indexes[row[0]] = {'primary_key': row[3], 'unique': row[2]}
-    return indexes
-
-# Maps type codes to Django Field types.
-DATA_TYPES_REVERSE = {
-    16: 'BooleanField',
-    21: 'SmallIntegerField',
-    23: 'IntegerField',
-    25: 'TextField',
-    701: 'FloatField',
-    869: 'IPAddressField',
-    1043: 'CharField',
-    1082: 'DateField',
-    1083: 'TimeField',
-    1114: 'DateTimeField',
-    1184: 'DateTimeField',
-    1266: 'TimeField',
-    1700: 'DecimalField',
-}

django/db/backends/postgresql/creation.py

@@ -1 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/db/backends/sqlite3/base.py

@@ -6 +6 @@
-Python 2.5 and later use the sqlite3 module in the standard library.
-"""
-
-
+
+
+
+
+
+
+
+
+
-try:
-    try:
-        from sqlite3 import dbapi2 as Database
@@ -39 +47 @@
-Database.register_adapter(decimal.Decimal, util.rev_typecast_decimal)
-
-class DatabaseFeatures(BaseDatabaseFeatures):
-    supports_constraints = False
-    # SQLite cannot handle us only partially reading from a cursor's result set
-    # and then writing the same rows to the database in another cursor. This
-    # setting ensures we always read result sets fully into memory all in one
@@ -89 +96 @@
-        second = '%s-12-31 23:59:59.999999'
-        return [first % value, second % value]
-
+class DatabaseValidation(BaseDatabaseValidation):
+    pass
-
-class DatabaseWrapper(BaseDatabaseWrapper):
-
-
-
+
-    # SQLite requires LIKE statements to include an ESCAPE clause if the value
-    # being escaped has a percent or underscore in it.
-    # See http://www.sqlite.org/lang_expr.html for an explanation.
@@ -114 +121 @@
-        'iendswith': "LIKE %s ESCAPE '\\'",
-    }
-
+    def __init__(self, *args, **kwargs):
+        super(DatabaseWrapper, self).__init__(*args, **kwargs)
+        
+        self.features = DatabaseFeatures()
+        self.ops = DatabaseOperations()
+        self.client = DatabaseClient()
+        self.creation = DatabaseCreation(self)
+        self.introspection = DatabaseIntrospection(self)
+        self.validation = DatabaseValidation()
+
-    def _cursor(self, settings):
-        if self.connection is None:
-            if not settings.DATABASE_NAME:

django/db/backends/sqlite3/client.py

@@ +1 @@
+from django.db.backends import BaseDatabaseClient
-from django.conf import settings
-import os
-
-
-
-
+
+
+
+

django/db/backends/sqlite3/introspection.py

@@ -1 @@
-.sqlite3.base import DatabaseOperations
+ import BaseDatabaseIntrospection
-
-quote_name = DatabaseOperations().quote_name
-
-def get_table_list(cursor):
-    "Returns a list of table names in the current database."
-    # Skip the sqlite_sequence system table used for autoincrement key
-    # generation.
-    cursor.execute("""
-        SELECT name FROM sqlite_master
-        WHERE type='table' AND NOT name='sqlite_sequence'
-        ORDER BY name""")
-    return [row[0] for row in cursor.fetchall()]
-
-def get_table_description(cursor, table_name):
-    "Returns a description of the table, with the DB-API cursor.description interface."
-    return [(info['name'], info['type'], None, None, None, None,
-             info['null_ok']) for info in _table_info(cursor, table_name)]
-
-def get_relations(cursor, table_name):
-    raise NotImplementedError
-
-def get_indexes(cursor, table_name):
-    """
-    Returns a dictionary of fieldname -> infodict for the given table,
-    where each infodict is in the format:
-        {'primary_key': boolean representing whether it's the primary key,
-         'unique': boolean representing whether it's a unique index}
-    """
-    indexes = {}
-    for info in _table_info(cursor, table_name):
-        indexes[info['name']] = {'primary_key': info['pk'] != 0,
-                                 'unique': False}
-    cursor.execute('PRAGMA index_list(%s)' % quote_name(table_name))
-    # seq, name, unique
-    for index, unique in [(field[1], field[2]) for field in cursor.fetchall()]:
-        if not unique:
-            continue
-        cursor.execute('PRAGMA index_info(%s)' % quote_name(index))
-        info = cursor.fetchall()
-        # Skip indexes across multiple fields
-        if len(info) != 1:
-            continue
-        name = info[0][2] # seqno, cid, name
-        indexes[name]['unique'] = True
-    return indexes
-
-def _table_info(cursor, name):
-    cursor.execute('PRAGMA table_info(%s)' % quote_name(name))
-    # cid, name, type, notnull, dflt_value, pk
-    return [{'name': field[1],
-             'type': field[2],
-             'null_ok': not field[3],
-             'pk': field[5]     # undocumented
-             } for field in cursor.fetchall()]
-
-# Maps SQL types to Django Field types. Some of the SQL types have multiple
-# entries here because SQLite allows for anything and doesn't normalize the
-# field type; it uses whatever was given.
-BASE_DATA_TYPES_REVERSE = {
-    'bool': 'BooleanField',
-    'boolean': 'BooleanField',
-    'smallint': 'SmallIntegerField',
-    'smallinteger': 'SmallIntegerField',
-    'int': 'IntegerField',
-    'integer': 'IntegerField',
-    'text': 'TextField',
-    'char': 'CharField',
-    'date': 'DateField',
-    'datetime': 'DateTimeField',
-    'time': 'TimeField',
-}
-
-# This light wrapper "fakes" a dictionary interface, because some SQLite data
-# types include variables in them -- e.g. "varchar(30)" -- and can't be matched
-# as a simple dictionary lookup.
-class FlexibleFieldLookupDict:
+    # Maps SQL types to Django Field types. Some of the SQL types have multiple
+    # entries here because SQLite allows for anything and doesn't normalize the
+    # field type; it uses whatever was given.
+    base_data_types_reverse = {
+        'bool': 'BooleanField',
+        'boolean': 'BooleanField',
+        'smallint': 'SmallIntegerField',
+        'smallinteger': 'SmallIntegerField',
+        'int': 'IntegerField',
+        'integer': 'IntegerField',
+        'text': 'TextField',
+        'char': 'CharField',
+        'date': 'DateField',
+        'datetime': 'DateTimeField',
+        'time': 'TimeField',
+    }
+
-    def __getitem__(self, key):
-        key = key.lower()
-        try:
-BASE_DATA_TYPES_REVERSE
+self.base_data_types_reverse
-        except KeyError:
-            import re
-            m = re.search(r'^\s*(?:var)?char\s*\(\s*(\d+)\s*\)\s*$', key)
@@ -86 +32 @@
-                return ('CharField', {'max_length': int(m.group(1))})
-            raise KeyError
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/db/backends/sqlite3/creation.py

@@ -1 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/db/backends/mysql/base.py

@@ -4 +4 @@
-Requires MySQLdb: http://sourceforge.net/projects/mysql-python
-"""
-
-
+
+
+
+
+
+