oracledb 7.0.1 → 26.0.0

package/lib/impl/datahandlers/buffer.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -44,7 +44,7 @@ class BaseBuffer {
   // The initializer is either an integer specifying the size of the buffer, or
   // an existing Buffer, which is used directly.
   //---------------------------------------------------------------------------
-  constructor(initializer) {
+  constructor(initializer, caps) {
     if (typeof initializer === 'number') {
       this.buf = Buffer.alloc(initializer);
       this.size = 0;
@@ -54,6 +54,7 @@ class BaseBuffer {
       this.size = this.maxSize = initializer.length;
     }
     this.pos = 0;
+    this.caps = caps;
   }
 
   //---------------------------------------------------------------------------
@@ -84,29 +85,42 @@ class BaseBuffer {
   // Read an integer from the buffer of the specified maximum size and returns
   // it. The signed flag indicates whether the value is allowed to be signed or
   // not and the skip flag indicates whether the data should simply be skipped.
+  // The asBigInt flag indicates whether the value should be returned as a
+  // BigInt instead of a Number.
   //---------------------------------------------------------------------------
-  _readInteger(maxSize, signed, skip) {
+  _readInteger(maxSize, signed, skip, asBigInt = false) {
     let isNegative = false;
     let size = this.readUInt8();
     if (size === 0) {
-      return 0;
+      return asBigInt ? 0n : 0;
     } else if (size & 0x80) {
       if (!signed) {
-        errors.throwErr(errors.ERR_UNEXPECTED_NEGATIVE_INTEGER, this.pos, this.packetNum);
+        errors.throwErr(errors.ERR_UNEXPECTED_NEGATIVE_INTEGER, this.pos,
+          this.packetNum);
       }
       isNegative = true;
       size = size & 0x7f;
     }
     if (size > maxSize) {
-      errors.throwErr(errors.ERR_INTEGER_TOO_LARGE, size, maxSize, this.pos, this.packetNum);
+      errors.throwErr(errors.ERR_INTEGER_TOO_LARGE, size, maxSize, this.pos,
+        this.packetNum);
     }
     if (skip) {
       this.skipBytes(size);
+      return;
+    }
+
+    const buf = this.readBytes(size);
+    let value;
+    if (asBigInt) {
+      value = 0n;
+      for (const byte of buf) {
+        value = (value << 8n) | BigInt(byte);
+      }
     } else {
-      const buf = this.readBytes(size);
-      const value = buf.readUIntBE(0, size);
-      return (isNegative) ? -value : value;
+      value = buf.readUIntBE(0, size);
     }
+    return isNegative ? -value : value;
   }
 
   //---------------------------------------------------------------------------
@@ -175,17 +189,22 @@ class BaseBuffer {
   // assumed at this point that the size of the buffer is either 7 bytes (date
   // or compressed timestamp), 11 bytes (timestamp) or 13 bytes (timestamp with
   // time zone). Time zone information is discarded because Node.js uses UTC
-  // timestamps and the server returns the data in that format, too. The Date
-  // type in Node.js doesn't support time zone information.
+  // timestamps. TIMESTAMP WITH LOCAL TIME ZONE is returned in the database
+  // time zone and needs its offset to produce the original UTC instant.
   //---------------------------------------------------------------------------
-  parseOracleDate(buf, useLocalTime = true) {
+  parseOracleDate(buf, useLocalTime = true, useDbTz = false) {
     let fseconds = 0;
     if (buf.length >= 11) {
       fseconds = Math.floor(buf.readUInt32BE(7) / (1000 * 1000));
     }
     const year = (buf[0] - 100) * 100 + buf[1] - 100;
+    if (useDbTz && this.caps?.dbTzRegion) {
+      errors.throwErr(errors.ERR_TIMESTAMP_LTZ_REGION_NOT_SUPPORTED,
+        this.caps.dbTzRegion);
+    }
+    const offset = useDbTz ? this.caps?.dbTzOffset ?? 0 : 0;
     return nodbUtil.makeDate(useLocalTime, year, buf[2], buf[3], buf[4] - 1,
-      buf[5] - 1, buf[6] - 1, fseconds, 0);
+      buf[5] - 1, buf[6] - 1, fseconds, offset);
   }
 
   //---------------------------------------------------------------------------
@@ -475,12 +494,12 @@ class BaseBuffer {
   // Reads an Oracle date from the buffer and returns a Date or a String,
   // depending on the desired type.
   //---------------------------------------------------------------------------
-  readOracleDate(useLocalTime) {
+  readOracleDate(useLocalTime, useDbTz = false) {
     const buf = this.readBytesWithLength();
     if (!buf) {
       return null;
     }
-    return this.parseOracleDate(buf, useLocalTime);
+    return this.parseOracleDate(buf, useLocalTime, useDbTz);
   }
 
   //---------------------------------------------------------------------------
@@ -609,6 +628,17 @@ class BaseBuffer {
     return this._readInteger(8, false, false);
   }
 
+  //---------------------------------------------------------------------------
+  // readUB8BigInt()
+  //
+  // Reads an unsigned, variable length integer of up to 8 bytes in length as
+  // a BigInt. This preserves values that cannot safely be represented by a
+  // JavaScript Number.
+  //---------------------------------------------------------------------------
+  readUB8BigInt() {
+    return this._readInteger(8, false, false, true);
+  }
+
   //---------------------------------------------------------------------------
   // readUInt8()
   //
@@ -856,6 +886,16 @@ class BaseBuffer {
   writeOracleDate(date, type, writeLength = true) {
     let fsec;
     let length = type._bufferSizeFactor;
+    if (type === types.DB_TYPE_TIMESTAMP_LTZ) {
+      if (this.caps?.dbTzRegion) {
+        errors.throwErr(errors.ERR_TIMESTAMP_LTZ_REGION_NOT_SUPPORTED,
+          this.caps.dbTzRegion);
+      }
+      const offset = this.caps?.dbTzOffset;
+      if (offset !== null && offset !== undefined) {
+        date = new Date(date.getTime() + offset * 60000);
+      }
+    }
     if (length > 7) {
       fsec = date.getUTCMilliseconds() * 1000 * 1000;
       if (fsec === 0 && length <= 11)
@@ -1123,6 +1163,29 @@ class BaseBuffer {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // writeUB8BigInt()
+  //
+  // Writes an unsigned BigInt in variable length format, up to eight bytes.
+  //---------------------------------------------------------------------------
+  writeUB8BigInt(value) {
+    if (value === 0n) {
+      this.writeUInt8(0);
+    } else if (value <= 0xffn) {
+      this.writeUInt8(1);
+      this.writeUInt8(Number(value));
+    } else if (value <= 0xffffn) {
+      this.writeUInt8(2);
+      this.writeUInt16BE(Number(value));
+    } else if (value <= 0xffffffffn) {
+      this.writeUInt8(4);
+      this.writeUInt32BE(Number(value));
+    } else {
+      this.writeUInt8(8);
+      this.writeBigUInt64BE(value);
+    }
+  }
+
   //---------------------------------------------------------------------------
   // writeUInt8()
   //
@@ -1175,6 +1238,16 @@ class BaseBuffer {
     this.buf.writeUInt32BE(n, pos + 4);
   }
 
+  //---------------------------------------------------------------------------
+  // writeBigUInt64BE()
+  //
+  // Writes an unsigned BigInt value up to 64 bits in big endian order.
+  //---------------------------------------------------------------------------
+  writeBigUInt64BE(n) {
+    const pos = this.reserveBytes(8);
+    this.buf.writeBigUInt64BE(n, pos);
+  }
+
   //---------------------------------------------------------------------------
   // writeUInt16LE()
   //
@@ -1194,11 +1267,11 @@ class GrowableBuffer extends BaseBuffer {
   //
   // Initializes the buffer with an initial fixed chunk size.
   //---------------------------------------------------------------------------
-  constructor(initializer) {
+  constructor(initializer, caps) {
     if (initializer) {
-      super(initializer);
+      super(initializer, caps);
     } else {
-      super(constants.BUFFER_CHUNK_SIZE);
+      super(constants.BUFFER_CHUNK_SIZE, caps);
       this.size = this.maxSize;
     }
   }

package/lib/impl/datahandlers/oson.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -754,7 +754,8 @@ class OsonEncoder extends GrowableBuffer {
     this.maxFieldNameSize = maxFieldNameSize;
 
     // determine the flags to use
-    let flags = constants.TNS_JSON_FLAG_INLINE_LEAF;
+    let flags = constants.TNS_JSON_FLAG_INLINE_LEAF |
+      constants.TNS_JSON_FLAG_LEN_IN_PCODE;
     if (Array.isArray(value) || (value && Array.isArray(value.fields))) {
       // examine all values recursively to determine the unique set of field
       // names and whether they need to be added to the long field names

package/lib/impl/resultset.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -200,6 +200,17 @@ class ResultSetImpl extends BaseImpl {
     return this._parentObj;
   }
 
+  //---------------------------------------------------------------------------
+  // _getDbObjectType()
+  //
+  // Return the object identifying the object type. These are cached by fully
+  // qualified name and by OID (thin mode only).
+  //---------------------------------------------------------------------------
+  _getDbObjectType(schema, name, packageName, oid) {
+    return this._getConnImpl()._getDbObjectType(schema, name, packageName,
+      oid);
+  }
+
   //---------------------------------------------------------------------------
   // _setup()
   //
@@ -210,7 +221,7 @@ class ResultSetImpl extends BaseImpl {
   //---------------------------------------------------------------------------
   _setup(options, metaData) {
     this._parentObj = options.connection._impl;
-    this.metaData = metaData;
+    this.metaData = [];
     this.lobIndices = [];
     this.dbObjectIndices = [];
     this.nestedCursorIndices = [];
@@ -227,13 +238,23 @@ class ResultSetImpl extends BaseImpl {
       }
     }
     for (let i = 0; i < metaData.length; i++) {
-      const info = metaData[i];
-      if (info.dbTypeClass) {
-        const cls = options.connection._getDbObjectClass(info.dbTypeClass);
-        info.dbTypeClass = cls;
+      const fetchInfo = metaData[i];
+      if (fetchInfo.dbTypeClass) {
+        const cls = options.connection._getDbObjectClass(fetchInfo.dbTypeClass);
+        fetchInfo.dbTypeClass = cls;
       }
-      nodbUtil.addTypeProperties(info, "dbType");
+      nodbUtil.addTypeProperties(fetchInfo, "dbType");
+
+      // Use a per-resultset metadata copy so any fetchTypeHandler or
+      // resultset-specific metadata mutations (for example renaming columns)
+      // do not leak back into the underlying statement metadata.
+      // This is also applied in thick mode for consistency, even though the
+      // extra copy is only needed to protect the thin-mode cached metadata.
+      const info = {...fetchInfo};
+      this.metaData.push(info);
       this._determineFetchType(info, options, metaData);
+      fetchInfo.fetchType = info.fetchType;
+      fetchInfo.converter = info.converter;
       if (info.fetchType === types.DB_TYPE_CURSOR) {
         this.nestedCursorIndices.push(i);
       } else if (info.fetchType === types.DB_TYPE_CLOB ||
@@ -281,7 +302,9 @@ class ResultSetImpl extends BaseImpl {
   //---------------------------------------------------------------------------
   // _getAllRows() [INTERNAL]
   //
-  // Fetches all the rows from the database to use internally.
+  // Fetches all the rows from the database to use internally. getRows()
+  // already materializes and consumes each batch, so this method only
+  // accumulates the returned rows.
   //---------------------------------------------------------------------------
   async _getAllRows() {
     const fetchArraySize = 100;
@@ -290,10 +313,8 @@ class ResultSetImpl extends BaseImpl {
     while (true) {
       // constant default value for fetchArraySize
       const rows = await this.getRows(fetchArraySize, {});
-      if (rows) {
-        await this._processRows(rows, false);
+      if (rows)
         rowsFetched = rowsFetched.concat(rows);
-      }
       if (rows.length < fetchArraySize) {
         break;
       }

package/lib/oracledb.js

@@ -66,6 +66,7 @@ const SodaCollection = require('./sodaCollection.js');
 const SodaDocCursor = require('./sodaDocCursor.js');
 const SodaDocument = require('./sodaDocument.js');
 const SodaOperation = require('./sodaOperation.js');
+const securityContextProviderModule = require('./securityContextProvider.js');
 const EndUserSecurityContext = require('./endUserSecurityContext.js');
 
 const poolCache = {};
@@ -417,6 +418,12 @@ async function _verifyOptions(options, inCreatePool) {
     outOptions.appContext = options.appContext;
   }
 
+  // txnPriority must be a supported value
+  if (options.txnPriority !== undefined) {
+    errors.assertTxnPriority(options.txnPriority);
+    outOptions.txnPriority = options.txnPriority;
+  }
+
   // check pool specific options
   if (inCreatePool) {
 
@@ -631,6 +638,11 @@ async function createPool(options) {
       errors.throwWrapErr(error, errors.ERR_CALLOUT_FN);
     }
   }
+  // Connect-string parsing can rebuild the options object and omit internal
+  // fields. Preserve the hook-provided unified-security state before that.
+  const securityContextProviderForPool = options._securityContextProvider;
+  // This is driver-only state and must not be passed to the implementation.
+  delete options._securityContextProvider;
   options = await _updateUserOptionsFromConnectString(options, true);
   const sessionCallback = options.sessionCallback;
   if (typeof sessionCallback === 'function')
@@ -715,6 +727,7 @@ async function createPool(options) {
   }
 
   pool._setup(options, poolAlias);
+  pool._securityContextProvider = securityContextProviderForPool;
   pool._sessionCallback = sessionCallback;
   pool.on('_afterPoolClose', () => {
     if (pool.poolAlias) {
@@ -781,6 +794,9 @@ async function getConnection(a1) {
       errors.throwWrapErr(error, errors.ERR_CALLOUT_FN);
     }
   }
+  const securityContextProviderForConnection = options._securityContextProvider;
+  // This is driver-only state and must not be passed to the implementation.
+  delete options._securityContextProvider;
   // create a standalone connection
   options = await _updateUserOptionsFromConnectString(options, false);
   settings.addToOptions(options,
@@ -799,6 +815,7 @@ async function getConnection(a1) {
   }
   const conn = new Connection();
   conn._impl = new impl.ConnectionImpl();
+  conn._impl._securityContextProvider = securityContextProviderForConnection;
 
   conn._impl._connectString = options.connectString;
   conn._impl._user = options.user;
@@ -1213,6 +1230,16 @@ function registerConfigurationProviderHook(configProvider, fn) {
   registeredConfigProviderHooks[configProvider] = fn;
 }
 
+//-----------------------------------------------------------------------------
+// getSecurityContextProvider()
+//
+// Exposes the internal security context provider helpers without requiring
+// callers to reference the module path directly.
+//-----------------------------------------------------------------------------
+function getSecurityContextProvider() {
+  return securityContextProviderModule;
+}
+
 //-----------------------------------------------------------------------------
 // enquoteLiteral()
 //
@@ -1302,6 +1329,7 @@ module.exports = {
   createPool: nodbUtil.callbackify(nodbUtil.wrapFn(createPool)),
   getNetworkServiceNames: nodbUtil.callbackify(nodbUtil.wrapFn(getNetworkServiceNames)),
   getPool,
+  getSecurityContextProvider,
   initOracleClient,
   isQualifiedSqlName,
   isSimpleSqlName,
@@ -1500,6 +1528,12 @@ module.exports = {
   ARRAY: constants.OUT_FORMAT_ARRAY,
   OBJECT: constants.OUT_FORMAT_OBJECT,
 
+  // txnPriority
+  TXN_PRIORITY_HIGH: constants.TXN_PRIORITY_HIGH,
+  TXN_PRIORITY_MEDIUM: constants.TXN_PRIORITY_MEDIUM,
+  TXN_PRIORITY_LOW: constants.TXN_PRIORITY_LOW,
+  TXN_PRIORITY_DEFAULT: constants.TXN_PRIORITY_DEFAULT,
+
   // Trace Interface
   traceHandler,
 

package/lib/pool.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2016, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2016, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -115,6 +115,7 @@ class Pool extends EventEmitter {
     this._user = options.user;
     this._connectString = options.connectString;
     this._status = constants.POOL_STATUS_OPEN;
+    // Current number of connections that are out for processing or being used
     this._connectionsOut = 0;
     this._poolAlias = poolAlias;
     this._bgRequestHandler();
@@ -514,6 +515,9 @@ class Pool extends EventEmitter {
       this._connectionsOut += 1;
       this._pendingRequestQueue.delete(request);
       conn._impl = await this._impl.getConnection(request.options);
+      // Each acquired connection uses the provider configured for this pool.
+      // Pools can have distinct Azure, OCI, or custom OBO configurations.
+      conn._impl._securityContextProvider = this._securityContextProvider;
       conn._pool = this;
       await this._tagFixup(conn, request.options.tag);
       if (request.isWaiting)
@@ -572,12 +576,12 @@ class Pool extends EventEmitter {
   // _processRequest' to decrease connectionsOut & wake up _bgRequestWaiter
   //---------------------------------------------------------------------------
   async _release(impl, options) {
-    this._connectionsOut -= 1;
     try {
       // Directly close the connection using the underlying connection impl
       if (impl)
         await impl.close(options);
     } finally {
+      this._connectionsOut -= 1;
       if (this._connectionsOut == 0)
         this.emit('_allCheckedIn');
       setImmediate(() => {

package/lib/queryStream.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2015, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2015, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -31,10 +31,11 @@ const { Readable } = require('stream');
 
 class QueryStream extends Readable {
 
-  constructor(rs) {
+  constructor(rs, rowsPerDataEvent = 1) {
     super({ objectMode: true });
     this._fetching = false;
     this._numRows = 0;
+    this._rowsPerDataEvent = rowsPerDataEvent;
 
     // calling open via process.nextTick to allow event handlers to be
     // registered prior to the events being emitted
@@ -95,10 +96,17 @@ class QueryStream extends Readable {
     // created via ResultSet.toQueryStream()
     try {
       this._fetching = true;
+      const rows = [];
       this._resultSet._allowGetRowCall = true;
-      const row = await this._resultSet.getRow();
-      if (row) {
-        this.push(row);
+      for (let i = 0; i < this._rowsPerDataEvent; i++) {
+        const row = await this._resultSet.getRow();
+        if (!row)
+          break;
+        rows.push(row);
+        this._resultSet._allowGetRowCall = true;
+      }
+      if (rows.length > 0) {
+        this.push(this._rowsPerDataEvent === 1 ? rows[0] : rows);
       } else {
         this.push(null);
       }

package/lib/resultset.js

@@ -341,8 +341,15 @@ class ResultSet {
   //
   // Converts a result set to a QueryStream object.
   //---------------------------------------------------------------------------
-  toQueryStream() {
-    errors.assertArgCount(arguments, 0, 0);
+  toQueryStream(options) {
+    errors.assertArgCount(arguments, 0, 1);
+    if (arguments.length == 1) {
+      errors.assertParamValue(nodbUtil.isObject(options), 1);
+      options = {...options};
+    } else {
+      options = {};
+    }
+    errors.assertParamPropUnsignedIntNonZero(options, 1, "rowsPerDataEvent");
 
     if (this._processingStarted) {
       errors.throwErr(errors.ERR_CANNOT_CONVERT_RS_TO_STREAM);
@@ -354,7 +361,7 @@ class ResultSet {
 
     this._convertedToStream = true;
 
-    return new QueryStream(this);
+    return new QueryStream(this, options.rowsPerDataEvent);
   }
 
   [Symbol.asyncIterator]() {