Ticket #7560: get_db_prep_refactor2.patch

django/db/backends/__init__.py

@@ -5 +5 @@
     # Import copy of _thread_local.py from Python 2.4
     from django.utils._threading_local import local
 
+from django.db.backends import util
+
 class BaseDatabaseWrapper(local):
     """
     Represents a database connection.
@@ -36 +38 @@
         return cursor
 
     def make_debug_cursor(self, cursor):
-        from django.db.backends import util
         return util.CursorDebugWrapper(cursor, self)
 
 class BaseDatabaseFeatures(object):
     allows_group_by_ordinal = True
     inline_fk_references = True
-    needs_datetime_string_cast = True
+    needs_datetime_string_cast = True # uses
+                                      # django.db.backend.utils.typecast_timetamp
+                                      # on returned values from dates()
     supports_constraints = True
     supports_tablespaces = False
     uses_case_insensitive_names = False
@@ -272 +275 @@
         """Prepares a value for use in a LIKE query."""
         from django.utils.encoding import smart_unicode
         return smart_unicode(x).replace("\\", "\\\\").replace("%", "\%").replace("_", "\_")
+
+    def value_to_db_date(self, value):
+        """
+        Transform a date value to an object compatible with what is expected
+        by the backend driver for date columns.
+        """
+        if value is None:
+            return None
+        return value.strftime('%Y-%m-%d')
+
+    def value_to_db_datetime(self, value):
+        """
+        Transform a datetime value to an object compatible with what is expected
+        by the backend driver for date columns.
+        """
+        if value is None:
+            return None
+        return unicode(value) # XXX: Why not just str(value)?
+
+    def value_to_db_time(self, value):
+        """
+        Transform a datetime value to an object compatible with what is expected
+        by the backend driver for date columns.
+        """
+        if value is None:
+            return None
+        return unicode(value) # XXX: Why not just str(value)?
+
+    def value_to_db_decimal(self, value, max_digits, decimal_places):
+        """
+        Transform a decimal.Decimal value to an object compatible with what is
+        expected by the backend driver for decimal (numeric) columns.
+        """
+        if value is None:
+            return None
+        return util.format_number(value, max_digits, decimal_places)

django/db/backends/mysql/base.py

@@ -131 +131 @@
         else:
             return []
 
+    def value_to_db_datetime(self, value):
+        # MySQL doesn't support microseconds
+        if value is None:
+            return None
+        # XXX: Why not just str(value)?
+        return unicode(value.replace(microsecond=0))
+
+    def value_to_db_time(self, value):
+        # MySQL doesn't support microseconds
+        if value is None:
+            return None
+        # XXX: Why not just str(value)?
+        return unicode(value.replace(microsecond=0))
+
 class DatabaseWrapper(BaseDatabaseWrapper):
     features = DatabaseFeatures()
     ops = DatabaseOperations()

django/db/backends/oracle/base.py

@@ -5 +5 @@
 """
 
 import os
+import datetime
+import time
 
 from django.db.backends import BaseDatabaseWrapper, BaseDatabaseFeatures, BaseDatabaseOperations, util
 from django.db.backends.oracle import query
@@ -183 +185 @@
     def tablespace_sql(self, tablespace, inline=False):
         return "%sTABLESPACE %s" % ((inline and "USING INDEX " or ""), self.quote_name(tablespace))
 
+    def value_to_db_time(self, value):
+        if value is None:
+            return None
+        if isinstance(value, basestring):
+            return datetime.datetime(*(time.strptime(value, '%H:%M:%S')[:6]))
+        return datetime.datetime(1900, 1, 1, value.hour, value.minute,
+                                 value.second, value.microsecond)
+
 class DatabaseWrapper(BaseDatabaseWrapper):
     features = DatabaseFeatures()
     ops = DatabaseOperations()

django/db/backends/sqlite3/base.py

