Support BigInt values for DbObject Number type attributes (Issue #1710)

sharadraju · sharadraju · commit 183b9becd4fb · 2025-02-11T13:03:19.000+05:30
diff --git a/doc/src/release_notes.rst b/doc/src/release_notes.rst
@@ -14,6 +14,11 @@ node-oracledb `v6.8.0 <https://github.com/oracle/node-oracledb/compare/v6.7.1...
 Common Changes
 ++++++++++++++
 
+#)  Added support for `BigInt` values to be passed to Database Objects.
+    Exported new function `dbObjectTypeHandler` from `oracledb` which can be
+    used to convert strings passed to the handler to `BigInt`.
+    See `Issue #1710 <https://github.com/oracle/node-oracledb/issues/1710>`__.
+
 #)  Added support for Oracle Database 23ai sparse vectors.
 
 #)  Fixed :attr:`~dbObject.length` property for the database object
diff --git a/lib/connection.js b/lib/connection.js
@@ -50,6 +50,48 @@ const oson = require('./impl/datahandlers/oson.js');
 // and destroyed with another!
 const _subscriptions = new Map();
 
+// default closure for NUMBER type.
+const defaultNumberConverter = (v) => (v === null) ? null : parseFloat(v);
+
+//---------------------------------------------------------------------------
+// _determineDbObjTypeConverter()
+//
+// Determines the converter associated with each DB type and its metadata.
+// This function is called once during metadata construction and the
+// converters are invoked when retriving DBObject values.
+//---------------------------------------------------------------------------
+function _determineDbObjTypeConverter(metadata, options) {
+  // clear any previous converter functions that may have been
+  // retained
+  delete metadata.converter;
+
+  // If a DBfetch type handler is specified, update converter,
+  // if available.
+  if (options.dbObjectTypeHandler) {
+    const result = options.dbObjectTypeHandler(metadata);
+    if (result !== undefined) {
+      errors.assert(typeof result === 'object',
+        errors.ERR_DB_FETCH_TYPE_HANDLER_RETURN_VALUE);
+      if (result.converter !== undefined) {
+        errors.assert(typeof result.converter === 'function',
+          errors.ERR_DB_FETCH_TYPE_HANDLER_CONVERTER);
+      }
+      if ([types.DB_TYPE_CLOB, types.DB_TYPE_NCLOB, types.DB_TYPE_BLOB,
+        types.DB_TYPE_BFILE].includes(metadata.type)) {
+        // converters for LOB's are not supported.
+        return errors.throwErr(errors.ERR_NOT_IMPLEMENTED,
+          'DbObjConverter for LOBs');
+      }
+      metadata.converter = result.converter;
+    }
+  }
+  if (metadata.type === types.DB_TYPE_NUMBER && !metadata.converter) {
+    // set default converter for NUMBER type as they are returned as strings
+    // from DB.
+    metadata.converter = defaultNumberConverter;
+  }
+}
+
 // define class
 class Connection extends EventEmitter {
 
@@ -106,9 +148,11 @@ class Connection extends EventEmitter {
       const cls = this._getDbObjectClass(objType.elementTypeClass);
       objType.elementTypeClass = cls;
     }
+    const options = {dbObjectTypeHandler: settings.dbObjectTypeHandler};
     if (objType.isCollection) {
       nodbUtil.addTypeProperties(objType, "elementType");
       objType.elementTypeInfo.type = objType.elementType;
+      _determineDbObjTypeConverter(objType.elementTypeInfo, options);
     }
     if (objType.attributes) {
       const props = {};
@@ -126,6 +170,10 @@ class Connection extends EventEmitter {
           }
         };
         props[attr.name] = prop;
+
+        // calculate for each attribute metadata as converters might change
+        // based on precision, scale, maxSize,..
+        _determineDbObjTypeConverter(attr, options);
       }
       Object.defineProperties(DbObject.prototype, props);
     }
