Fixed bug when the fetched data type of a column changes from

oracledb.DB_TYPE_LONG or oracledb.DB_TYPE_LONG_RAW to to a different
compatible type (#424).

Author: anthony-tuininga

doc/src/release_notes.rst

@@ -14,6 +14,14 @@ of python-oracledb), as affecting the optional :ref:`Thick Mode
 oracledb 2.5.1 (TBD)
 --------------------
 
+Thin Mode Changes
++++++++++++++++++
+
+#)  Fixed bug when the fetched data type of a column changes from
+    :data:`oracledb.DB_TYPE_LONG` or :data:`oracledb.DB_TYPE_LONG_RAW` to
+    to a different compatible type
+    (`issue 424 <https://github.com/oracle/python-oracledb/issues/424>`__).
+
 Thick Mode Changes
 ++++++++++++++++++
 
@@ -24,6 +32,7 @@ Thick Mode Changes
     older) to connect to Oracle Database 12.2, or later.
     (`ODPI-C <https://github.com/oracle/odpi>`__ dependency update).
 
+
 oracledb 2.5.0 (November 2024)
 ------------------------------
 

src/oracledb/impl/thin/messages.pyx

@@ -375,21 +375,31 @@ cdef class MessageWithData(Message):
         """
         cdef:
             FetchInfoImpl prev_fetch_info = prev_var_impl._fetch_info
-            uint8_t csfrm = prev_var_impl.dbtype._csfrm
-            uint8_t type_num
-        if fetch_info.dbtype._ora_type_num == TNS_DATA_TYPE_CLOB \
+            uint8_t type_num, csfrm
+        if fetch_info.dbtype._ora_type_num == TNS_DATA_TYPE_VARCHAR \
+                and prev_fetch_info.dbtype._ora_type_num == TNS_DATA_TYPE_LONG:
+            type_num = TNS_DATA_TYPE_LONG
+            csfrm = fetch_info.dbtype._csfrm
+            fetch_info.dbtype = DbType._from_ora_type_and_csfrm(type_num, csfrm)
+
+        elif fetch_info.dbtype._ora_type_num == TNS_DATA_TYPE_RAW \
+                and prev_fetch_info.dbtype._ora_type_num == \
+                        TNS_DATA_TYPE_LONG_RAW:
+            type_num = TNS_DATA_TYPE_LONG_RAW
+            fetch_info.dbtype = DbType._from_ora_type_and_csfrm(type_num, 0)
+        elif fetch_info.dbtype._ora_type_num == TNS_DATA_TYPE_CLOB \
                 and prev_fetch_info.dbtype._ora_type_num in \
                         (TNS_DATA_TYPE_CHAR, TNS_DATA_TYPE_VARCHAR,
                          TNS_DATA_TYPE_LONG):
             type_num = TNS_DATA_TYPE_LONG
+            csfrm = prev_var_impl.dbtype._csfrm
             fetch_info.dbtype = DbType._from_ora_type_and_csfrm(type_num,
                                                                 csfrm)
         elif fetch_info.dbtype._ora_type_num == TNS_DATA_TYPE_BLOB \
                 and prev_fetch_info.dbtype._ora_type_num in \
                         (TNS_DATA_TYPE_RAW, TNS_DATA_TYPE_LONG_RAW):
             type_num = TNS_DATA_TYPE_LONG_RAW
-            fetch_info.dbtype = DbType._from_ora_type_and_csfrm(type_num,
-                                                                csfrm)
+            fetch_info.dbtype = DbType._from_ora_type_and_csfrm(type_num, 0)
 
     cdef object _create_cursor_from_describe(self, ReadBuffer buf,
                                              object cursor=None):

tests/test_4600_type_changes.py

@@ -29,6 +29,7 @@
 import datetime
 import unittest
 
+import oracledb
 import test_env
 
 
@@ -40,27 +41,33 @@ def __test_type_change(
         query_frag_2,
         query_value_2,
         table_name="dual",
+        type_handler=None,
     ):
         if test_env.get_is_implicit_pooling():
             self.skipTest("sessions can change with implicit pooling")
-        self.cursor.execute(
-            f"""
-            create or replace view TestTypesChanged as
-            select {query_frag_1} as value
-            from {table_name}
-            """
-        )
-        self.cursor.execute("select * from TestTypesChanged")
-        self.assertEqual(self.cursor.fetchall(), [(query_value_1,)])
-        self.cursor.execute(
-            f"""
-            create or replace view TestTypesChanged as
-                select {query_frag_2} as value
-                from dual
-            """
-        )
-        self.cursor.execute("select * from TestTypesChanged")
-        self.assertEqual(self.cursor.fetchall(), [(query_value_2,)])
+        orig_type_handler = self.conn.outputtypehandler
+        self.conn.outputtypehandler = type_handler
+        try:
+            self.cursor.execute(
+                f"""
+                create or replace view TestTypesChanged as
+                select {query_frag_1} as value
+                from {table_name}
+                """
+            )
+            self.cursor.execute("select * from TestTypesChanged")
+            self.assertEqual(self.cursor.fetchall(), [(query_value_1,)])
+            self.cursor.execute(
+                f"""
+                create or replace view TestTypesChanged as
+                    select {query_frag_2} as value
+                    from dual
+                """
+            )
+            self.cursor.execute("select * from TestTypesChanged")
+            self.assertEqual(self.cursor.fetchall(), [(query_value_2,)])
+        finally:
+            self.conn.outputtypehandler = orig_type_handler
 
     @unittest.skipIf(
         not test_env.get_is_thin(),
@@ -273,6 +280,111 @@ def test_4616(self):
             datetime.datetime(2022, 1, 5, 0, 0),
         )
 
+    @unittest.skipIf(
+        not test_env.get_is_thin(),
+        "thick mode doesn't support this type change",
+    )
+    def test_4617(self):
+        "4617 - test data type changing from CLOB to VARCHAR"
+
+        def type_handler(cursor, metadata):
+            if metadata.type_code is oracledb.DB_TYPE_CLOB:
+                return cursor.var(
+                    oracledb.DB_TYPE_VARCHAR,
+                    size=32768,
+                    arraysize=cursor.arraysize,
+                )
+
+        self.__test_type_change(
+            "to_clob('clob_4617')",
+            "clob_4617",
+            "cast('string_4617' as VARCHAR2(15))",
+            "string_4617",
+            type_handler=type_handler,
+        )
+
+    @unittest.skipIf(
+        not test_env.get_is_thin(),
+        "thick mode doesn't support this type change",
+    )
+    def test_4618(self):
+        "4618 - test data type changing from NCLOB to NVARCHAR"
+
+        def type_handler(cursor, metadata):
+            if metadata.type_code is oracledb.DB_TYPE_NCLOB:
+                return cursor.var(
+                    oracledb.DB_TYPE_NVARCHAR,
+                    size=32768,
+                    arraysize=cursor.arraysize,
+                )
+
+        self.__test_type_change(
+            "to_nclob('nclob_4618')",
+            "nclob_4618",
+            "cast('nstring_4618' as NVARCHAR2(15))",
+            "nstring_4618",
+            type_handler=type_handler,
+        )
+
+    @unittest.skipIf(
+        not test_env.get_is_thin(),
+        "thick mode doesn't support this type change",
+    )
+    def test_4619(self):
+        "4619 - test data type changing from CLOB to NVARCHAR"
+
+        def type_handler(cursor, metadata):
+            if metadata.type_code is oracledb.DB_TYPE_CLOB:
+                return cursor.var(
+                    oracledb.DB_TYPE_NVARCHAR,
+                    size=32768,
+                    arraysize=cursor.arraysize,
+                )
+
+        self.__test_type_change(
+            "to_clob('clob_4619')",
+            "clob_4619",
+            "cast('string_4619' as VARCHAR2(15))",
+            "string_4619",
+            type_handler=type_handler,
+        )
+
+    @unittest.skipIf(
+        not test_env.get_is_thin(),
+        "thick mode doesn't support this type change",
+    )
+    def test_4620(self):
+        "4620 - test data type changing from BLOB to RAW"
+
+        def type_handler(cursor, metadata):
+            if metadata.type_code is oracledb.DB_TYPE_BLOB:
+                return cursor.var(
+                    oracledb.DB_TYPE_RAW,
+                    size=32768,
+                    arraysize=cursor.arraysize,
+                )
+
+        self.__test_type_change(
+            "to_blob(utl_raw.cast_to_raw('blob_4620'))",
+            b"blob_4620",
+            "utl_raw.cast_to_raw('string_4620')",
+            b"string_4620",
+            type_handler=type_handler,
+        )
+
+    @unittest.skipIf(
+        not test_env.get_is_thin(),
+        "thick mode doesn't support this type change",
+    )
+    def test_4621(self):
+        "4621 - test data type changing from NVARCHAR to CLOB"
+        self.__test_type_change(
+            "cast('string_4621' as NVARCHAR2(15))",
+            "string_4621",
+            "to_clob('clob_4621')",
+            "clob_4621",
+        )
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()