Ticket #17336: merge-alex-gsoc.patch

django/db/backends/creation.py

@@ -2 +2 @@
 import time
 
 from django.conf import settings
+from django.utils.datastructures import DictWrapper
 
 # The prefix to put on the default database name when creating
 # the test database.
@@ -26 +27 @@
         """
         return '%x' % (abs(hash(args)) % 4294967296L)  # 2**32
 
+    def db_type(self, field):
+        return self._db_type(field, field.get_internal_type())
+
+    def related_db_type(self, field):
+        return self._db_type(field, field.get_related_internal_type())
+
+    def _db_type(self, field, internal_type):
+        data = DictWrapper(field.__dict__, self.connection.ops.quote_name, "qn_")
+        try:
+            return self.connection.creation.data_types[internal_type] % data
+        except KeyError:
+            return None
+
     def sql_create_model(self, model, style, known_models=set()):
         """
         Returns the SQL required to create a single model, as a tuple of:

django/db/backends/mysql/base.py

@@ -366 +366 @@
 
     def _rollback(self):
         try:
-            BaseDatabaseWrapper._rollback(self)
+            super(DatabaseWrapper, self)._rollback()
         except Database.NotSupportedError:
             pass
 

django/db/backends/sqlite3/base.py

@@ -289 +289 @@
         # database. To prevent accidental data loss, ignore close requests on
         # an in-memory db.
         if self.settings_dict['NAME'] != ":memory:":
-            BaseDatabaseWrapper.close(self)
+            super(DatabaseWrapper, self).close()
 
 FORMAT_QMARK_REGEX = re.compile(r'(?<!%)%s')
 

django/db/models/fields/__init__.py

@@ -10 +10 @@
 from django.conf import settings
 from django import forms
 from django.core import exceptions, validators
-from django.utils.datastructures import DictWrapper
 from django.utils.dateparse import parse_date, parse_datetime, parse_time
 from django.utils.functional import curry
 from django.utils.text import capfirst
@@ -221 +220 @@
         # 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:
-            return (connection.creation.data_types[self.get_internal_type()]
-                    % data)
-        except KeyError:
-            return None
+        return connection.creation.db_type(self)
+
+    def related_db_type(self, connection):
+        # This is the db_type used by a ForeignKey.
+        return connection.creation.related_db_type(self)
 
     @property
     def unique(self):
@@ -261 +259 @@
     def get_internal_type(self):
         return self.__class__.__name__
 
+    def get_related_internal_type(self):
+        return self.get_internal_type()
+
     def pre_save(self, model_instance, add):
         """
         Returns field's value just before saving.
@@ -518 +519 @@
     def get_internal_type(self):
         return "AutoField"
 
+    def get_related_internal_type(self):
+        return "RelatedAutoField"
+
+    def related_db_type(self, connection):
+        db_type = super(AutoField, self).related_db_type(connection=connection)
+        if db_type is None:
+            return IntegerField().db_type(connection=connection)
+        return db_type
+
     def to_python(self, value):
         if value is None:
             return value