Fixed bug when a DbObject instance contains an attribute of type

SYS.XMLTYPE (#336).

Author: anthony-tuininga

doc/src/release_notes.rst

@@ -17,6 +17,9 @@ oracledb 2.2.1 (TBD)
 Thin Mode Changes
 +++++++++++++++++
 
+#)  Fixed bug when a :ref:`DbObject <dbobject>` instance contains an attribute
+    of type ``SYS.XMLTYPE``
+    (`issue 336 <https://github.com/oracle/python-oracledb/issues/336>`__).
 #)  Fixed bug in statement cache when the maximum number of cursors is unknown
     due to the database not being open.
 #)  Fixed bug in handling redirect data with small SDU sizes.

src/oracledb/impl/thin/dbobject.pyx

@@ -94,6 +94,36 @@ cdef class DbObjectPickleBuffer(GrowableBuffer):
         else:
             length[0] = short_length
 
+    cdef object read_xmltype(self, BaseThinConnImpl conn_impl):
+        """
+        Reads an XML type from the buffer. This is similar to reading a
+        database object but with specialized processing.
+        """
+        cdef:
+            uint8_t image_flags, image_version
+            BaseThinLobImpl lob_impl
+            const char_type *ptr
+            ssize_t bytes_left
+            uint32_t xml_flag
+            type cls
+        self.read_header(&image_flags, &image_version)
+        self.skip_raw_bytes(1)              # XML version
+        self.read_uint32(&xml_flag)
+        if xml_flag & TNS_XML_TYPE_FLAG_SKIP_NEXT_4:
+            self.skip_raw_bytes(4)
+        bytes_left = self.bytes_left()
+        ptr = self.read_raw_bytes(bytes_left)
+        if xml_flag & TNS_XML_TYPE_STRING:
+            return ptr[:bytes_left].decode()
+        elif xml_flag & TNS_XML_TYPE_LOB:
+            lob_impl = conn_impl._create_lob_impl(DB_TYPE_CLOB,
+                                                  ptr[:bytes_left])
+            cls = PY_TYPE_ASYNC_LOB \
+                if conn_impl._protocol._transport._is_async \
+                else PY_TYPE_LOB
+            return cls._from_impl(lob_impl)
+        errors._raise_err(errors.ERR_UNEXPECTED_XML_TYPE, flag=xml_flag)
+
     cdef int skip_length(self) except -1:
         """
         Skips the length instead of reading it from the buffer.
@@ -329,6 +359,7 @@ cdef class ThinDbObjectImpl(BaseDbObjectImpl):
         cdef:
             uint8_t ora_type_num = dbtype._ora_type_num
             uint8_t csfrm = dbtype._csfrm
+            DbObjectPickleBuffer xml_buf
             BaseThinConnImpl conn_impl
             ThinDbObjectImpl obj_impl
             BaseThinLobImpl lob_impl
@@ -370,6 +401,10 @@ cdef class ThinDbObjectImpl(BaseDbObjectImpl):
             buf.get_is_atomic_null(&is_null)
             if is_null:
                 return None
+            if objtype is None:
+                xml_buf = DbObjectPickleBuffer.__new__(DbObjectPickleBuffer)
+                xml_buf._populate_from_bytes(buf.read_bytes())
+                return xml_buf.read_xmltype(self.type._conn_impl)
             obj_impl = ThinDbObjectImpl.__new__(ThinDbObjectImpl)
             obj_impl.type = objtype
             if objtype.is_collection or self.type.is_collection:

src/oracledb/impl/thin/dbobject_cache.pyx

@@ -365,6 +365,40 @@ cdef class BaseThinDbObjectTypeCache:
             errors._raise_err(errors.ERR_TDS_TYPE_NOT_SUPPORTED, num=attr_type)
         return DbType._from_ora_type_and_csfrm(ora_type_num, csfrm)
 
+    cdef int _create_attr(self, ThinDbObjectTypeImpl typ_impl, str name,
+                          str type_name, str type_owner,
+                          str type_package_name=None, bytes oid=None,
+                          int8_t precision=0, int8_t scale=0,
+                          uint32_t max_size=0) except -1:
+        """
+        Creates an attribute from the supplied information and adds it to the
+        list of attributes for the type.
+        """
+        cdef:
+            ThinDbObjectTypeImpl attr_typ_impl
+            ThinDbObjectAttrImpl attr_impl
+        attr_impl = ThinDbObjectAttrImpl.__new__(ThinDbObjectAttrImpl)
+        attr_impl.name = name
+        if type_owner is not None:
+            attr_typ_impl = self.get_type_for_info(oid, type_owner,
+                                                   type_package_name,
+                                                   type_name)
+            if attr_typ_impl.is_xml_type:
+                attr_impl.dbtype = DB_TYPE_XMLTYPE
+            else:
+                attr_impl.dbtype = DB_TYPE_OBJECT
+                attr_impl.objtype = attr_typ_impl
+        else:
+            attr_impl.dbtype = DbType._from_ora_name(type_name)
+            attr_impl.max_size = max_size
+            if precision != 0 or scale != 0:
+                attr_impl.precision = precision
+                attr_impl.scale = scale
+                attr_impl._preferred_num_type = \
+                        get_preferred_num_type(precision, scale)
+        typ_impl.attrs.append(attr_impl)
+        typ_impl.attrs_by_name[name] = attr_impl
+
     cdef object _populate_type_info(self, str name, object attrs,
                                     ThinDbObjectTypeImpl typ_impl):
         """
@@ -389,48 +423,25 @@ cdef class BaseThinDbObjectTypeCache:
         if typ_impl.is_row_type:
             for name, data_type, data_type_owner, max_size, precision, \
                     scale in attrs:
-                attr_impl = ThinDbObjectAttrImpl.__new__(ThinDbObjectAttrImpl)
-                attr_impl.name = name
-                if data_type_owner is not None:
-                    attr_impl.dbtype = DB_TYPE_OBJECT
-                    attr_impl.objtype = self.get_type_for_info(None,
-                                                               data_type_owner,
-                                                               None,
-                                                               data_type)
-                else:
+                if data_type_owner is None:
                     start_pos = data_type.find("(")
                     if start_pos > 0:
                         end_pos = data_type.find(")")
                         if end_pos > start_pos:
                             data_type = data_type[:start_pos] + \
                                     data_type[end_pos + 1:]
-                    attr_impl.dbtype = DbType._from_ora_name(data_type)
-                    attr_impl.max_size = max_size
-                    attr_impl.precision = precision
-                    attr_impl.scale = scale
-                typ_impl.attrs.append(attr_impl)
-                typ_impl.attrs_by_name[name] = attr_impl
+                self._create_attr(typ_impl, name, data_type, data_type_owner,
+                                  None, None, precision, scale, max_size)
         else:
             for cursor_version, attr_name, attr_num, attr_type_name, \
                     attr_type_owner, attr_type_package, attr_type_oid, \
                     attr_instantiable, attr_super_type_owner, \
                     attr_super_type_name in attrs:
                 if attr_name is None:
                     continue
-                attr_impl = ThinDbObjectAttrImpl.__new__(ThinDbObjectAttrImpl)
-                attr_impl.name = attr_name
-                if attr_type_owner is not None:
-                    attr_impl.dbtype = DB_TYPE_OBJECT
-                    attr_impl.objtype = self.get_type_for_info(
-                        attr_type_oid,
-                        attr_type_owner,
-                        attr_type_package,
-                        attr_type_name
-                    )
-                else:
-                    attr_impl.dbtype = DbType._from_ora_name(attr_type_name)
-                typ_impl.attrs.append(attr_impl)
-                typ_impl.attrs_by_name[attr_name] = attr_impl
+                self._create_attr(typ_impl, attr_name, attr_type_name,
+                                  attr_type_owner, attr_type_package,
+                                  attr_type_oid)
             return self._parse_tds(typ_impl, self.tds_var.getvalue())
 
     cdef ThinDbObjectTypeImpl get_type_for_info(self, bytes oid, str schema,

src/oracledb/impl/thin/packet.pyx

@@ -589,15 +589,8 @@ cdef class ReadBuffer(Buffer):
         since the structure is a bit different.
         """
         cdef:
-            uint8_t image_flags, image_version
             DbObjectPickleBuffer buf
-            BaseThinLobImpl lob_impl
-            const char_type *ptr
             uint32_t num_bytes
-            ssize_t bytes_left
-            uint32_t xml_flag
-            bytes packed_data
-            type cls
         self.read_ub4(&num_bytes)
         if num_bytes > 0:                   # type OID
             self.read_bytes()
@@ -611,26 +604,9 @@ cdef class ReadBuffer(Buffer):
         self.read_ub4(&num_bytes)           # length of data
         self.skip_ub2()                     # flags
         if num_bytes > 0:
-            packed_data = self.read_bytes()
             buf = DbObjectPickleBuffer.__new__(DbObjectPickleBuffer)
-            buf._populate_from_bytes(packed_data)
-            buf.read_header(&image_flags, &image_version)
-            buf.skip_raw_bytes(1)           # XML version
-            buf.read_uint32(&xml_flag)
-            if xml_flag & TNS_XML_TYPE_FLAG_SKIP_NEXT_4:
-                buf.skip_raw_bytes(4)
-            bytes_left = buf.bytes_left()
-            ptr = buf.read_raw_bytes(bytes_left)
-            if xml_flag & TNS_XML_TYPE_STRING:
-                return ptr[:bytes_left].decode()
-            elif xml_flag & TNS_XML_TYPE_LOB:
-                lob_impl = conn_impl._create_lob_impl(DB_TYPE_CLOB,
-                                                      ptr[:bytes_left])
-                cls = PY_TYPE_ASYNC_LOB \
-                    if conn_impl._protocol._transport._is_async \
-                    else PY_TYPE_LOB
-                return cls._from_impl(lob_impl)
-            errors._raise_err(errors.ERR_UNEXPECTED_XML_TYPE, flag=xml_flag)
+            buf._populate_from_bytes(self.read_bytes())
+            return buf.read_xmltype(conn_impl)
 
     cdef int check_control_packet(self) except -1:
         """

tests/sql/create_schema.sql

@@ -135,13 +135,14 @@ create or replace type &main_user..udt_Book as object (
 );
 /
 
-create or replace type &main_user..udt_UnknownAttributeType as object (
+create or replace type &main_user..udt_ObjectWithXmlType as object (
     NumberValue                         number(9),
-    XMLValue                            sys.xmltype
+    XMLValue                            sys.xmltype,
+    StringValue                         varchar2(60)
 );
 /
 
-create or replace type &main_user..udt_UnknownElementType
+create or replace type &main_user..udt_XmlTypeArray
 as table of sys.xmltype;
 /
 

tests/test_2300_object_var.py

@@ -660,22 +660,16 @@ def test_2327(self):
         )
         self.assertEqual(result, 7146445847327)
 
-    @unittest.skipIf(
-        test_env.get_is_thin(),
-        "thin mode doesn't have any unknown types currently",
-    )
+    @unittest.skipIf(test_env.get_is_thin(), "thin mode supports xmltype")
     def test_2328(self):
         "2328 - test object with unknown type in one of its attributes"
-        typ = self.conn.gettype("UDT_UNKNOWNATTRIBUTETYPE")
+        typ = self.conn.gettype("UDT_OBJECTWITHXMLTYPE")
         self.assertEqual(typ.attributes[1].type, oracledb.DB_TYPE_UNKNOWN)
 
-    @unittest.skipIf(
-        test_env.get_is_thin(),
-        "thin mode doesn't have any unknown types currently",
-    )
+    @unittest.skipIf(test_env.get_is_thin(), "thin mode supports xmltype")
     def test_2329(self):
         "2329 - test object with unknown type as the element type"
-        typ = self.conn.gettype("UDT_UNKNOWNELEMENTTYPE")
+        typ = self.conn.gettype("UDT_XMLTYPEARRAY")
         self.assertEqual(typ.element_type, oracledb.DB_TYPE_UNKNOWN)
 
     def test_2330(self):
@@ -790,6 +784,25 @@ def test_2338(self):
         result = [i for i in obj]
         self.assertEqual(result, [5, 10, 15])
 
+    @unittest.skipUnless(
+        test_env.get_is_thin(), "thick mode does not support xmltype"
+    )
+    def test_2339(self):
+        "2339 - test fetching an object containing an XmlType instance"
+        num_val = 2339
+        xml_val = "<item>test_2339</item>"
+        str_val = "A string for test 2339"
+        self.cursor.execute(
+            f"""
+            select udt_ObjectWithXmlType({num_val}, sys.xmltype('{xml_val}'),
+                    '{str_val}') from dual
+            """
+        )
+        (obj,) = self.cursor.fetchone()
+        self.assertEqual(obj.NUMBERVALUE, num_val)
+        self.assertEqual(obj.XMLVALUE, xml_val)
+        self.assertEqual(obj.STRINGVALUE, str_val)
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()