Ticket #6767: 6767.diff

django/db/backends/oracle/base.py

@@ -7 +7 @@
 import os
 import datetime
 import time
+from decimal import Decimal
 
 # Oracle takes client-side character set encoding from the environment.
 os.environ['NLS_LANG'] = '.UTF8'
@@ -287 +288 @@
                 pass
         if not cursor:
             cursor = FormatStylePlaceholderCursor(self.connection)
+        # Necessary to retrieve decimal values without rounding error.
+        cursor.numbersAsStrings = True
         # Default arraysize of 1 is highly sub-optimal.
         cursor.arraysize = 100
         return cursor
@@ -390 +393 @@
         row = Database.Cursor.fetchone(self)
         if row is None:
             return row
-        return tuple([to_unicode(e) for e in row])
+        return self._rowfactory(row)
 
     def fetchmany(self, size=None):
         if size is None:
             size = self.arraysize
-        return tuple([tuple([to_unicode(e) for e in r])
+        return tuple([self._rowfactory(r)
                       for r in Database.Cursor.fetchmany(self, size)])
 
     def fetchall(self):
-        return tuple([tuple([to_unicode(e) for e in r])
+        return tuple([self._rowfactory(r)
                       for r in Database.Cursor.fetchall(self)])
 
+    def _rowfactory(self, row):
+        # Cast numeric values as the appropriate Python type based upon the
+        # cursor description, and convert strings to unicode.
+        casted = []
+        for value, desc in zip(row, self.description):
+            if value is not None and desc[1] is Database.NUMBER:
+                precision, scale = desc[4:6]
+                if scale == -127:
+                    if precision == 0:
+                        # NUMBER column: decimal-precision floating point
+                        # This will normally be an integer from a sequence,
+                        # but it could be a decimal value.
+                        if '.' in value:
+                            value = Decimal(value)
+                        else:
+                            value = int(value)
+                    else:
+                        # FLOAT column: binary-precision floating point.
+                        # This comes from FloatField columns.
+                        value = float(value)
+                elif precision > 0:
+                    # NUMBER(p,s) column: decimal-precision fixed point.
+                    # This comes from IntField and DecimalField columns.
+                    if scale == 0:
+                        value = int(value)
+                    else:
+                        value = Decimal(value)
+                elif '.' in value:
+                    # No type information. This normally comes from a
+                    # mathematical expression in the SELECT list. Guess int
+                    # or Decimal based on whether it has a decimal point.
+                    value = Decimal(value)
+                else:
+                    value = int(value)
+            else:
+                value = to_unicode(value)
+            casted.append(value)
+        return tuple(casted)
 
+
 def to_unicode(s):
     """
     Convert strings to Unicode objects (and return all other data types

django/db/backends/oracle/query.py

@@ -66 +66 @@
             # Convert 1 or 0 to True or False
             elif value in (1, 0) and isinstance(field, (BooleanField, NullBooleanField)):
                 value = bool(value)
-            # Convert floats to decimals
-            elif value is not None and isinstance(field, DecimalField):
-                value = util.typecast_decimal(field.format_number(value))
             # cx_Oracle always returns datetime.datetime objects for
             # DATE and TIMESTAMP columns, but Django wants to see a
             # python datetime.date, .time, or .datetime.  We use the type