oracledb 7.0.0 → 26.0.0

package/lib/errors.js

@@ -27,6 +27,8 @@
 
 const util = require('util');
 
+const constants = require('./constants.js');
+
 // define error prefix for all messages
 const ERR_PREFIX = "NJS";
 
@@ -198,6 +200,16 @@ const ERR_INVALID_END_USER_SECURITY_CONTEXT_LENGTH = 189;
 const ERR_END_USER_SECURITY_CONTEXT_REQUIRES_TCPS = 190;
 const ERR_UNSUPPORTED_DEEP_DATA_SECURITY_FEATURE = 191;
 const ERR_CHAR_CS_NOT_SUPPORTED = 192;
+const ERR_INVALID_PROPERTY_LENGTH = 193;
+const ERR_UNSUPPORTED_JSON_VALUE_TYPE = 194;
+const ERR_NON_FINITE_JSON_NUMBER = 195;
+const ERR_UNSUPPORTED_JSON_FIELD_NAME = 196;
+const ERR_UNSUPPORTED_DB_OTEL_FEATURE = 197;
+const ERR_END_USER_SECURITY_CONTEXT_PROVIDER = 198;
+const ERR_INVALID_SECURITY_CONTEXT_METADATA = 199;
+const ERR_INVALID_SECURITY_CONTEXT_CALLBACK = 200;
+const ERR_TIMESTAMP_LTZ_REGION_NOT_SUPPORTED = 201;
+const ERR_CONFLICTING_SECURITY_CONTEXT_IDENTITIES = 202;
 
 // Oracle Net layer errors start from 500
 const ERR_CONNECTION_CLOSED = 500;
@@ -232,6 +244,8 @@ const ERR_ANO_NEGOTIATION = 533;
 const ERR_DATA_COMPRESSION = 534;
 const ERR_CONFIG_PROVIDER_PARAM_TYPE = 535;
 const ERR_TOO_MANY_REDIRECTS = 536;
+const ERR_TXN_PRIORITY_NOT_SUPPORTED = 537;
+const ERR_INVALID_TXN_PRIORITY = 538;
 
 // Oracle SUCCESS_WITH_INFO warning start from 700
 const WRN_COMPILATION_CREATE = 700;
@@ -246,6 +260,7 @@ adjustErrorXref.set("DPI-1055", ERR_NAN_VALUE);
 adjustErrorXref.set("DPI-1063", ERR_EXEC_MODE_ONLY_FOR_DML);
 adjustErrorXref.set("DPI-1067", [ERR_CALL_TIMEOUT_EXCEEDED, "call timeout of ([0-9]+) ms"]);
 adjustErrorXref.set("DPI-1080", ERR_CONNECTION_CLOSED);
+adjustErrorXref.set("DPI-1087", ERR_NOT_A_QUERY);
 adjustErrorXref.set("OCI-22303", [ERR_INVALID_OBJECT_TYPE_NAME, 'type "([^"]*"."[^"]*)"']);
 adjustErrorXref.set("OCI-22164", ERR_DELETE_ELEMENTS_OF_VARRAY);
 adjustErrorXref.set("OCI-22165", [ERR_INVALID_COLL_INDEX_SET, /index \[([0-9]+)\] must be in the range of \[([0-9]+)\] to \[([0-9]+)\]/]);
@@ -275,6 +290,7 @@ adjustErrorXref.set("ORA-12570", ERR_CONNECTION_CLOSED);
 adjustErrorXref.set("ORA-12583", ERR_CONNECTION_CLOSED);
 adjustErrorXref.set("ORA-27146", ERR_CONNECTION_CLOSED);
 adjustErrorXref.set("ORA-28511", ERR_CONNECTION_CLOSED);
+adjustErrorXref.set("ORA-29970", ERR_INVALID_SUBSCR);
 adjustErrorXref.set("ORA-56600", ERR_CONNECTION_CLOSED);
 adjustErrorXref.set("ORA-24315", ERR_APP_CONTEXT_EMPTY_NAMESPACE);
 adjustErrorXref.set("ORA-24338", ERR_INVALID_REF_CURSOR);
