Added support for precision, scale and max_size on DbObjectAttribute

anthony-tuininga · anthony-tuininga · commit 59c52be1ede8 · 2024-12-02T21:14:07.000-07:00
objects
diff --git a/doc/src/api_manual/dbobject_type.rst b/doc/src/api_manual/dbobject_type.rst
@@ -192,11 +192,41 @@ DbObjectAttribute Objects
     :attr:`DbObjectType.attributes` are instances of this type.
 
 
+.. attribute:: DbObjectAttribute.max_size
+
+    This read-only attribute returns the maximum size (in bytes) of the
+    attribute when the attribute's type is one of
+    :data:`oracledb.DB_TYPE_CHAR`, :data:`oracledb.DB_TYPE_NCHAR`,
+    :data:`oracledb.DB_TYPE_NVARCHAR`, :data:`oracledb.DB_TYPE_RAW`, or
+    :data:`oracledb.DB_TYPE_VARCHAR`. For all other types the value returned is
+    `None`.
+
+    .. versionadded:: 2.6.0
+
+
 .. attribute:: DbObjectAttribute.name
 
     This read-only attribute returns the name of the attribute.
 
 
+.. attribute:: DbObjectAttribute.precision
+
+    This read-only attribute returns the precision of the attribute when the
+    attribute's type is :data:`oracledb.DB_TYPE_NUMBER`. For all other types
+    the value returned is `None`.
+
+    .. versionadded:: 2.6.0
+
+
+.. attribute:: DbObjectAttribute.scale
+
+    This read-only attribute returns the scale of the attribute when the
+    attribute's type is :data:`oracledb.DB_TYPE_NUMBER`. For all other types
+    the value returned is `None`.
+
+    .. versionadded:: 2.6.0
+
+
 .. attribute:: DbObjectAttribute.type
 
     This read-only attribute returns the type of the attribute. This will be an
