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

@@ -26,6 +26,10 @@ Thin Mode Changes
     id=GUID-490A0B3B-FEF3-425A-81B0-6FA29D4B8C0E>`__ parameter to TRUE),
     python-oracledb no longer attempts to do so
     (`issue 419 <https://github.com/oracle/python-oracledb/issues/419>`__).
+#)  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>`__).
 #)  Error ``DPY-6002: The distinguished name (DN) on the server certificate
     does not match the expected value: "{expected_dn}"`` now shows the expected
     value.

src/oracledb/impl/thin/messages.pyx

@@ -370,23 +370,36 @@ cdef class MessageWithData(Message):
         previously returned was CHAR/VARCHAR/RAW (or the equivalent long
         types), then the server returns the data as LONG (RAW), similarly to
         what happens when a define is done to return CLOB/BLOB as string/bytes.
-        Detect this situation and adjust the fetch type appropriately.
+        In addition, if the data type returned was previously LONG or LONG RAW,
+        and the new type is VARCHAR or RAW, the database continues to return
+        LONG or LONG RAW. Detect these situations and adjust the fetch type
+        appropriately.
         """
         cdef:
             OracleMetadata prev_metadata = prev_var_impl._fetch_metadata
-            uint8_t csfrm = prev_metadata.dbtype._csfrm
-            uint8_t type_num
-        if metadata.dbtype._ora_type_num == ORA_TYPE_NUM_CLOB \
+            uint8_t type_num, csfrm
+        if metadata.dbtype._ora_type_num == ORA_TYPE_NUM_VARCHAR \
+                and prev_metadata.dbtype._ora_type_num == ORA_TYPE_NUM_LONG:
+            type_num = ORA_TYPE_NUM_LONG
+            csfrm = metadata.dbtype._csfrm
+            metadata.dbtype = DbType._from_ora_type_and_csfrm(type_num, csfrm)
+
+        elif metadata.dbtype._ora_type_num == ORA_TYPE_NUM_RAW \
+                and prev_metadata.dbtype._ora_type_num == ORA_TYPE_NUM_LONG_RAW:
+            type_num = ORA_TYPE_NUM_LONG_RAW
+            metadata.dbtype = DbType._from_ora_type_and_csfrm(type_num, 0)
+        elif metadata.dbtype._ora_type_num == ORA_TYPE_NUM_CLOB \
                 and prev_metadata.dbtype._ora_type_num in \
                         (ORA_TYPE_NUM_CHAR, ORA_TYPE_NUM_VARCHAR,
                          ORA_TYPE_NUM_LONG):
             type_num = ORA_TYPE_NUM_LONG
+            csfrm = prev_metadata.dbtype._csfrm
             metadata.dbtype = DbType._from_ora_type_and_csfrm(type_num, csfrm)
         elif metadata.dbtype._ora_type_num == ORA_TYPE_NUM_BLOB \
                 and prev_metadata.dbtype._ora_type_num in \
                         (ORA_TYPE_NUM_RAW, ORA_TYPE_NUM_LONG_RAW):
             type_num = ORA_TYPE_NUM_LONG_RAW
-            metadata.dbtype = DbType._from_ora_type_and_csfrm(type_num, csfrm)
+            metadata.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()