Validate database objects meet maximum size constraints.

Author: anthony-tuininga

doc/src/release_notes.rst

@@ -79,6 +79,10 @@ Common Changes
     :data:`FetchInfo.type_code` for data of this type was
     :data:`~oracledb.DB_TYPE_LONG` in Thick mode and
     :data:`~oracledb.DB_TYPE_OBJECT` in Thin mode.
+#)  Attribute and element values of :ref:`Oracle Object <dbobject>` instances
+    that contain strings or bytes now have their maximum size constraints
+    checked. Errors ``DPY-2043`` (attributes) and ``DPY-2044`` (element values)
+    are now raised when constraints are violated.
 #)  Attribute and element values of :ref:`Oracle Object <dbobject>` instances
     that are numbers are now returned as integers if the precision and scale
     allow for it. This is the same way that numbers are fetched from the

src/oracledb/base_impl.pxd

@@ -386,22 +386,33 @@ cdef class BaseDbObjectTypeImpl:
         readonly dict attrs_by_name
         readonly DbType element_dbtype
         readonly BaseDbObjectTypeImpl element_objtype
+        readonly int8_t element_precision
+        readonly int8_t element_scale
+        readonly uint32_t element_max_size
         readonly BaseConnImpl _conn_impl
         int _element_preferred_num_type
 
+    cpdef str _get_fqn(self)
+
 
 cdef class BaseDbObjectAttrImpl:
     cdef:
         readonly str name
         readonly DbType dbtype
         readonly BaseDbObjectTypeImpl objtype
+        readonly int8_t precision
+        readonly int8_t scale
+        readonly uint32_t max_size
         int _preferred_num_type
 
 
 cdef class BaseDbObjectImpl:
     cdef:
         readonly BaseDbObjectTypeImpl type
 
+    cdef int _check_max_size(self, object value, uint32_t max_size,
+                             ssize_t* actual_size, bint* violated) except -1
+
 
 cdef class BaseSodaDbImpl:
     cdef:

src/oracledb/dbobject.py

@@ -282,9 +282,7 @@ def _get_full_name(self):
         """
         Returns the full name of the type.
         """
-        if self.package_name is not None:
-            return f"{self.schema}.{self.package_name}.{self.name}"
-        return f"{self.schema}.{self.name}"
+        return self._impl._get_fqn()
 
     @property
     def attributes(self) -> list:

src/oracledb/errors.py

@@ -225,6 +225,8 @@ def _raise_from_string(exc_type: Exception, message: str) -> None:
 ERR_EXECUTE_MODE_ONLY_FOR_DML = 2040
 ERR_MISSING_QUOTE_IN_STRING = 2041
 ERR_MISSING_QUOTE_IN_IDENTIFIER = 2042
+ERR_DBOBJECT_ATTR_MAX_SIZE_VIOLATED = 2043
+ERR_DBOBJECT_ELEMENT_MAX_SIZE_VIOLATED = 2044
 
 # error numbers that result in NotSupportedError
 ERR_TIME_NOT_SUPPORTED = 3000
@@ -386,6 +388,14 @@ def _raise_from_string(exc_type: Exception, message: str) -> None:
     ),
     ERR_CONTENT_INVALID_AFTER_NUMBER: "invalid number (content after number)",
     ERR_CURSOR_NOT_OPEN: "cursor is not open",