diff --git a/doc/src/release_notes.rst b/doc/src/release_notes.rst
@@ -57,6 +57,13 @@ Common Changes
 #)  Added support for :ref:`naming and caching connection pools
     <connpoolcache>` during creation, and retrieving them later from the
     python-oracledb pool cache with :meth:`oracledb.get_pool()`.
+#)  Added attributes :attr:`DbObjectAttribute.precision`,
+    :attr:`DbObjectAttribute.scale`, and :attr:`DbObjectAttribute.max_size` that
+    provide additional metadata about
+    :ref:`database object attributes <dbobjectattr>`.
+#)  Fixed bug where some :ref:`DbObject <dbobjecttype>` attributes for database
+    objects defined using ANSI names (including FLOAT and REAL) may have shown
+    as integers.
 
 
 oracledb 2.5.0 (November 2024)
diff --git a/src/oracledb/dbobject.py b/src/oracledb/dbobject.py
@@ -235,13 +235,39 @@ def _from_impl(cls, impl):
         attr._type = None
         return attr
 
+    @property
+    def max_size(self) -> Union[int, None]:
+        """
+        Returns the max size of the attribute (in bytes) for attributes of type
+        DB_TYPE_RAW, DB_TYPE_CHAR, DB_TYPE_NCHAR, DB_TYPE_VARCHAR and
+        DB_TYPE_NVARCHAR.
+        """
+        if self._impl.max_size:
+            return self._impl.max_size
+
     @property
     def name(self) -> str:
         """
         This read-only attribute returns the name of the attribute.
         """
         return self._impl.name
 
+    @property
+    def precision(self) -> Union[int, None]:
+        """
+        Returns the precision of the attribute.
+        """
+        if self._impl.precision or self._impl.scale:
+            return self._impl.precision
+
+    @property
+    def scale(self) -> Union[int, None]:
+        """
+        Returns the scale of the column.
+        """
+        if self._impl.precision or self._impl.scale:
+            return self._impl.scale
+
     @property
     def type(self) -> Union["DbObjectType", DbType]:
         """
diff --git a/src/oracledb/impl/base/cursor.pyx b/src/oracledb/impl/base/cursor.pyx
@@ -221,9 +221,9 @@ cdef class BaseCursorImpl:
         if db_type_num == DB_TYPE_NUM_NUMBER:
             if C_DEFAULTS.fetch_decimals:
                 var_impl._preferred_num_type = NUM_TYPE_DECIMAL
-            elif var_impl.scale == 0 \
-                    or (var_impl.scale == -127 and var_impl.precision == 0):
-                var_impl._preferred_num_type = NUM_TYPE_INT
+            else:
+                var_impl._preferred_num_type = \
+                    get_preferred_num_type(var_impl.precision, var_impl.scale)
         elif fetch_info.is_oson and db_type_num != DB_TYPE_NUM_JSON:
             conn_impl = self._get_conn_impl()
             var_impl.dbtype = DB_TYPE_LONG_RAW
diff --git a/src/oracledb/impl/base/types.pyx b/src/oracledb/impl/base/types.pyx
@@ -396,14 +396,9 @@ DB_TYPE_XMLTYPE = DbType(
 )
 
 # additional aliases
-db_type_by_ora_name["DOUBLE PRECISION"] = DB_TYPE_NUMBER
-db_type_by_ora_name["FLOAT"] = DB_TYPE_NUMBER
-db_type_by_ora_name["INTEGER"] = DB_TYPE_NUMBER
 db_type_by_ora_name["PL/SQL BOOLEAN"] = DB_TYPE_BOOLEAN
 db_type_by_ora_name["PL/SQL BINARY INTEGER"] = DB_TYPE_BINARY_INTEGER
 db_type_by_ora_name["PL/SQL PLS INTEGER"] = DB_TYPE_BINARY_INTEGER
-db_type_by_ora_name["REAL"] = DB_TYPE_NUMBER
-db_type_by_ora_name["SMALLINT"] = DB_TYPE_NUMBER
 db_type_by_ora_name["TIMESTAMP WITH TZ"] = DB_TYPE_TIMESTAMP_TZ
 db_type_by_ora_name["TIMESTAMP WITH LOCAL TZ"] = DB_TYPE_TIMESTAMP_LTZ
 
diff --git a/src/oracledb/impl/thick/dbobject.pyx b/src/oracledb/impl/thick/dbobject.pyx
@@ -289,9 +289,10 @@ cdef class ThickDbObjectAttrImpl(BaseDbObjectAttrImpl):
         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)
+        if impl.dbtype.num == DPI_ORACLE_TYPE_NUMBER:
+            impl._preferred_num_type = \
+                    get_preferred_num_type(info.typeInfo.precision,
+                                           info.typeInfo.scale)
         if info.typeInfo.objectType:
             typ_handle = info.typeInfo.objectType
             impl.objtype = ThickDbObjectTypeImpl._from_handle(conn_impl,
@@ -341,9 +342,10 @@ cdef class ThickDbObjectTypeImpl(BaseDbObjectTypeImpl):
             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)
+            if dbtype.num == DPI_ORACLE_TYPE_NUMBER:
+                impl._element_preferred_num_type = \
+                    get_preferred_num_type(info.elementTypeInfo.precision,
+                                           info.elementTypeInfo.scale)
             if info.elementTypeInfo.objectType != NULL:
                 handle = info.elementTypeInfo.objectType
                 temp = ThickDbObjectTypeImpl._from_handle(conn_impl, handle)
diff --git a/src/oracledb/impl/thin/dbobject_cache.pyx b/src/oracledb/impl/thin/dbobject_cache.pyx
@@ -78,8 +78,21 @@ cdef str DBO_CACHE_SQL_GET_COLUMNS = """
                     then data_length
                 else 0
             end,
-            nvl(data_precision, 0),
-            nvl(data_scale, 0)
+            case
+                when data_precision is null and data_scale is null
+                    then 0
+                when data_precision is null
+                    then 38
+                else data_precision
+            end,
+            case
+                when data_precision is null and data_scale is null
+                        and data_type = 'NUMBER'
+                    then -127
+                when data_scale is null
+                    then 0
+                else data_scale
+            end
         from all_tab_cols
         where owner = :owner
           and table_name = substr(:name, 1, length(:name) - 8)
@@ -307,10 +320,13 @@ cdef class BaseThinDbObjectTypeCache:
         # process the type code
         if attr_type == TNS_OBJ_TDS_TYPE_NUMBER:
             ora_type_num = ORA_TYPE_NUM_NUMBER
-            buf.read_sb1(precision)
-            buf.read_sb1(scale)
-            preferred_num_type[0] = \
-                    get_preferred_num_type(precision[0], scale[0])
+            buf.read_sb1(&temp_precision)
+            buf.read_sb1(&temp_scale)
+            if temp_precision != 0 or temp_scale != 0:
+                precision[0] = temp_precision
+                scale[0] = temp_scale
+                preferred_num_type[0] = \
+                        get_preferred_num_type(precision[0], scale[0])
         elif attr_type == TNS_OBJ_TDS_TYPE_FLOAT:
             ora_type_num = ORA_TYPE_NUM_NUMBER
             buf.skip_raw_bytes(1)           # precision
@@ -389,13 +405,34 @@ cdef class BaseThinDbObjectTypeCache:
                 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
+            if type_name in ("INTEGER", "SMALLINT"):
+                attr_impl.dbtype = DB_TYPE_NUMBER
+                attr_impl.precision = 38
+                attr_impl.scale = 0
+            elif type_name == "REAL":
+                attr_impl.dbtype = DB_TYPE_NUMBER
+                attr_impl.precision = 63
+                attr_impl.scale = -127
+            elif type_name in ("DOUBLE PRECISION", "FLOAT"):
+                attr_impl.dbtype = DB_TYPE_NUMBER
+                # the database sends type name "FLOAT" instead of type name
+                # "REAL" when looking at table metadata but not when examining
+                # database object attribute metadata so account for that here
+                if precision != 0:
+                    attr_impl.precision = precision
+                else:
+                    attr_impl.precision = 126
+                attr_impl.scale = -127
+            else:
+                attr_impl.dbtype = DbType._from_ora_name(type_name)
+                attr_impl.max_size = max_size
+                if attr_impl.dbtype._ora_type_num == ORA_TYPE_NUM_NUMBER:
+                    attr_impl.precision = precision
+                    attr_impl.scale = scale
+            if attr_impl.dbtype._ora_type_num == ORA_TYPE_NUM_NUMBER:
                 attr_impl._preferred_num_type = \
-                        get_preferred_num_type(precision, scale)
+                        get_preferred_num_type(attr_impl.precision,
+                                               attr_impl.scale)
         typ_impl.attrs.append(attr_impl)
         typ_impl.attrs_by_name[name] = attr_impl
 
diff --git a/src/oracledb/thin_impl.pyx b/src/oracledb/thin_impl.pyx
@@ -179,6 +179,7 @@ from .base_impl import (
     DB_TYPE_NCLOB,
     DB_TYPE_BINARY_INTEGER,
     DB_TYPE_CURSOR,
+    DB_TYPE_NUMBER,
     DB_TYPE_OBJECT,
     DB_TYPE_XMLTYPE,
 )
diff --git a/tests/test_2300_object_var.py b/tests/test_2300_object_var.py
diff --git a/tests/test_3200_features_12_1.py b/tests/test_3200_features_12_1.py
diff --git a/tests/test_5600_dbobject_async.py b/tests/test_5600_dbobject_async.py

Original file line number	Diff line number	Diff line change
`@@ -179,6 +179,7 @@ from .base_impl import (`
`179`	`179`	`DB_TYPE_NCLOB,`
`180`	`180`	`DB_TYPE_BINARY_INTEGER,`
`181`	`181`	`DB_TYPE_CURSOR,`
	`182`	`+ DB_TYPE_NUMBER,`
`182`	`183`	`DB_TYPE_OBJECT,`
`183`	`184`	`DB_TYPE_XMLTYPE,`
`184`	`185`	`)`