Rework handling of numbers so that, unless using the NATIVE_INT,

NATIVE_FLOAT or NATIVE_DOUBLE types, all numbers are converted to strings and
passed through to ODPI-C in all Python versions; improved error message when
a value cannot be represented by an Oracle number value; improved test suite to
verify that calling executemany() with integers, floats and decimal values
intermixed with each other works as expected
(oracle#241).

Author: anthony-tuininga

odpi

@@ -186,7 +186,6 @@ typedef enum {
     CXO_TRANSFORM_FLOAT,
     CXO_TRANSFORM_INT,
     CXO_TRANSFORM_LONG_BINARY,
-    CXO_TRANSFORM_LONG_INT,
     CXO_TRANSFORM_LONG_STRING,
     CXO_TRANSFORM_NATIVE_DOUBLE,
     CXO_TRANSFORM_NATIVE_FLOAT,

src/cxoModule.h

@@ -175,12 +175,11 @@ static int cxoObject_convertFromPython(cxoObject *obj, PyObject *value,
     }
 
     // convert the different Python types
-    transformNum = cxoTransform_getNumFromValue(value, 1);
+    cxoTransform_getTypeInfo(transformNum, &oracleTypeNum, nativeTypeNum);
     if (cxoTransform_fromPython(transformNum, value, &data->value, buffer,
             obj->objectType->connection->encodingInfo.encoding,
             obj->objectType->connection->encodingInfo.nencoding, NULL, 0) < 0)
         return -1;
-    cxoTransform_getTypeInfo(transformNum, &oracleTypeNum, nativeTypeNum);
     data->isNull = 0;
     return 0;
 }
@@ -220,9 +219,11 @@ static PyObject *cxoObject_getAttributeValue(cxoObject *obj,
     }
     cxoTransform_getTypeInfo(attribute->transformNum, &oracleTypeNum,
             &nativeTypeNum);
-    if (attribute->transformNum == CXO_TRANSFORM_LONG_INT) {
+    if (oracleTypeNum == DPI_ORACLE_TYPE_NUMBER &&
+            nativeTypeNum == DPI_NATIVE_TYPE_BYTES) {
         data.value.asBytes.ptr = numberAsStringBuffer;
         data.value.asBytes.length = sizeof(numberAsStringBuffer);
+        data.value.asBytes.encoding = NULL;
     }
     if (dpiObject_getAttributeValue(obj->handle, attribute->handle,
             nativeTypeNum, &data) < 0)
@@ -374,9 +375,11 @@ static PyObject *cxoObject_internalGetElementByIndex(cxoObject *obj,
     }
     cxoTransform_getTypeInfo(obj->objectType->elementTransformNum,
             &oracleTypeNum, &nativeTypeNum);
-    if (obj->objectType->elementTransformNum == CXO_TRANSFORM_LONG_INT) {
+    if (oracleTypeNum == DPI_ORACLE_TYPE_NUMBER &&
+            nativeTypeNum == DPI_NATIVE_TYPE_BYTES) {
         data.value.asBytes.ptr = numberAsStringBuffer;
         data.value.asBytes.length = sizeof(numberAsStringBuffer);
+        data.value.asBytes.encoding = NULL;
     }
     if (dpiObject_getElementValueByIndex(obj->handle, index, nativeTypeNum,
                 &data) < 0)

src/cxoObject.c

@@ -104,23 +104,18 @@ static const cxoTransform cxoAllTransforms[] = {
     {
         CXO_TRANSFORM_FLOAT,
         DPI_ORACLE_TYPE_NUMBER,
-        DPI_NATIVE_TYPE_DOUBLE
+        DPI_NATIVE_TYPE_BYTES
     },
     {
         CXO_TRANSFORM_INT,
         DPI_ORACLE_TYPE_NUMBER,
-        DPI_NATIVE_TYPE_INT64
+        DPI_NATIVE_TYPE_BYTES
     },
     {
         CXO_TRANSFORM_LONG_BINARY,
         DPI_ORACLE_TYPE_LONG_RAW,
         DPI_NATIVE_TYPE_BYTES
     },
-    {
-        CXO_TRANSFORM_LONG_INT,
-        DPI_ORACLE_TYPE_NUMBER,
-        DPI_NATIVE_TYPE_BYTES
-    },
     {
         CXO_TRANSFORM_LONG_STRING,
         DPI_ORACLE_TYPE_LONG_VARCHAR,
@@ -252,7 +247,6 @@ int cxoTransform_fromPython(cxoTransformNum transformNum, PyObject *pyValue,
                     buffer->size);
             Py_END_ALLOW_THREADS
             return status;
-        case CXO_TRANSFORM_INT:
         case CXO_TRANSFORM_NATIVE_INT:
 #if PY_MAJOR_VERSION < 3
             if (PyInt_Check(pyValue)) {
@@ -268,8 +262,18 @@ int cxoTransform_fromPython(cxoTransformNum transformNum, PyObject *pyValue,
             if (PyErr_Occurred())
                 return -1;
             return 0;
+        case CXO_TRANSFORM_INT:
         case CXO_TRANSFORM_DECIMAL:
-        case CXO_TRANSFORM_LONG_INT:
+        case CXO_TRANSFORM_FLOAT:
+            if (!PyFloat_Check(pyValue) &&
+#if PY_MAJOR_VERSION < 3
+                    !PyInt_Check(pyValue) &&
+#endif
+                    !PyLong_Check(pyValue) &&
+                    !PyObject_TypeCheck(pyValue, cxoPyTypeDecimal)) {
+                PyErr_SetString(PyExc_TypeError, "expecting number");
+                return -1;
+            }
             textValue = PyObject_Str(pyValue);
             if (!textValue)
                 return -1;
@@ -280,19 +284,6 @@ int cxoTransform_fromPython(cxoTransformNum transformNum, PyObject *pyValue,
             dbValue->asBytes.ptr = (char*) buffer->ptr;
             dbValue->asBytes.length = buffer->size;
             return 0;
-        case CXO_TRANSFORM_FLOAT:
-            if (!PyFloat_Check(pyValue) &&
-#if PY_MAJOR_VERSION < 3
-                    !PyInt_Check(pyValue) &&
-#endif
-                    !PyLong_Check(pyValue)) {
-                PyErr_SetString(PyExc_TypeError, "expecting float");
-                return -1;
-            }
-            dbValue->asDouble = PyFloat_AsDouble(pyValue);
-            if (PyErr_Occurred())
-                return -1;
-            return 0;
         case CXO_TRANSFORM_NATIVE_DOUBLE:
         case CXO_TRANSFORM_NATIVE_FLOAT:
             if (!PyFloat_Check(pyValue) &&
@@ -380,10 +371,6 @@ int cxoTransform_fromPython(cxoTransformNum transformNum, PyObject *pyValue,
 //-----------------------------------------------------------------------------
 cxoTransformNum cxoTransform_getNumFromDataTypeInfo(dpiDataTypeInfo *info)
 {
-#if PY_MAJOR_VERSION < 3
-    static int maxLongSafeDigits = sizeof(long) >= 8 ? 18 : 9;
-#endif
-
     switch (info->oracleTypeNum) {
         case DPI_ORACLE_TYPE_VARCHAR:
             return CXO_TRANSFORM_STRING;
@@ -403,14 +390,8 @@ cxoTransformNum cxoTransform_getNumFromDataTypeInfo(dpiDataTypeInfo *info)
             return CXO_TRANSFORM_NATIVE_FLOAT;
         case DPI_ORACLE_TYPE_NUMBER:
             if (info->scale == 0 ||
-                    (info->scale == -127 && info->precision == 0)) {
-#if PY_MAJOR_VERSION < 3
-                if (info->precision > 0 &&
-                        info->precision <= maxLongSafeDigits)
-                    return CXO_TRANSFORM_INT;
-#endif
-                return CXO_TRANSFORM_LONG_INT;
-            }
+                    (info->scale == -127 && info->precision == 0))
+                return CXO_TRANSFORM_INT;
             return CXO_TRANSFORM_FLOAT;
         case DPI_ORACLE_TYPE_NATIVE_INT:
             return CXO_TRANSFORM_NATIVE_INT;
@@ -479,7 +460,7 @@ cxoTransformNum cxoTransform_getNumFromType(PyTypeObject *type)
     if (type == &PyFloat_Type)
         return CXO_TRANSFORM_FLOAT;
     if (type == &PyLong_Type)
-        return CXO_TRANSFORM_LONG_INT;
+        return CXO_TRANSFORM_INT;
     if (type == cxoPyTypeDecimal)
         return CXO_TRANSFORM_DECIMAL;
     if (type == &cxoPyTypeNumberVar)
@@ -558,7 +539,7 @@ cxoTransformNum cxoTransform_getNumFromValue(PyObject *value, int plsql)
         return CXO_TRANSFORM_INT;
 #endif
     if (PyLong_Check(value))
-        return CXO_TRANSFORM_LONG_INT;
+        return CXO_TRANSFORM_INT;
     if (PyFloat_Check(value))
         return CXO_TRANSFORM_FLOAT;
     if (PyDateTime_Check(value))
@@ -703,44 +684,42 @@ PyObject *cxoTransform_toPython(cxoTransformNum transformNum,
                     timestamp->month, timestamp->day, timestamp->hour,
                     timestamp->minute, timestamp->second,
                     timestamp->fsecond / 1000);
-        case CXO_TRANSFORM_DECIMAL:
-            bytes = &dbValue->asBytes;
-            stringObj = cxoPyString_fromEncodedString(bytes->ptr,
-                    bytes->length, bytes->encoding, encodingErrors);
-            if (!stringObj)
-                return NULL;
-            result = PyObject_CallFunctionObjArgs(
-                    (PyObject*) cxoPyTypeDecimal, stringObj, NULL);
-            Py_DECREF(stringObj);
-            return result;
         case CXO_TRANSFORM_FIXED_NCHAR:
         case CXO_TRANSFORM_NSTRING:
             bytes = &dbValue->asBytes;
             return PyUnicode_Decode(bytes->ptr, bytes->length, bytes->encoding,
                     encodingErrors);
-        case CXO_TRANSFORM_FLOAT:
         case CXO_TRANSFORM_NATIVE_DOUBLE:
             return PyFloat_FromDouble(dbValue->asDouble);
         case CXO_TRANSFORM_NATIVE_FLOAT:
             return PyFloat_FromDouble(dbValue->asFloat);
-        case CXO_TRANSFORM_INT:
         case CXO_TRANSFORM_NATIVE_INT:
             return PyInt_FromLong((long) dbValue->asInt64);
-        case CXO_TRANSFORM_LONG_INT:
+        case CXO_TRANSFORM_DECIMAL:
+        case CXO_TRANSFORM_INT:
+        case CXO_TRANSFORM_FLOAT:
             bytes = &dbValue->asBytes;
             stringObj = cxoPyString_fromEncodedString(bytes->ptr,
-                    bytes->length, NULL, NULL);
+                    bytes->length, bytes->encoding, encodingErrors);
             if (!stringObj)
                 return NULL;
+            if (transformNum == CXO_TRANSFORM_INT &&
+                    memchr(bytes->ptr, '.', bytes->length) == NULL) {
 #if PY_MAJOR_VERSION >= 3
-            result = PyNumber_Long(stringObj);
+                result = PyNumber_Long(stringObj);
 #else
-            result = PyNumber_Int(stringObj);
+                result = PyNumber_Int(stringObj);
 #endif
-            if (!result && PyErr_ExceptionMatches(PyExc_ValueError)) {
-                PyErr_Clear();
+                Py_DECREF(stringObj);
+                return result;
+            } else if (transformNum != CXO_TRANSFORM_DECIMAL &&
+                    bytes->length <= 15) {
                 result = PyNumber_Float(stringObj);
+                Py_DECREF(stringObj);
+                return result;
             }
+            result = PyObject_CallFunctionObjArgs(
+                    (PyObject*) cxoPyTypeDecimal, stringObj, NULL);
             Py_DECREF(stringObj);
             return result;
         case CXO_TRANSFORM_OBJECT:

src/cxoTransform.c

@@ -74,23 +74,18 @@ static cxoVarType cxoAllVarTypes[] = {
     {
         CXO_TRANSFORM_FLOAT,
         &cxoPyTypeNumberVar,
-        0
+        1000
     },
     {
         CXO_TRANSFORM_INT,
         &cxoPyTypeNumberVar,
-        0
+        1000
     },
     {
         CXO_TRANSFORM_LONG_BINARY,
         &cxoPyTypeLongBinaryVar,
         128 * 1024
     },
-    {
-        CXO_TRANSFORM_LONG_INT,
-        &cxoPyTypeNumberVar,
-        250,
-    },
     {
         CXO_TRANSFORM_LONG_STRING,
         &cxoPyTypeLongStringVar,

src/cxoVarType.c

@@ -180,6 +180,19 @@ def testExecuteManyMultipleBatches(self):
         self.cursor.executemany(sql, [(1, None), (2, None)])
         self.cursor.executemany(sql, [(3, None), (4, "Testing")])
 
+    def testExecuteManyNumeric(self):
+        "test executemany() with various numeric types"
+        self.cursor.execute("truncate table TestTempTable")
+        data = [(1, 5), (2, 7.0), (3, 6.5), (4, 2 ** 65),
+                (5, decimal.Decimal("24.5"))]
+        sql = "insert into TestTempTable (IntCol, NumberCol) values (:1, :2)"
+        self.cursor.executemany(sql, data)
+        self.cursor.execute("""
+                select IntCol, NumberCol
+                from TestTempTable
+                order by IntCol""")
+        self.assertEqual(self.cursor.fetchall(), data)
+
     def testExecuteManyWithResize(self):
         """test executing a statement multiple times (with resize)"""
         self.cursor.execute("truncate table TestTempTable")

test/Cursor.py

@@ -320,24 +320,42 @@ def testReturnConstantInteger(self):
         self.assertEqual(result, 148)
         self.assertTrue(isinstance(result, int), "integer not returned")
 
-    def testBoundaryNumbers(self):
-        "test that boundary numbers are handled properly"
-        inValues = [float('inf'), 0.0, float('-inf'), 1e126, -1e126]
-        outValues = [10**126, 0, -10**126, 10**126, -10**126]
+    def testAcceptableBoundaryNumbers(self):
+        "test that acceptable boundary numbers are handled properly"
+        inValues = [decimal.Decimal("9.99999999999999e+125"),
+                decimal.Decimal("-9.99999999999999e+125"), 0.0, 1e-130,
+                -1e-130]
+        outValues = [int("9" * 15 + "0" * 111), -int("9" * 15 + "0" * 111),
+                0, decimal.Decimal("1e-130"), decimal.Decimal("-1e-130")]
         for inValue, outValue in zip(inValues, outValues):
             self.cursor.execute("select :1 from dual", (inValue,))
             result, = self.cursor.fetchone()
             self.assertEqual(result, outValue)
 
+    def testUnacceptableBoundaryNumbers(self):
+        "test that unacceptable boundary numbers are rejected"
+        inValues = [1e126, -1e126, float("inf"), float("-inf"),
+                float("NaN"), decimal.Decimal("1e126"),
+                decimal.Decimal("-1e126"), decimal.Decimal("inf"),
+                decimal.Decimal("-inf"), decimal.Decimal("NaN")]
+        noRepErr = "DPI-1044: value cannot be represented as an Oracle number"
+        invalidErr = ""
+        expectedErrors = [noRepErr, noRepErr, invalidErr, invalidErr,
+                invalidErr, noRepErr, noRepErr, invalidErr, invalidErr,
+                invalidErr]
+        for inValue, error in zip(inValues, expectedErrors):
+            self.assertRaisesRegexp(cx_Oracle.DatabaseError, error,
+                    self.cursor.execute, "select :1 from dual", (inValue,))
+
     def testReturnFloatFromDivision(self):
         "test that fetching the result of division returns a float"
         self.cursor.execute("""
                 select IntCol / 7
                 from TestNumbers
                 where IntCol = 1""")
         result, = self.cursor.fetchone()
-        self.assertEqual(result, 1.0 / 7.0)
-        self.assertTrue(isinstance(result, float), "float not returned")
+        self.assertAlmostEqual(result,
+                decimal.Decimal("1") / decimal.Decimal("7"))
 
     def testStringFormat(self):
         "test that string format is returned properly"

test/NumberVar.py

@@ -181,6 +181,7 @@ create table &main_user..TestLongRaws (
 create table &main_user..TestTempTable (
     IntCol                              number(9) not null,
     StringCol                           varchar2(400),
+    NumberCol                           number(25,2),
     constraint TestTempTable_pk primary key (IntCol)
 );