@@ -283,6 +299,7 @@ adjustErrorXref.set("ORA-24344", WRN_COMPILATION_CREATE);
 adjustErrorXref.set("ORA-26202", ERR_SESSIONLESS_INACTIVE);
 adjustErrorXref.set("ORA-26211", ERR_SESSIONLESS_DIFFERING_METHODS);
 adjustErrorXref.set("ORA-26216", ERR_SESSIONLESS_ALREADY_ACTIVE);
+adjustErrorXref.set("ORA-24562", ERR_TXN_PRIORITY_NOT_SUPPORTED);
 adjustErrorXref.set("DPI-1071", ERR_PAYLOAD_CANNOT_BE_ENQUEUED);
 
 // define mapping for error messages
@@ -534,19 +551,19 @@ messages.set(ERR_OPERATION_ONLY_SUPPORTED_ON_BFILE,     // NJS-156
 messages.set(ERR_EXECMANY_NOT_ALLOWED_ON_QUERIES,       // NJS-157
   'executeMany() cannot be used with SELECT statement or WITH SQL clause');
 messages.set(ERR_VECTOR_SPARSE_INDICES_IS_NOT_ARRAY,    // NJS-158
-  'SPARSE VECTOR indices is not Uint32Array or an Array');
+  'SPARSE VECTOR indices must be of type Uint32Array or a regular JavaScript array');
 messages.set(ERR_VECTOR_SPARSE_VALUES_IS_NOT_ARRAY,     // NJS-159
-  'SPARSE VECTOR values is not an Array');
+  'SPARSE VECTOR values is not an array');
 messages.set(ERR_VECTOR_SPARSE_DIMS_IS_NOT_INTEGER,     // NJS-160
-  'SPARSE VECTOR dimensions is not an Positive Integer');
+  'SPARSE VECTOR dimensions must be a positive integer value');
 messages.set(ERR_VECTOR_SPARSE_INDICES_VALUES_NOT_EQUAL, // NJS-161
   'SPARSE VECTOR indices and values must be of same length');
 messages.set(ERR_VECTOR_SPARSE_INVALID_JSON,           // NJS-162
   'SPARSE VECTOR string data is not valid JSON');
 messages.set(ERR_VECTOR_SPARSE_INVALID_STRING,         // NJS-163
-  'SPARSE VECTOR string data Array should have exactly 3 elements');
+  'SPARSE VECTOR string data array should have exactly 3 elements');
 messages.set(ERR_VECTOR_SPARSE_INVALID_INPUT,           // NJS-164
-  'SPARSE VECTOR Invalid Input Data');
+  '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
@@ -603,6 +620,26 @@ messages.set(ERR_UNSUPPORTED_DEEP_DATA_SECURITY_FEATURE,   // NJS-191
   'database version does not support the Oracle Deep Data Security feature');
 messages.set(ERR_CHAR_CS_NOT_SUPPORTED,                 // NJS-192
   'Character set id %d is not supported by node-oracledb in Thin mode');
+messages.set(ERR_INVALID_PROPERTY_LENGTH,               // NJS-193
+  'The length of the parameter %s exceeds the maximum allowed length of %d');
+messages.set(ERR_UNSUPPORTED_JSON_VALUE_TYPE,           // NJS-194
+  'Unsupported JavaScript type "%s" in JSON value');
+messages.set(ERR_NON_FINITE_JSON_NUMBER,                // NJS-195
+  'Non-finite numbers are not supported in JSON value');
+messages.set(ERR_UNSUPPORTED_JSON_FIELD_NAME,           // NJS-196
+  'Unsupported JSON field name "%s"');
+messages.set(ERR_UNSUPPORTED_DB_OTEL_FEATURE,           // NJS-197
+  'The current database version does not support Oracle Database OpenTelemetry tracing');
+messages.set(ERR_END_USER_SECURITY_CONTEXT_PROVIDER,    // NJS-198
+  'end user security context provider failed');
+messages.set(ERR_INVALID_SECURITY_CONTEXT_METADATA,     // NJS-199
+  'runWithContext() expects a non-null metadata object');
+messages.set(ERR_INVALID_SECURITY_CONTEXT_CALLBACK,     // NJS-200
+  'runWithContext() expects a function callback');
+messages.set(ERR_TIMESTAMP_LTZ_REGION_NOT_SUPPORTED,    // NJS-201
+  'TIMESTAMP WITH LOCAL TIME ZONE is not supported in Thin mode when DBTIMEZONE is a region: %s. Use a fixed-offset DBTIMEZONE, such as +00:00, to use this type in Thin mode.');
+messages.set(ERR_CONFLICTING_SECURITY_CONTEXT_IDENTITIES, // NJS-202
+  'runWithContext() metadata cannot combine endUserToken with endUserName or key');
 
 // Oracle Net layer errors
 