diff --git a/lib/dbObject.js b/lib/dbObject.js
@@ -86,7 +86,7 @@ class BaseDbObject {
   //---------------------------------------------------------------------------
   _getAttrValue(attr) {
     const value = this._impl.getAttrValue(attr);
-    return this._transformValueOut(value, attr.typeClass);
+    return this._transformValueOut(value, attr.typeClass, attr);
   }
 
   //---------------------------------------------------------------------------
@@ -138,16 +138,21 @@ class BaseDbObject {
   //
   // Transforms a value going out to the caller from the implementation.
   //---------------------------------------------------------------------------
-  _transformValueOut(value, cls) {
+  _transformValueOut(value, cls, metaData) {
     let outValue = value;
     if (value instanceof impl.LobImpl) {
       outValue = new Lob();
       outValue._setup(value, true);
-    } else if (value instanceof impl.DbObjectImpl) {
-      outValue = Object.create(cls.prototype);
-      outValue._impl = value;
-      if (outValue.isCollection) {
-        outValue = new Proxy(outValue, BaseDbObject._collectionProxyHandler);
+    } else {
+      if (value instanceof impl.DbObjectImpl) {
+        outValue = Object.create(cls.prototype);
+        outValue._impl = value;
+        if (outValue.isCollection) {
+          outValue = new Proxy(outValue, BaseDbObject._collectionProxyHandler);
+        }
+      }
+      if (metaData.converter) {
+        outValue = metaData.converter(outValue);
       }
     }
     return outValue;
@@ -288,7 +293,7 @@ class BaseDbObject {
     errors.assertArgCount(arguments, 1, 1);
     errors.assertParamValue(Number.isInteger(index), 1);
     const value = this._impl.getElement(index);
-    return this._transformValueOut(value, this.elementTypeClass);
+    return this._transformValueOut(value, this.elementTypeClass, this._objType.elementTypeInfo);
   }
 
   //---------------------------------------------------------------------------
@@ -352,7 +357,7 @@ class BaseDbObject {
     errors.assertArgCount(arguments, 0, 0);
     const values = this._impl.getValues();
     for (let i = 0; i < values.length; i++) {
-      values[i] = this._transformValueOut(values[i], this.elementTypeClass);
+      values[i] = this._transformValueOut(values[i], this.elementTypeClass, this._objType.elementTypeInfo);
     }
     return values;
   }
diff --git a/lib/errors.js b/lib/errors.js
@@ -171,6 +171,8 @@ const ERR_VECTOR_SPARSE_INVALID_JSON = 162;
 const ERR_VECTOR_SPARSE_INVALID_STRING = 163;
 const ERR_VECTOR_SPARSE_INVALID_INPUT = 164;
 const ERR_VECTOR_SPARSE_INDICES_ELEM_IS_NOT_VALID = 165;
+const ERR_DB_FETCH_TYPE_HANDLER_CONVERTER = 166;
+const ERR_DB_FETCH_TYPE_HANDLER_RETURN_VALUE = 167;
 
 // Oracle Net layer errors start from 500
 const ERR_CONNECTION_CLOSED = 500;
@@ -494,6 +496,10 @@ messages.set(ERR_VECTOR_SPARSE_INVALID_INPUT,           // NJS-164
   'SPARSE VECTOR Invalid Input Data');
 messages.set(ERR_VECTOR_SPARSE_INDICES_ELEM_IS_NOT_VALID,    // NJS-165
   'SPARSE VECTOR indices element at index %d is not valid');
+messages.set(ERR_DB_FETCH_TYPE_HANDLER_CONVERTER,          // NJS-166
+  'DBFetchTypeHandler return value attribute "converter" must be a function');
+messages.set(ERR_DB_FETCH_TYPE_HANDLER_RETURN_VALUE,       // NJS-167
+  'DBFetchTypeHandler return value must be an object');
 
 // Oracle Net layer errors
 
@@ -963,6 +969,8 @@ module.exports = {
   ERR_VECTOR_SPARSE_INVALID_STRING,
   ERR_VECTOR_SPARSE_INVALID_INPUT,
   ERR_VECTOR_SPARSE_INDICES_ELEM_IS_NOT_VALID,
+  ERR_DB_FETCH_TYPE_HANDLER_CONVERTER,
+  ERR_DB_FETCH_TYPE_HANDLER_RETURN_VALUE,
   WRN_COMPILATION_CREATE,
   assert,
   assertArgCount,
diff --git a/lib/oracledb.js b/lib/oracledb.js
@@ -1289,6 +1289,10 @@ module.exports = {
     return settings.fetchTypeHandler;
   },
 
+  get dbObjectTypeHandler() {
+    return settings.dbObjectTypeHandler;
+  },
+
   get lobPrefetchSize() {
     return settings.lobPrefetchSize;
   },
@@ -1434,6 +1438,13 @@ module.exports = {
     settings.fetchTypeHandler = value;
   },
 
+  set dbObjectTypeHandler(value) {
+    if (value !== undefined) {
+      errors.assertPropValue(typeof value === 'function', "dbObjectTypeHandler");
+    }
+    settings.dbObjectTypeHandler = value;
+  },
+
   set lobPrefetchSize(value) {
     errors.assertPropValue(Number.isInteger(value) && value >= 0,
       "lobPrefetchSize");
diff --git a/lib/settings.js b/lib/settings.js
@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -64,6 +64,7 @@ class Settings {
     this.thinDriverInitialized = false;
     this.createFetchTypeMap(this.fetchAsString, this.fetchAsBuffer);
     this.fetchTypeHandler = undefined;
+    this.dbObjectTypeHandler = undefined;
     this._JsonId = types.JsonId;
     this._SparseVector = types.SparseVector;
   }
diff --git a/lib/thin/dbObject.js b/lib/thin/dbObject.js
@@ -368,10 +368,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
     let isNull, obj, value;
     switch (type) {
       case types.DB_TYPE_NUMBER:
-        value = buf.readOracleNumber();
-        if (value !== null)
-          value = parseFloat(value);
-        return value;
+        return buf.readOracleNumber();
       case types.DB_TYPE_BINARY_INTEGER:
         return buf.readBinaryInteger();
       case types.DB_TYPE_VARCHAR:
diff --git a/src/njsDbObject.c b/src/njsDbObject.c
@@ -1,4 +1,4 @@
-// Copyright (c) 2019, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2019, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -204,8 +204,14 @@ NJS_NAPI_METHOD_IMPL_SYNC(njsDbObject_getAttrValue, 1, &njsClassDefDbObject)
     njsDbObject *obj = (njsDbObject*) callingInstance;
     njsDbObjectAttr *attr;
     dpiData data;
+    char numberAsString[200];
 
     NJS_CHECK_NAPI(env, napi_unwrap(env, args[0], (void**) &attr))
+    if (attr->typeInfo.oracleTypeNum == DPI_ORACLE_TYPE_NUMBER) {
+        data.value.asBytes.ptr = numberAsString;
+        data.value.asBytes.length = sizeof(numberAsString);
+        data.value.asBytes.encoding = NULL;
+    }
     if (dpiObject_getAttributeValue(obj->handle, attr->handle,
             attr->typeInfo.nativeTypeNum, &data) < 0)
         return njsUtils_throwErrorDPI(env, globals);
@@ -223,8 +229,14 @@ NJS_NAPI_METHOD_IMPL_SYNC(njsDbObject_getElement, 1, &njsClassDefDbObject)
     njsDbObject *obj = (njsDbObject*) callingInstance;
     int32_t index;
     dpiData data;
+    char numberAsString[200];
 
     NJS_CHECK_NAPI(env, napi_get_value_int32(env, args[0], &index))
+    if (obj->type->elementTypeInfo.oracleTypeNum == DPI_ORACLE_TYPE_NUMBER) {
+        data.value.asBytes.ptr = numberAsString;
+        data.value.asBytes.length = sizeof(numberAsString);
+        data.value.asBytes.encoding = NULL;
+    }
     if (dpiObject_getElementValueByIndex(obj->handle, index,
             obj->type->elementTypeInfo.nativeTypeNum, &data) < 0 )
         return njsUtils_throwErrorDPI(env, globals);
@@ -459,6 +471,7 @@ NJS_NAPI_METHOD_IMPL_SYNC(njsDbObject_getValues, 0, &njsClassDefDbObject)
     uint32_t arrayPos;
     napi_value temp;
     dpiData data;
+    char numberAsString[200];
 
     // determine the size of the collection and create an array of that length
     if (dpiObject_getSize(obj->handle, &size) < 0)
@@ -471,6 +484,11 @@ NJS_NAPI_METHOD_IMPL_SYNC(njsDbObject_getValues, 0, &njsClassDefDbObject)
     if (dpiObject_getFirstIndex(obj->handle, &index, &exists) < 0)
         return njsUtils_throwErrorDPI(env, globals);
     while (exists) {
+        if (obj->type->elementTypeInfo.oracleTypeNum == DPI_ORACLE_TYPE_NUMBER) {
+            data.value.asBytes.ptr = numberAsString;
+            data.value.asBytes.length = sizeof(numberAsString);
+            data.value.asBytes.encoding = NULL;
+        }
         if (dpiObject_getElementValueByIndex(obj->handle, index,
                 obj->type->elementTypeInfo.nativeTypeNum, &data) < 0)
             return njsUtils_throwErrorDPI(env, globals);
@@ -627,6 +645,7 @@ static bool njsDbObject_transformFromOracle(njsDbObject *obj, napi_env env,
         case DPI_ORACLE_TYPE_NCHAR:
         case DPI_ORACLE_TYPE_VARCHAR:
         case DPI_ORACLE_TYPE_NVARCHAR:
+        case DPI_ORACLE_TYPE_NUMBER:
             NJS_CHECK_NAPI(env, napi_create_string_utf8(env,
                     data->value.asBytes.ptr, data->value.asBytes.length,
                     value))
@@ -636,15 +655,6 @@ static bool njsDbObject_transformFromOracle(njsDbObject *obj, napi_env env,
                     data->value.asBytes.length, data->value.asBytes.ptr, NULL,
                     value))
             return true;
-        case DPI_ORACLE_TYPE_NUMBER:
-            if (typeInfo->nativeTypeNum == DPI_NATIVE_TYPE_INT64) {
-                NJS_CHECK_NAPI(env, napi_create_int64(env, data->value.asInt64,
-                        value))
-            } else {
-                NJS_CHECK_NAPI(env, napi_create_double(env,
-                        data->value.asDouble, value))
-            }
-            return true;
         case DPI_ORACLE_TYPE_NATIVE_INT:
             NJS_CHECK_NAPI(env, napi_create_int64(env, data->value.asInt64,
                     value))
@@ -712,6 +722,7 @@ static bool njsDbObject_transformToOracle(njsDbObject *obj, napi_env env,
         njsDbObjectAttr *attr, njsModuleGlobals *globals)
 {
     napi_value constructor, getComponentsFn;
+    napi_value numStr;
     napi_valuetype valueType;
     njsDbObject *valueObj;
     bool check, tempBool;
@@ -738,8 +749,19 @@ static bool njsDbObject_transformToOracle(njsDbObject *obj, napi_env env,
             dpiData_setBytes(data, *strBuffer, (uint32_t) length);
             return true;
 
-        // numbers are handled as doubles in JavaScript
+        // numbers are handled as doubles in JavaScript.
+        // If property type is NUMBER, we write string.
         case napi_number:
+        case napi_bigint:
+            if (oracleTypeNum == DPI_ORACLE_TYPE_NUMBER) {
+                // Write to NUMBER/ INTEGER properties astring.
+                NJS_CHECK_NAPI(env, napi_coerce_to_string(env, value, &numStr))
+                if (!njsUtils_copyStringFromJS(env, numStr, strBuffer, &length))
+                    return false;
+                *nativeTypeNum = DPI_NATIVE_TYPE_BYTES;
+                dpiData_setBytes(data, *strBuffer, (uint32_t)length);
+                return true;
+            }
             NJS_CHECK_NAPI(env, napi_get_value_double(env, value,
                     &data->value.asDouble));
             *nativeTypeNum = DPI_NATIVE_TYPE_DOUBLE;
@@ -1033,7 +1055,13 @@ static bool njsDbObjectType_populateTypeInfo(njsDataTypeInfo *info,
     napi_value temp;
 
     info->oracleTypeNum = sourceInfo->oracleTypeNum;
-    info->nativeTypeNum = sourceInfo->defaultNativeTypeNum;
+    if (sourceInfo->oracleTypeNum == DPI_ORACLE_TYPE_NUMBER) {
+        // For NUMBER property, we want to retrieve always as
+        // DPI_NATIVE_TYPE_BYTES not DPI_NATIVE_TYPE_DOUBLE.
+        info->nativeTypeNum = DPI_NATIVE_TYPE_BYTES;
+    } else {
+        info->nativeTypeNum = sourceInfo->defaultNativeTypeNum;
+    }
     info->precision = sourceInfo->precision;
     info->scale = sourceInfo->scale;
     info->dbSizeInBytes = sourceInfo->dbSizeInBytes;
diff --git a/test/bigInt.js b/test/bigInt.js
diff --git a/test/dbObject20.js b/test/dbObject20.js
diff --git a/test/list.txt b/test/list.txt