+    ERR_DBOBJECT_ATTR_MAX_SIZE_VIOLATED: (
+        "attribute {attr_name} of type {type_name} exceeds its maximum size "
+        "(actual: {actual_size}, maximum: {max_size})"
+    ),
+    ERR_DBOBJECT_ELEMENT_MAX_SIZE_VIOLATED: (
+        "element {index} of type {type_name} exceeds its maximum size "
+        "(actual: {actual_size}, maximum: {max_size})"
+    ),
     ERR_DB_TYPE_NOT_SUPPORTED: 'database type "{name}" is not supported',
     ERR_DUPLICATED_PARAMETER: (
         '"{deprecated_name}" and "{new_name}" cannot be specified together'

src/oracledb/impl/base/dbobject.pyx

@@ -31,14 +31,39 @@
 
 cdef class BaseDbObjectImpl:
 
+    cdef int _check_max_size(self, object value, uint32_t max_size,
+                             ssize_t* actual_size, bint* violated) except -1:
+        """
+        Checks to see if the maximum size has been violated.
+        """
+        violated[0] = False
+        if max_size > 0:
+            if isinstance(value, str):
+                actual_size[0] = len((<str> value).encode())
+            else:
+                actual_size[0] = len(<bytes> value)
+            if actual_size[0] > max_size:
+                violated[0] = True
+
     def append(self, object value):
         """
         Appends a value to the collection after first checking to see if the
         value is acceptable.
         """
-        cdef BaseConnImpl conn_impl = self.type._conn_impl
+        cdef:
+            BaseConnImpl conn_impl = self.type._conn_impl
+            ssize_t actual_size
+            bint violated
         value = conn_impl._check_value(self.type.element_dbtype,
                                        self.type.element_objtype, value, NULL)
+        self._check_max_size(value, self.type.element_max_size, &actual_size,
+                             &violated)
+        if violated:
+            errors._raise_err(errors.ERR_DBOBJECT_ELEMENT_MAX_SIZE_VIOLATED,
+                              index=self.get_size(),
+                              type_name=self.type._get_fqn(),
+                              actual_size=actual_size,
+                              max_size=self.type.element_max_size)
         self.append_checked(value)
 
     @utils.CheckImpls("appending a value to a collection")
@@ -90,8 +115,17 @@ cdef class BaseDbObjectImpl:
         Sets the attribute value after first checking to see if the value is
         acceptable.
         """
-        cdef BaseConnImpl conn_impl = self.type._conn_impl
+        cdef:
+            BaseConnImpl conn_impl = self.type._conn_impl
+            ssize_t actual_size
+            bint violated
         value = conn_impl._check_value(attr.dbtype, attr.objtype, value, NULL)
+        self._check_max_size(value, attr.max_size, &actual_size, &violated)
+        if violated:
+            errors._raise_err(errors.ERR_DBOBJECT_ATTR_MAX_SIZE_VIOLATED,
+                              attr_name=attr.name,
+                              type_name=self.type._get_fqn(),
+                              actual_size=actual_size, max_size=attr.max_size)
         self.set_attr_value_checked(attr, value)
 
     @utils.CheckImpls("setting an attribute value")
@@ -103,9 +137,19 @@ cdef class BaseDbObjectImpl:
         Sets the element value after first checking to see if the value is
         acceptable.
         """
-        cdef BaseConnImpl conn_impl = self.type._conn_impl
+        cdef:
+            BaseConnImpl conn_impl = self.type._conn_impl
+            ssize_t actual_size
+            bint violated
         value = conn_impl._check_value(self.type.element_dbtype,
                                        self.type.element_objtype, value, NULL)
+        self._check_max_size(value, self.type.element_max_size, &actual_size,
+                             &violated)
+        if violated:
+            errors._raise_err(errors.ERR_DBOBJECT_ELEMENT_MAX_SIZE_VIOLATED,
+                              index=index, type_name=self.type._get_fqn(),
+                              actual_size=actual_size,
+                              max_size=self.type.element_max_size)
         self.set_element_by_index_checked(index, value)
 
     @utils.CheckImpls("setting an element of a collection")
@@ -130,6 +174,14 @@ cdef class BaseDbObjectTypeImpl:
                     and other.name == self.name
         return NotImplemented
 
+    cpdef str _get_fqn(self):
+        """
+        Return the fully qualified name of the type.
+        """
+        if self.package_name is not None:
+            return f"{self.schema}.{self.package_name}.{self.name}"
+        return f"{self.schema}.{self.name}"
+
     @utils.CheckImpls("creating a new object")
     def create_new_object(self):
         pass

src/oracledb/impl/thick/dbobject.pyx

@@ -287,6 +287,9 @@ cdef class ThickDbObjectAttrImpl(BaseDbObjectAttrImpl):
             _raise_from_odpi()
         impl.name = info.name[:info.nameLength].decode()
         impl.dbtype = DbType._from_num(info.typeInfo.oracleTypeNum)
+        impl.precision = info.typeInfo.precision
+        impl.scale = info.typeInfo.scale
+        impl.max_size = info.typeInfo.dbSizeInBytes
         impl._preferred_num_type = \
                 get_preferred_num_type(info.typeInfo.precision,
                                        info.typeInfo.scale)
@@ -338,6 +341,9 @@ cdef class ThickDbObjectTypeImpl(BaseDbObjectTypeImpl):
         if impl.is_collection:
             dbtype = DbType._from_num(info.elementTypeInfo.oracleTypeNum)
             impl.element_dbtype = dbtype
+            impl.element_precision = info.elementTypeInfo.precision
+            impl.element_scale = info.elementTypeInfo.scale
+            impl.element_max_size = info.elementTypeInfo.dbSizeInBytes
             impl._element_preferred_num_type = \
                 get_preferred_num_type(info.elementTypeInfo.precision,
                                        info.elementTypeInfo.scale)

src/oracledb/impl/thin/dbobject_cache.pyx

@@ -234,7 +234,9 @@ cdef class BaseThinDbObjectTypeCache:
                 typ_impl.collection_flags = TNS_OBJ_HAS_INDEXES
             buf.skip_to(pos)
             typ_impl.element_dbtype = self._parse_tds_attr(
-                buf, &typ_impl._element_preferred_num_type
+                buf, &typ_impl.element_precision, &typ_impl.element_scale,
+                &typ_impl.element_max_size,
+                &typ_impl._element_preferred_num_type
             )
             if typ_impl.element_dbtype is DB_TYPE_CLOB:
                 return self._get_element_type_clob(typ_impl)
@@ -244,16 +246,22 @@ cdef class BaseThinDbObjectTypeCache:
         # handle objects with attributes
         else:
             for i, attr_impl in enumerate(typ_impl.attrs):
-                self._parse_tds_attr(buf, &attr_impl._preferred_num_type)
+                self._parse_tds_attr(buf, &attr_impl.precision,
+                                     &attr_impl.scale, &attr_impl.max_size,
+                                     &attr_impl._preferred_num_type)
 
-    cdef DbType _parse_tds_attr(self, TDSBuffer buf, int* preferred_num_type):
+    cdef DbType _parse_tds_attr(self, TDSBuffer buf, int8_t* precision,
+                                int8_t* scale, uint32_t *max_size,
+                                int* preferred_num_type):
         """
         Parses a TDS attribute from the buffer.
         """
         cdef:
             uint8_t attr_type, ora_type_num = 0, csfrm = 0
+            int8_t temp_precision, temp_scale
             int temp_preferred_num_type
-            int8_t precision, scale
+            uint32_t temp_max_size
+            uint16_t temp16
 
         # skip until a type code that is of interest
         while True:
@@ -266,14 +274,16 @@ cdef class BaseThinDbObjectTypeCache:
         # process the type code
         if attr_type == TNS_OBJ_TDS_TYPE_NUMBER:
             ora_type_num = TNS_DATA_TYPE_NUMBER
-            buf.read_sb1(&precision)
-            buf.read_sb1(&scale)
-            preferred_num_type[0] = get_preferred_num_type(precision, scale)
+            buf.read_sb1(precision)
+            buf.read_sb1(scale)
+            preferred_num_type[0] = \
+                    get_preferred_num_type(precision[0], scale[0])
         elif attr_type == TNS_OBJ_TDS_TYPE_FLOAT:
             ora_type_num = TNS_DATA_TYPE_NUMBER
             buf.skip_raw_bytes(1)           # precision
         elif attr_type in (TNS_OBJ_TDS_TYPE_VARCHAR, TNS_OBJ_TDS_TYPE_CHAR):
-            buf.skip_raw_bytes(2)           # maximum length
+            buf.read_uint16(&temp16)        # maximum length
+            max_size[0] = temp16
             buf.read_ub1(&csfrm)
             csfrm = csfrm & 0x7f
             buf.skip_raw_bytes(2)           # character set
@@ -282,7 +292,8 @@ cdef class BaseThinDbObjectTypeCache:
             else:
                 ora_type_num = TNS_DATA_TYPE_CHAR
         elif attr_type == TNS_OBJ_TDS_TYPE_RAW:
-            buf.skip_raw_bytes(2)           # maximum length
+            buf.read_uint16(&temp16)        # maximum length
+            max_size[0] = temp16
             ora_type_num = TNS_DATA_TYPE_RAW
         elif attr_type == TNS_OBJ_TDS_TYPE_BINARY_FLOAT:
             ora_type_num = TNS_DATA_TYPE_BINARY_FLOAT
@@ -311,7 +322,9 @@ cdef class BaseThinDbObjectTypeCache:
             buf.skip_raw_bytes(5)           # offset and code
         elif attr_type == TNS_OBJ_TDS_TYPE_START_EMBED_ADT:
             ora_type_num = TNS_DATA_TYPE_INT_NAMED
-            while self._parse_tds_attr(buf, &temp_preferred_num_type):
+            while self._parse_tds_attr(buf, &temp_precision, &temp_scale,
+                                       &temp_max_size,
+                                       &temp_preferred_num_type):
                 pass
         elif attr_type == TNS_OBJ_TDS_TYPE_END_EMBED_ADT:
             return None

tests/test_2300_object_var.py

@@ -730,6 +730,47 @@ def test_2332_validate_invalid_attr_name(self):
         with self.assertRaises(AttributeError):
             obj.MISSING
 
+    def test_2333_validate_string_attr(self):
+        "2333 - test validating a string attribute"
+        typ = self.conn.gettype("UDT_OBJECT")
+        obj = typ.newobject()
+        for attr_name, max_size in [
+            ("STRINGVALUE", 60),
+            ("FIXEDCHARVALUE", 10),
+            ("NSTRINGVALUE", 120),
+            ("NFIXEDCHARVALUE", 20),
+            ("RAWVALUE", 16),
+        ]:
+            with self.subTest(attr_name=attr_name, max_size=max_size):
+                value = "A" * max_size
+                setattr(obj, attr_name, value)
+                value += "X"
+                self.assertRaisesRegex(
+                    oracledb.ProgrammingError,
+                    "^DPY-2043:",
+                    setattr,
+                    obj,
+                    attr_name,
+                    value,
+                )
+
+    def test_2334_validate_string_element_value(self):
+        "2334 - test validating a string element value"
+        typ = self.conn.gettype("PKG_TESTSTRINGARRAYS.UDT_STRINGLIST")
+        obj = typ.newobject()
+        obj.append("A" * 100)
+        self.assertRaisesRegex(
+            oracledb.ProgrammingError, "^DPY-2044:", obj.append, "A" * 101
+        )
+        obj.append("B" * 100)
+        self.assertRaisesRegex(
+            oracledb.ProgrammingError,
+            "^DPY-2044:",
+            obj.setelement,
+            2,
+            "C" * 101,
+        )
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()