@@ -670,6 +707,10 @@ messages.set(ERR_CONFIG_PROVIDER_PARAM_TYPE,               // NJS-535
   'Parameter does not have a valid type: %s\n');
 messages.set(ERR_TOO_MANY_REDIRECTS,               // NJS-536
   'Too many connect redirects (limit: %d)');
+messages.set(ERR_TXN_PRIORITY_NOT_SUPPORTED,            // NJS-537
+  'Server does not support changing the transaction priority.');
+messages.set(ERR_INVALID_TXN_PRIORITY,                  // NJS-538
+  'Invalid value for parameter txnPriority.');
 messages.set(WRN_COMPILATION_CREATE,                    // NJS-700
   'creation succeeded with compilation errors');
 
@@ -793,6 +834,21 @@ function assertParamValue(condition, parameterNum) {
   assert(condition, ERR_INVALID_PARAMETER_VALUE, parameterNum);
 }
 
+//-----------------------------------------------------------------------------
+// assertPropLength()
+//
+// Asserts that the property value is of specified type and doesn't exceed
+// maximum specified length
+//-----------------------------------------------------------------------------
+function assertPropLength(value, propType, propMaxLength, propName) {
+  if (propType !== 'array')
+    assertPropValue(typeof value === propType, propName);
+  else
+    assertPropValue(Array.isArray(value), propName);
+  assert(value.length <= propMaxLength, ERR_INVALID_PROPERTY_LENGTH, propName,
+    propMaxLength);
+}
+
 //-----------------------------------------------------------------------------
 // assertPropValue()
 //
@@ -802,6 +858,21 @@ function assertPropValue(condition, propName) {
   assert(condition, ERR_INVALID_PROPERTY_VALUE, propName);
 }
 
+//-----------------------------------------------------------------------------
+// assertTxnPriority()
+//
+// Asserts that the transaction priority is a supported value.
+//-----------------------------------------------------------------------------
+function assertTxnPriority(value) {
+  assert(typeof value === 'string', ERR_INVALID_TXN_PRIORITY);
+  const normalizedValue = value.toUpperCase();
+  assert(normalizedValue === constants.TXN_PRIORITY_HIGH ||
+    normalizedValue === constants.TXN_PRIORITY_MEDIUM ||
+    normalizedValue === constants.TXN_PRIORITY_LOW ||
+    normalizedValue === constants.TXN_PRIORITY_DEFAULT,
+  ERR_INVALID_TXN_PRIORITY);
+}
+
 //-----------------------------------------------------------------------------
 // getErr()
 //
@@ -816,6 +887,9 @@ function getErr(errorNum) {
     errorNum = ERR_INVALID_ERR_NUM;
     baseText = messages.get(errorNum);
   }
+  if (errorNum === ERR_INVALID_PACKET && args.length > 1) {
+    baseText += '. Cause: %s';
+  }
   const errorNumStr = errorNum.toString().padStart(3, '0');
   const code = `${ERR_PREFIX}-${errorNumStr}`;
   args[0] = `${code}: ${baseText}`;