@@ -150 +150 @@
     try:
         dt = util.typecast_timestamp(dt)
     except (ValueError, TypeError):
+        print "error!"
         return None
-    return str(getattr(dt, lookup_type))
+    return getattr(dt, lookup_type)
 
 def _sqlite_date_trunc(lookup_type, dt):
     try:

django/db/backends/util.py

@@ -117 +117 @@
     hash = md5.md5(name).hexdigest()[:4]
 
     return '%s%s' % (name[:length-4], hash)
+
+def format_number(value, max_digits, decimal_places):
+    """
+    Formats a number into a string with the requisite number of digits and
+    decimal places.
+    """
+    return u"%.*f" % (decimal_places, value)

django/db/models/fields/__init__.py

@@ -252 +252 @@
                 value = int(value)
             except ValueError:
                 raise ValueError("The __year lookup type requires an integer argument")
+            if settings.DATABASE_ENGINE.endswith('zxjdbc'):
+                # zxJDBC drivers should support dates
+                first = datetime.datetime(value, 1, 1)
+                second = datetime.datetime(value, 12, 31,
+                                           23, 59, 59, 999999)
+                return (first, second)
             if settings.DATABASE_ENGINE == 'sqlite3':
                 first = '%s-01-01'
                 second = '%s-12-31 23:59:59.999999'
@@ -453 +459 @@
         except (TypeError, ValueError):
             raise validators.ValidationError, _("This value must be an integer.")
 
+    def get_db_prep_save(self, value):
+        if value is None:
+            return None
+        return int(value)
+
+    def get_db_prep_lookup(self, lookup_type, value):
+        if lookup_type == 'range':
+            value = [int(v) for v in value]
+        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
+            value = int(value)
+        return Field.get_db_prep_lookup(self, lookup_type, value)
+
     def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False, follow=True):
         if not rel:
             return [] # Don't add a FormField unless it's in a related context.
@@ -492 +510 @@
         if value in ('f', 'False', '0'): return False
         raise validators.ValidationError, _("This value must be either True or False.")
 
+    def get_db_prep_save(self, value):
+        if value is None:
+            return None
+        return bool(value)
+
+    def get_db_prep_lookup(self, lookup_type, value):
+        if lookup_type == 'exact' and value is not None:
+            value = bool(value)
+        return Field.get_db_prep_lookup(self, lookup_type, value)
+
     def get_manipulator_field_objs(self):
         return [oldforms.CheckboxField]
 
@@ -554 +582 @@
             raise validators.ValidationError, _('Enter a valid date in YYYY-MM-DD format.')
 
     def get_db_prep_lookup(self, lookup_type, value):
+        value_to_db_date = connection.ops.value_to_db_date
         if lookup_type == 'range':
-            value = [smart_unicode(v) for v in value]
-        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte') and hasattr(value, 'strftime'):
-            value = value.strftime('%Y-%m-%d')
-        else:
-            value = smart_unicode(value)
+            value = [value_to_db_date(self.to_python(v)) for v in value]
+        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
+            # Lookups with a date argument
+            value = value_to_db_date(self.to_python(value))
+        # else:
+        #    value = smart_unicode(value)
         return Field.get_db_prep_lookup(self, lookup_type, value)
 
     def pre_save(self, model_instance, add):
@@ -586 +616 @@
             return self.editable or self.auto_now or self.auto_now_add
 
     def get_db_prep_save(self, value):
-        # Casts dates into string format for entry into database.
-        if value is not None:
-            try:
-                value = value.strftime('%Y-%m-%d')
-            except AttributeError:
-                # If value is already a string it won't have a strftime method,
-                # so we'll just let it pass through.
-                pass
-        return Field.get_db_prep_save(self, value)
+        # Casts dates into the format expected by the backend
+        return connection.ops.value_to_db_date(self.to_python(value))
 
     def get_manipulator_field_objs(self):
         return [oldforms.DateField]