@@ -1106,6 +1180,17 @@ module.exports = {
   ERR_PIPELINE_EXEC_OPTION_NOT_SUPPORTED,
   ERR_INVALID_SQL_NAME,
   ERR_CHAR_CS_NOT_SUPPORTED,
+  ERR_UNSUPPORTED_JSON_VALUE_TYPE,
+  ERR_NON_FINITE_JSON_NUMBER,
+  ERR_UNSUPPORTED_JSON_FIELD_NAME,
+  ERR_UNSUPPORTED_DB_OTEL_FEATURE,
+  ERR_TXN_PRIORITY_NOT_SUPPORTED,
+  ERR_INVALID_TXN_PRIORITY,
+  ERR_END_USER_SECURITY_CONTEXT_PROVIDER,
+  ERR_INVALID_SECURITY_CONTEXT_METADATA,
+  ERR_INVALID_SECURITY_CONTEXT_CALLBACK,
+  ERR_TIMESTAMP_LTZ_REGION_NOT_SUPPORTED,
+  ERR_CONFLICTING_SECURITY_CONTEXT_IDENTITIES,
   WRN_COMPILATION_CREATE,
   assert,
   assertArgCount,
@@ -1117,7 +1202,9 @@ module.exports = {
   assertParamPropUnsignedIntNonZero,
   assertParamPropValue,
   assertParamValue,
+  assertPropLength,
   assertPropValue,
+  assertTxnPriority,
   getErr,
   throwErr,
   throwErrWithORAError,

package/lib/impl/connection.js

@@ -238,6 +238,15 @@ class ConnectionImpl {
     errors.throwNotImplemented("getting current schema");
   }
 
+  //---------------------------------------------------------------------------
+  // getDatabaseOpenTelemetryTracing()
+  //
+  // Returns the database OpenTelemetry trace propagation flag.
+  //---------------------------------------------------------------------------
+  getDatabaseOpenTelemetryTracing() {
+    errors.throwNotImplemented("getting database OpenTelemetry trace propagation");
+  }
+
   //---------------------------------------------------------------------------
   // getDbDomain()
   //
@@ -430,6 +439,15 @@ class ConnectionImpl {
     errors.throwNotImplemented("getting information about warning");
   }
 
+  //---------------------------------------------------------------------------
+  // getTxnPriority()
+  //
+  // Returns the transaction priority associated with the connection.
+  //---------------------------------------------------------------------------
+  getTxnPriority() {
+    errors.throwNotImplemented("getting transaction priority");
+  }
+
   //---------------------------------------------------------------------------
   // isHealthy()
   //
@@ -515,6 +533,15 @@ class ConnectionImpl {
     errors.throwNotImplemented("setting end-to-end attribute 'dbOp'");
   }
 
+  //---------------------------------------------------------------------------
+  // setDatabaseOpenTelemetryTracing()
+  //
+  // Sets the database OpenTelemetry trace propagation flag.
+  //---------------------------------------------------------------------------
+  setDatabaseOpenTelemetryTracing() {
+    errors.throwNotImplemented("setting database OpenTelemetry trace propagation");
+  }
+
   //---------------------------------------------------------------------------
   // setECID()
   //
@@ -587,6 +614,15 @@ class ConnectionImpl {
     errors.throwNotImplemented("setting the tag for the connection");
   }
 
+  //---------------------------------------------------------------------------
+  // setTxnPriority()
+  //
+  // Sets the transaction priority associated with the connection.
+  //---------------------------------------------------------------------------
+  setTxnPriority() {
+    errors.throwNotImplemented("setting transaction priority");
+  }
+
   //---------------------------------------------------------------------------
   // shutdown()
   //

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/parserHelpers.js

@@ -81,8 +81,8 @@ const CONNECT_OVERRIDES = [
 
   // SECURITY parameters
   { opt: 'walletLocation', section: ['DESCRIPTION', 'SECURITY', 'MY_WALLET_DIRECTORY'] },
-  { opt: 'sslServerCertDn', section: ['DESCRIPTION', 'SECURITY', 'SSL_SERVER_CERT_DN'] },
-  { opt: 'sslServerDnMatch', section: ['DESCRIPTION', 'SECURITY', 'SSL_SERVER_DN_MATCH'] },
+  { opt: 'sslServerCertDN', section: ['DESCRIPTION', 'SECURITY', 'SSL_SERVER_CERT_DN'] },
+  { opt: 'sslServerDNMatch', section: ['DESCRIPTION', 'SECURITY', 'SSL_SERVER_DN_MATCH'] },
 
   // ADDRESS parameters
   { opt: 'httpsProxy', section: ['DESCRIPTION', 'ADDRESS', 'HTTPS_PROXY'], perAddress: true },
@@ -297,6 +297,10 @@ async function applyConnectStringOverrides(options) {
     if (raw === undefined) {
       continue;
     }
+    // Treat walletLocation=SYSTEM as "use system certs" -> do not inject into descriptor
+    if (def.opt === 'walletLocation' && typeof raw === 'string' && raw.trim().toUpperCase() === 'SYSTEM') {
+      continue;
+    }
     const formatter = def.fmt || (v => v);
     const value = formatter(raw);
     configured.push({ def, value });

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;
       }