@@ -631 +654 @@
                     raise validators.ValidationError, _('Enter a valid date/time in YYYY-MM-DD HH:MM format.')
 
     def get_db_prep_save(self, value):
-        # Casts dates into string format for entry into database.
-        if value is not None:
-            # MySQL will throw a warning if microseconds are given, because it
-            # doesn't support microseconds.
-            if not connection.features.supports_usecs and hasattr(value, 'microsecond'):
-                value = value.replace(microsecond=0)
-            value = smart_unicode(value)
-        return Field.get_db_prep_save(self, value)
+        # Casts dates into the format expected by the backend
+        return connection.ops.value_to_db_datetime(self.to_python(value))
 
     def get_db_prep_lookup(self, lookup_type, value):
+        value_to_db_datetime = connection.ops.value_to_db_datetime
         if lookup_type == 'range':
-            value = [smart_unicode(v) for v in value]
-        else:
-            value = smart_unicode(value)
+            value = [value_to_db_datetime(self.to_python(v)) for v in value]
+        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
+            value = value_to_db_datetime(self.to_python(value))
         return Field.get_db_prep_lookup(self, lookup_type, value)
 
     def get_manipulator_field_objs(self):
@@ -705 +723 @@
         Formats a number into a string with the requisite number of digits and
         decimal places.
         """
-        num_chars = self.max_digits
-        # Allow for a decimal point
-        if self.decimal_places > 0:
-            num_chars += 1
-        # Allow for a minus sign
-        if value < 0:
-            num_chars += 1
+        # Method moved to django.db.backends.util.
+        #
+        # It is preserved because it is used by the oracle backend
+        # (django.db.backends.oracle.query), and also for
+        # backwards-compatibility with any external code which may have used
+        # this method.
+        from django.db.backends import util
+        return util.format_number(value, self.max_digits, self.decimal_places)
 
-        return u"%.*f" % (self.decimal_places, value)
-
     def get_db_prep_save(self, value):
-        value = self._format(value)
-        return super(DecimalField, self).get_db_prep_save(value)
+        return connection.ops.value_to_db_decimal(value, self.max_digits,
+                                                  self.decimal_places)
 
     def get_db_prep_lookup(self, lookup_type, value):
+        value_to_db_decimal = connection.ops.value_to_db_decimal
         if lookup_type == 'range':
-            value = [self._format(v) for v in value]
+            value = [value_to_db_decimal(v, self.max_digits,
+                                         self.decimal_places)
+                     for v in value]
         else:
-            value = self._format(value)
+            value = value_to_db_decimal(value, self.max_digits,
+                                        self.decimal_places)
         return super(DecimalField, self).get_db_prep_lookup(lookup_type, value)
 
     def get_manipulator_field_objs(self):
@@ -898 +919 @@
 class FloatField(Field):
     empty_strings_allowed = False
 
+    def get_db_prep_save(self, value):
+        if value is None:
+            return None
+        return float(value)
+
+    def get_db_prep_lookup(self, lookup_type, value):
+        if lookup_type == 'range':
+            value = [float(v) for v in value]
+        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
+            value = float(value)
+        return Field.get_db_prep_lookup(self, lookup_type, value)
+
     def get_manipulator_field_objs(self):
         return [oldforms.FloatField]
 
@@ -948 +981 @@
 
 class IntegerField(Field):
     empty_strings_allowed = False
+    def get_db_prep_save(self, value):
+        if value is None:
+            return None
+        return int(value)
+
+    def get_db_prep_lookup(self, lookup_type, value):
+        if lookup_type == 'range':
+            value = [int(v) for v in value]
+        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
+            value = int(value)
+        return Field.get_db_prep_lookup(self, lookup_type, value)
+
     def get_manipulator_field_objs(self):
         return [oldforms.IntegerField]
 
@@ -995 +1040 @@
         if value in ('f', 'False', '0'): return False
         raise validators.ValidationError, _("This value must be either None, True or False.")
 
+    def get_db_prep_save(self, value):
+        if value is None:
+            return None
+        return bool(value)
+
+    def get_db_prep_lookup(self, lookup_type, value):
+        if lookup_type == 'exact' and value is not None:
+            value = bool(value)
+        return Field.get_db_prep_lookup(self, lookup_type, value)
+
+
     def get_manipulator_field_objs(self):
         return [oldforms.NullBooleanField]
 
@@ -1003 +1059 @@
         defaults.update(kwargs)
         return super(NullBooleanField, self).formfield(**defaults)
 
-class PhoneNumberField(IntegerField):
+class PhoneNumberField(Field):
     def get_manipulator_field_objs(self):
         return [oldforms.PhoneNumberField]
 
@@ -1085 +1141 @@
     def get_internal_type(self):
         return "TimeField"
 
+    def to_python(self, value):
+        if value is None:
+            return None
+        if isinstance(value, datetime.time):
+            return value
+        try: # Seconds are optional, so try converting seconds first.
+            return datetime.time(*time.strptime(value, '%H:%M:%S')[3:6])
+        except ValueError:
+            try: # Try without seconds.
+                return datetime.datetime(*time.strptime(value, '%H:%M')[:5])
+            except ValueError:
+                raise validators.ValidationError, _('Enter a valid time in HH:MM[:ss] format.')
+
     def get_db_prep_lookup(self, lookup_type, value):
-        if connection.features.time_field_needs_date:
-            # Oracle requires a date in order to parse.
-            def prep(value):
-                if isinstance(value, datetime.time):
-                    value = datetime.datetime.combine(datetime.date(1900, 1, 1), value)
-                return smart_unicode(value)
-        else:
-            prep = smart_unicode
+        value_to_db_time = connection.ops.value_to_db_time
         if lookup_type == 'range':
-            value = [prep(v) for v in value]
-        else:
-            value = prep(value)
+            value = [value_to_db_time(self.to_python(v)) for v in value]
+        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
+            value = value_to_db_time(self.to_python(value))
         return Field.get_db_prep_lookup(self, lookup_type, value)
 
     def pre_save(self, model_instance, add):
@@ -1109 +1171 @@
             return super(TimeField, self).pre_save(model_instance, add)
 
     def get_db_prep_save(self, value):
-        # Casts dates into string format for entry into database.
-        if value is not None:
-            # MySQL will throw a warning if microseconds are given, because it
-            # doesn't support microseconds.
-            if not connection.features.supports_usecs and hasattr(value, 'microsecond'):
-                value = value.replace(microsecond=0)
-            if connection.features.time_field_needs_date:
-                # cx_Oracle expects a datetime.datetime to persist into TIMESTAMP field.
-                if isinstance(value, datetime.time):
-                    value = datetime.datetime(1900, 1, 1, value.hour, value.minute,
-                                              value.second, value.microsecond)
-                elif isinstance(value, basestring):
-                    value = datetime.datetime(*(time.strptime(value, '%H:%M:%S')[:6]))
-            else:
-                value = smart_unicode(value)
-        return Field.get_db_prep_save(self, value)
+        # Casts times into the format expected by the backend
+        return connection.ops.value_to_db_time(self.to_python(value))
 
     def get_manipulator_field_objs(self):
         return [oldforms.TimeField]

tests/modeltests/custom_methods/models.py

@@ -31 +31 @@
             SELECT id, headline, pub_date
             FROM custom_methods_article
             WHERE pub_date = %s
-                AND id != %s""", [str(self.pub_date), self.id])
+                AND id != %s""", [connection.ops.value_to_db_date(self.pub_date),
+                                  self.id])
         # The asterisk in "(*row)" tells Python to expand the list into
         # positional arguments to Article().
         return [self.__class__(*row) for row in cursor.fetchall()]