oracledb 7.0.1 → 26.0.0

package/lib/thin/protocol/capabilities.js

@@ -45,10 +45,18 @@ class Capabilities {
     this.charsetId = constants.TNS_CHARSET_UTF8;
     this.compileCaps = Buffer.alloc(constants.TNS_CCAP_MAX);
     this.runtimeCaps = Buffer.alloc(constants.TNS_RCAP_MAX);
+    this.dbTzOffset = null;
+
+    // Region-form DBTIMEZONE values are represented by an Oracle region ID in
+    // TTC. dbTzRegion holds the corresponding name obtained from DBTIMEZONE
+    // so LTZ operations can report that this unsupported configuration is used.
+    this.dbTzRegion = null;
     this.initCompileCaps(nscon);
     this.initRuntimeCaps();
     this.maxStringSize = 0;
     this.supportsEndUserSecurityContext = false;
+    this.supportsServerOtelTracing = false;
+    this.supportsTxnPriority = false;
   }
 
   adjustForServerCompileCaps(serverCaps, nscon) {
@@ -65,18 +73,34 @@ class Capabilities {
       nscon.endOfRequestSupport = false;
     }
     const bpIndex = constants.TNS_CCAP_FEATURE_BACKPORT2;
-    if (bpIndex < serverCaps.length &&
-        (serverCaps[bpIndex] & constants.TNS_CCAP_END_USER_SEC_CTX_PIGGYBACK)) {
-      this.supportsEndUserSecurityContext = true;
+    if (bpIndex < serverCaps.length) {
+      if (serverCaps[bpIndex] & constants.TNS_CCAP_END_USER_SEC_CTX_PIGGYBACK) {
+        this.supportsEndUserSecurityContext = true;
+      }
+      if (serverCaps[bpIndex] &
+          constants.TNS_CCAP_TXN_PRIORITY_ALTSESS) {
+        this.supportsTxnPriority = true;
+      }
     }
   }
 
   adjustForServerRuntimeCaps(serverCaps) {
+    // TZ_EX adds timezone fields to the TTIDTY request and response. Only
+    // advertise it when TTIPRO confirms that the server understands those
+    // fields; otherwise datatype negotiation would be decoded out of sync.
+    if (serverCaps.length <= constants.TNS_RCAP_TZ ||
+        !(serverCaps[constants.TNS_RCAP_TZ] & constants.TNS_RCAP_TZ_EX)) {
+      this.runtimeCaps[constants.TNS_RCAP_TZ] = 0;
+    }
     if (serverCaps[constants.TNS_RCAP_TTC] & constants.TNS_RCAP_TTC_32K) {
       this.maxStringSize = 32767;
     } else {
       this.maxStringSize = 4000;
     }
+    this.supportsServerOtelTracing =
+      constants.TNS_RCAP_OTEL < serverCaps.length &&
+      (serverCaps[constants.TNS_RCAP_OTEL] &
+        constants.TNS_RCAP_OTEL_SUPPORTED) !== 0;
   }
 
   initCompileCaps(nscon) {
@@ -134,13 +158,16 @@ class Capabilities {
       constants.TNS_CCAP_PIPELINING_SUPPORT |
       constants.TNS_CCAP_PIPELINING_BREAK |
       constants.TNS_CCAP_TTC5_SESSIONLESS_TXNS;
+    this.compileCaps[constants.TNS_CCAP_FEATURE_BACKPORT2] =
+      constants.TNS_CCAP_TXN_PRIORITY_ALTSESS |
+      constants.TNS_CCAP_END_USER_SEC_CTX_PIGGYBACK;
     this.compileCaps[constants.TNS_CCAP_VECTOR_FEATURES] =
       constants.TNS_CCAP_VECTOR_FEATURE_BINARY | constants.TNS_CCAP_VECTOR_FEATURE_SPARSE;
-    this.compileCaps[constants.TNS_CCAP_FEATURE_BACKPORT2] = constants.TNS_CCAP_END_USER_SEC_CTX_PIGGYBACK;
   }
 
   initRuntimeCaps() {
     this.runtimeCaps[constants.TNS_RCAP_COMPAT] = constants.TNS_RCAP_COMPAT_81;
+    this.runtimeCaps[constants.TNS_RCAP_TZ] = constants.TNS_RCAP_TZ_EX;
     this.runtimeCaps[constants.TNS_RCAP_TTC] =
       constants.TNS_RCAP_TTC_ZERO_COPY | constants.TNS_RCAP_TTC_32K;
   }
@@ -155,6 +182,12 @@ class Capabilities {
       errors.throwErr(errors.ERR_CHAR_CS_NOT_SUPPORTED, this.charsetId);
   }
 
+  assertTxnPrioritySupported() {
+    if (!this.supportsTxnPriority) {
+      errors.throwErr(errors.ERR_TXN_PRIORITY_NOT_SUPPORTED);
+    }
+  }
+
 }
 
 module.exports = Capabilities;

package/lib/thin/protocol/constants.js

@@ -411,6 +411,7 @@ module.exports = {
   TNS_DATA_TYPE_PLBGN: 661,
   TNS_DATA_TYPE_UDS: 663,
   TNS_DATA_TYPE_PLOP: 665,
+  TNS_DATA_TYPE_ALTSESS: 668,
   TNS_DATA_TYPE_KVE: 669,
   TNS_DATA_TYPE_EUSC: 670,
 
@@ -429,6 +430,7 @@ module.exports = {
   TNS_MSG_TYPE_PARAMETER: 8,
   TNS_MSG_TYPE_STATUS: 9,
   TNS_MSG_TYPE_IO_VECTOR: 11,
+  TNS_MSG_TYPE_OAC: 13,
   TNS_MSG_TYPE_LOB_DATA: 14,
   TNS_MSG_TYPE_WARNING: 15,
   TNS_MSG_TYPE_DESCRIBE_INFO: 16,
@@ -449,6 +451,16 @@ module.exports = {
   TNS_KEYWORD_NUM_TRANSACTION_ID: 201,
   TNS_KEYWORD_PDBNAME: 197, // Container Name
   TNS_KEYWORD_DBNAME: 179, // Global DB Name
+  TNS_KEYWORD_MODULE: 184,
+  TNS_KEYWORD_ACTION: 185,
+  TNS_KEYWORD_CLIENT_INFO: 186,
+  TNS_KEYWORD_CLIENT_ID: 198,
+  TNS_KEYWORD_NUM_TXN_PRIORITY: 204,
+
+  // key/value flags
+  // Empty txnPriority uses the same reset semantics as OCI
+  // KPD_TXNPROP_PRI_RESET.
+  TNS_KVAL_FLAG_TXN_PRIORITY_DEFAULT: 0x0001,
 
   // bind flags
   TNS_BIND_USE_INDICATORS: 0x0001,
@@ -538,9 +550,12 @@ module.exports = {
   // end-to-end metrics
   TNS_END_TO_END_ACTION: 0x0010,
   TNS_END_TO_END_CLIENT_IDENTIFIER: 0x0001,
+  TNS_END_TO_END_ECID: 0x0020,
   TNS_END_TO_END_CLIENT_INFO: 0x0100,
   TNS_END_TO_END_DBOP: 0x0200,
   TNS_END_TO_END_MODULE: 0x0008,
+  TNS_END_TO_END_OTEL_RESET: 0x0400,
+  TNS_END_TO_END_OTEL_TRACE: 0x80000000,
 
   // versions
   TNS_VERSION_MIN_ACCEPTED: 315,
@@ -560,6 +575,7 @@ module.exports = {
   TNS_FUNC_FETCH: 5,
   TNS_FUNC_LOB_OP: 96,
   TNS_FUNC_LOGOFF: 9,
+  TNS_FUNC_NOTIFY: 187,
   TNS_FUNC_PING: 147,
   TNS_FUNC_PIPELINE_BEGIN: 199,
   TNS_FUNC_PIPELINE_END: 200,
@@ -568,15 +584,17 @@ module.exports = {
   TNS_FUNC_REEXECUTE: 4,
   TNS_FUNC_REEXECUTE_AND_FETCH: 78,
   TNS_FUNC_SET_SCHEMA: 152,
+  TNS_FUNC_SUBSCRIBE: 125,
   TNS_FUNC_SESSION_GET: 162,
   TNS_FUNC_SESSION_RELEASE: 163,
   TNS_FUNC_SESSION_STATE: 176, // piggyback fn
-  TNS_FUNC_CANCEL_ALL: 120, // piggyback fn
+  TNS_FUNC_CANCEL_CURSORS: 120, // piggyback fn
   TNS_FUNC_TPC_TXN_SWITCH: 103,
   TNS_FUNC_TPC_TXN_CHANGE_STATE: 104,
   TNS_FUNC_AQ_ENQ: 121,
   TNS_FUNC_AQ_DEQ: 122,
   TNS_FUNC_ARRAY_AQ: 145,
+  TNS_FUNC_ALTSESS: 204,
 
   // character sets and encodings
   TNS_CHARSET_UTF8: 873,
@@ -677,17 +695,22 @@ module.exports = {
   TNS_CCAP_VECTOR_FEATURE_SPARSE: 0x02,
   TNS_CCAP_TTC5_SESSIONLESS_TXNS: 0x20,
   TNS_CCAP_OCI3_OCSSYNC: 0x20,
+  TNS_CCAP_TXN_PRIORITY_ALTSESS: 0x01,
   TNS_CCAP_END_USER_SEC_CTX_PIGGYBACK: 0x02,
 
   // runtime capability indices
   TNS_RCAP_COMPAT: 0,
+  TNS_RCAP_TZ: 1,
   TNS_RCAP_TTC: 6,
+  TNS_RCAP_OTEL: 12,
   TNS_RCAP_MAX: 7,
 
   // runtime capability values
   TNS_RCAP_COMPAT_81: 2,
+  TNS_RCAP_TZ_EX: 0x01,
   TNS_RCAP_TTC_ZERO_COPY: 0x01,
   TNS_RCAP_TTC_32K: 0x04,
+  TNS_RCAP_OTEL_SUPPORTED: 0x01,
 
   /** Verifier types. */
   /**  SHA1 (salted). */
@@ -788,6 +811,31 @@ module.exports = {
   TNS_KPD_AQ_BUFMSG: 0x02,
   TNS_KPD_AQ_EITHER: 0x10,
 
+  // subscription opcodes
+  TNS_SUBSCR_OP_REGISTER: 1,
+  TNS_SUBSCR_OP_UNREGISTER: 2,
+
+  // subscription modes/constants
+  TNS_INIT_KPNDRREQ: 1,
+  TNS_SUBSCR_MODE_CLIENT_INITIATED: 4,
+  TNS_SUBSCR_CLIENT_ID_LEN: 29,
+  TNS_SUBSCR_STOP_NOTIF: 0x04,
+
+  // subscription quality of service flags
+  TNS_SUBSCR_QOS_RELIABLE: 0x01,
+  TNS_SUBSCR_QOS_PAYLOAD: 0x02,
+  TNS_SUBSCR_QOS_REPLICATE: 0x04,
+  TNS_SUBSCR_QOS_SECURE: 0x08,
+  TNS_SUBSCR_QOS_PURGE_ON_NTFN: 0x10,
+  TNS_SUBSCR_QOS_MULTICBK: 0x20,
+  TNS_SUBSCR_QOS_ASYNC_DEQ: 0x200,
+  TNS_SUBSCR_QOS_AUTO_ACK: 0x400,
+  TNS_SUBSCR_QOS_TX_ACK: 0x800,
+
+  // subscription flags
+  TNS_SUBSCR_FLAGS_INCLUDE_ROWIDS: 0x10,
+  TNS_SUBSCR_FLAGS_QUERY: 0x20,
+
   TNS_AQ_MESSAGE_ID_LENGTH: 16,
   TNS_AQ_MESSAGE_VERSION: 1,
 

package/lib/thin/protocol/messages/auth.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -117,6 +117,7 @@ class AuthMessage extends Message {
     }
     this.appContext = config.appContext;
     this.setAuthMode(config);
+    this.txnPriority = config.txnPriority;
   }
 
   setAuthMode(config) {
@@ -155,13 +156,13 @@ class AuthMessage extends Message {
     }
   }
 
-  getAlterTimezoneStatement() {
-    let sign, tzRepr;
+  getAlterSessionStatement() {
+    let sign, stmt, tzRepr;
     if (process.env.ORA_SDTZ) {
       tzRepr = process.env.ORA_SDTZ;
       // LOCAL and DBTIMEZONE are SQL keywords and must not be quoted.
       if (["LOCAL", "DBTIMEZONE"].includes(tzRepr.toUpperCase())) {
-        return `ALTER SESSION SET TIME_ZONE =${tzRepr}\x00`;
+        stmt = `ALTER SESSION SET TIME_ZONE =${tzRepr}`;
       }
     } else {
       const date = new Date();
@@ -177,7 +178,16 @@ class AuthMessage extends Message {
       tzHour = tzHour.toLocaleString('en-US', {minimumIntegerDigits: 2});
       tzRepr = `${sign}${tzHour}:${tzMinutes}`;
     }
-    return `ALTER SESSION SET TIME_ZONE =${parser.enquoteLiteral(tzRepr)}\x00`;
+
+    if (stmt === undefined) {
+      stmt = `ALTER SESSION SET TIME_ZONE =${parser.enquoteLiteral(tzRepr)}`;
+    }
+    if (this.txnPriority) {
+      this.conn._protocol.caps.assertTxnPrioritySupported();
+      stmt += ` TXN_PRIORITY = ${parser.enquoteLiteral(this.txnPriority)}`;
+    }
+
+    return `${stmt}\x00`;
   }
 
   encode(buf) {
@@ -290,7 +300,8 @@ class AuthMessage extends Message {
           this.driverName ?? constants.DRIVER_NAME);
         buf.writeKeyValue("SESSION_CLIENT_VERSION",
           constants.CLIENT_VERSION.toString());
-        buf.writeKeyValue("AUTH_ALTER_SESSION", this.getAlterTimezoneStatement(), 1);
+        buf.writeKeyValue("AUTH_ALTER_SESSION",
+          this.getAlterSessionStatement(), 1);
       }
       if (this.encodedPassword) {
         buf.writeKeyValue("AUTH_PASSWORD", this.encodedPassword);

package/lib/thin/protocol/messages/base.js

@@ -452,6 +452,16 @@ class Message {
           this.connection.dbName = keyTextValue;
         } else if (keywordNum === constants.TNS_KEYWORD_PDBNAME) {
           this.connection.pdbName = keyTextValue;
+        } else if (keywordNum === constants.TNS_KEYWORD_ACTION) {
+          this.connection._action = keyTextValue;
+        } else if (keywordNum === constants.TNS_KEYWORD_CLIENT_INFO) {
+          this.connection._clientInfo = keyTextValue;
+        } else if (keywordNum === constants.TNS_KEYWORD_MODULE) {
+          this.connection._module = keyTextValue;
+        } else if (keywordNum === constants.TNS_KEYWORD_CLIENT_ID) {
+          this.connection._clientIdentifier = keyTextValue;
+        } else if (keywordNum === constants.TNS_KEYWORD_NUM_TXN_PRIORITY) {
+          this.connection._txnPriority = keyTextValue;
         }
       }
       buf.skipUB4();                            // skip overall flags
@@ -530,18 +540,27 @@ class Message {
       this._writeCurrentSchemaPiggyback(buf);
     }
     this._writeApplicationContextPiggyback(buf);
-    if (this.connection.statementCache._cursorsToClose.size > 0 && !this.connection._drcpEstablishSession) {
+    if (!this.connection._drcpEstablishSession) {
       // skip closing cursors when '_drcpEstablishSession = true' Since we don't know whether the same session
       // is in use. We can not send the information across until after the session information has been returned
       // (on the first round trip).
-      this.writeCloseCursorsPiggyBack(buf);
+      if (this.connection.statementCache._cursorsToClose.size > 0) {
+        this.writeCursorsPiggyBack(buf, constants.TNS_FUNC_CLOSE_CURSORS,
+          this.connection.statementCache._cursorsToClose);
+      }
+      if (this.connection.statementCache._cursorsToCancel.size > 0) {
+        this.writeCursorsPiggyBack(buf, constants.TNS_FUNC_CANCEL_CURSORS,
+          this.connection.statementCache._cursorsToCancel);
+      }
     }
     if (
       this.connection._actionModified ||
       this.connection._clientIdentifierModified ||
+      this.connection._ecidModified ||
       this.connection._dbOpModified ||
       this.connection._clientInfoModified ||
-      this.connection._moduleModified
+      this.connection._moduleModified ||
+      this.connection._otelModified
     ) {
       this._writeEndToEndPiggybacks(buf);
     }
@@ -553,6 +572,10 @@ class Message {
       this.connection._sessionlessData.piggyback.encode(buf);
       this.connection._sessionlessData.piggyback = null;
     }
+    if (this.connection._txnPriorityModified) {
+      this.connection._protocol.caps.assertTxnPrioritySupported();
+      this._writeAltSessPiggyback(buf);
+    }
   }
 
   writePiggybackHeader(buf, functionCode) {
@@ -565,10 +588,10 @@ class Message {
     }
   }
 
-  writeCloseCursorsPiggyBack(buf) {
-    this.writePiggybackHeader(buf, constants.TNS_FUNC_CLOSE_CURSORS);
+  writeCursorsPiggyBack(buf, functionCode, cursors) {
+    this.writePiggybackHeader(buf, functionCode);
     buf.writeUInt8(1);
-    this.connection.statementCache.writeCursorsToClose(buf);
+    this.connection.statementCache.writeCursors(buf, cursors);
   }
 
   writeCloseTempLobsPiggyback(buf) {
@@ -638,6 +661,9 @@ class Message {
     if (this.connection._clientIdentifierModified) {
       flags |= constants.TNS_END_TO_END_CLIENT_IDENTIFIER;
     }
+    if (this.connection._ecidModified) {
+      flags |= constants.TNS_END_TO_END_ECID;
+    }
     if (this.connection._clientInfoModified) {
       flags |= constants.TNS_END_TO_END_CLIENT_INFO;
     }
@@ -647,20 +673,25 @@ class Message {
     if (this.connection._dbOpModified) {
       flags |= constants.TNS_END_TO_END_DBOP;
     }
+    if (this.connection._otelModified) {
+      flags |= constants.TNS_END_TO_END_OTEL_RESET;
+      flags |= this._getOtelFlags();
+    }
 
     // write initial packet data
     this.writePiggybackHeader(buf, constants.TNS_FUNC_SET_END_TO_END_ATTR);
     buf.writeUInt8(0);                  // pointer (cidnam)
     buf.writeUInt8(0);                  // pointer (cidser)
-    buf.writeUB4(flags);
+
+    // Coerce to unsigned since JS bitwise operators produce signed 32-bit
+    // values, and OTEL trace uses the high bit.
+    buf.writeUB4(flags >>> 0);
 
     const clientIdentifierBytes = this.writeEndEndTraceValue(buf, this.connection._clientIdentifier, this.connection._clientIdentifierModified);
     const moduleBytes = this.writeEndEndTraceValue(buf, this.connection._module, this.connection._moduleModified);
     const actionBytes = this.writeEndEndTraceValue(buf, this.connection._action, this.connection._actionModified);
-
+    const ecidBytes = this.writeEndEndTraceValue(buf, this.connection._ecid, this.connection._ecidModified);
     // write unsupported bits
-    buf.writeUInt8(0);                  // pointer (cideci)
-    buf.writeUB4(0);                    // length (cideci)
     buf.writeUInt8(0);                  // cidcct
     buf.writeUB4(0);                    // cidecs
 
@@ -682,6 +713,9 @@ class Message {
     if (this.connection._actionModified && this.connection._action) {
       buf.writeBytesWithLength(actionBytes);
     }
+    if (this.connection._ecidModified && this.connection._ecid) {
+      buf.writeBytesWithLength(ecidBytes);
+    }
     if (this.connection._clientInfoModified && this.connection._clientInfo) {
       buf.writeBytesWithLength(clientInfoBytes);
     }
@@ -689,17 +723,24 @@ class Message {
       buf.writeBytesWithLength(dbOpBytes);
     }
 
-    // reset flags and values
+    // Safely retain the values and clear only their modified flags.
+    // This avoids resending stale values, while preserving ACTION
+    // because it is sent with MODULE updates.
     this.connection._actionModified = false;
-    this.connection._action = "";
+    this.connection._ecidModified = false;
     this.connection._clientIdentifierModified = false;
-    this.connection._clientIdentifier = "";
     this.connection._clientInfoModified = false;
-    this.connection._clientInfo = "";
     this.connection._dbOpModified = false;
-    this.connection._dbOp = "";
     this.connection._moduleModified = false;
-    this.connection._module = "";
+    this.connection._otelModified = false;
+  }
+
+  _getOtelFlags() {
+    let flags = 0;
+    if (this.connection.databaseOpenTelemetryTracing) {
+      flags |= constants.TNS_END_TO_END_OTEL_TRACE;
+    }
+    return flags >>> 0;
   }
 
   writeEndEndTraceValue(buf, value, modified) {
@@ -762,6 +803,23 @@ class Message {
     }
   }
 
+  _writeAltSessPiggyback(buf) {
+    const pendingTxnPriority = this.connection._pendingTxnPriority ?? "";
+    const flags = (pendingTxnPriority === "") ?
+      constants.TNS_KVAL_FLAG_TXN_PRIORITY_DEFAULT : 0;
+
+    this.writePiggybackHeader(buf, constants.TNS_FUNC_ALTSESS);
+
+    // OALTSESS uses DTYALTSESS, which wraps a KVAL array carrying the
+    // alter-session key/value pairs to apply on the server.
+    buf.writeUB4(0);                            // kpdAltSessFlg
+    buf.writeUInt8(1);                          // ptr to KVAL array
+    buf.writeUB4(1);                            // number of key/value pairs
+    buf.writeKeyValue("TXN_PRIORITY", pendingTxnPriority, flags);
+    this.connection._pendingTxnPriority = undefined;
+    this.connection._txnPriorityModified = false;
+  }
+
   // Called when an error is encountered during decode of RPC
   saveDeferredErr() {
     if (!this.deferredErr) {

package/lib/thin/protocol/messages/dataType.js

@@ -26,9 +26,23 @@
 
 'use strict';
 
+const { Buffer } = require('buffer');
 const constants = require("../constants.js");
+const dataHandlerConstants = require("../../../impl/datahandlers/constants.js");
 const Message = require("./base.js");
 
+// TTIDTY carries the client's time zone as an 11-byte INTERVAL DAY TO SECOND
+// value. A zero day field is followed by the biased hour and minute offset;
+// the remaining five bytes use the TTC time-zone trailer representation.
+const TTIDTY_TIME_ZONE_TRAILER = Buffer.from([0x80, 0, 0, 0, 0]);
+
+// In the server's 11-byte DBTIMEZONE interval, byte 4 holds either the biased
+// hour offset or a region-ID marker. Oracle clients identify a region when
+// this byte is greater than 120 (181 - the hour bias of 60 - 1). The region ID
+// itself is encoded in bytes 2 and 3. node-oracledb currently obtains the
+// region name with DBTIMEZONE, since it has no Oracle region-ID mapping table.
+const TTIDTY_TIME_ZONE_REGION_ID_THRESHOLD = 120;
+
 /**
  * Does Datatype Negotiation
  *
@@ -40,6 +54,19 @@ class DataTypeMessage extends Message {
 
   processMessage(buf, messageType) {
     if (messageType === constants.TNS_MSG_TYPE_DATA_TYPES) {
+      if (buf.caps.runtimeCaps[constants.TNS_RCAP_TZ] ===
+          constants.TNS_RCAP_TZ_EX) {
+        // TZ_EX adds the database time zone before the negotiated datatype
+        // list. It uses the same 11-byte INTERVAL DAY TO SECOND layout as the
+        // client value written below.
+        const dbTimeZone = buf.readBytes(11);
+        if (dbTimeZone[4] <= TTIDTY_TIME_ZONE_REGION_ID_THRESHOLD) {
+          // Fixed offsets encode hours and minutes with a bias of 60.
+          buf.caps.dbTzOffset = (dbTimeZone[4] -
+            dataHandlerConstants.TNS_DURATION_OFFSET) * 60 +
+            dbTimeZone[5] - dataHandlerConstants.TNS_DURATION_OFFSET;
+        }
+      }
       while (true) {
         const dataType = buf.readUInt16BE();
         if (dataType === 0)
@@ -62,6 +89,24 @@ class DataTypeMessage extends Message {
       constants.TNS_ENCODING_CONV_LENGTH);
     buf.writeBytesWithLength(buf.caps.compileCaps);
     buf.writeBytesWithLength(buf.caps.runtimeCaps);
+    if (buf.caps.runtimeCaps[constants.TNS_RCAP_TZ] ===
+        constants.TNS_RCAP_TZ_EX) {
+      // Advertise the Node process's current fixed UTC offset. The server
+      // uses this client value while performing datatype negotiation and
+      // returns its DBTIMEZONE using the corresponding interval layout.
+      //
+      // Date#getTimezoneOffset() uses the opposite sign convention
+      // (UTC - local time), so negate it before encoding the offset for TTIDTY.
+      const timeZoneOffset = -new Date().getTimezoneOffset();
+      const timeZone = Buffer.alloc(11);
+      timeZone.writeUInt32BE(dataHandlerConstants.TNS_DURATION_MID, 0);
+      timeZone[4] = Math.trunc(timeZoneOffset / 60) +
+        dataHandlerConstants.TNS_DURATION_OFFSET;
+      timeZone[5] = timeZoneOffset % 60 +
+        dataHandlerConstants.TNS_DURATION_OFFSET;
+      TTIDTY_TIME_ZONE_TRAILER.copy(timeZone, 6);
+      buf.writeBytes(timeZone);
+    }
     for (const val of dataTypes) {
       buf.writeUInt16BE(val[0]);
       buf.writeUInt16BE(val[1]);
@@ -399,6 +444,7 @@ const dataTypes = [
   [constants.TNS_DATA_TYPE_PLEND, constants.TNS_DATA_TYPE_PLEND, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_PLBGN, constants.TNS_DATA_TYPE_PLBGN, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_PLOP, constants.TNS_DATA_TYPE_PLOP, constants.TNS_TYPE_REP_UNIVERSAL],
+  [constants.TNS_DATA_TYPE_ALTSESS, constants.TNS_DATA_TYPE_ALTSESS, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_KVE, constants.TNS_DATA_TYPE_KVE, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_EUSC, constants.TNS_DATA_TYPE_EUSC, constants.TNS_TYPE_REP_UNIVERSAL]
 ];

package/lib/thin/protocol/messages/directPathLoadStream.js

@@ -93,13 +93,14 @@ class DirectPathPiece {
 
 class PieceBuffer extends BaseBuffer {
   constructor(connection) {
-    super(Buffer.alloc(constants.TNS_DPLS_MAX_PIECE_SIZE));
+    const caps = connection._protocol.caps;
+    super(Buffer.alloc(constants.TNS_DPLS_MAX_PIECE_SIZE), caps);
     this.connection = connection;
     this.currentPiece = null;
     this.totalPieceLength = 0;
     this.pieces = [];
     this._encodingTempBuf = new BaseBuffer(
-      Buffer.alloc(constants.TNS_DPLS_MAX_BUFFER_SIZE_FACTOR)
+      Buffer.alloc(constants.TNS_DPLS_MAX_BUFFER_SIZE_FACTOR), caps
     );
   }
 

package/lib/thin/protocol/messages/execute.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -65,6 +65,8 @@ class ExecuteMessage extends MessageWithData {
     let execFlags = 0;
     let numParams = 0;
     let numIters = 1;
+    let registrationIdMsb = 0;
+    let registrationIdLsb = 0;
     // Configuring the options field thats send to the server
     const stmt = this.statement;
     const params = stmt.bindInfoList;
@@ -123,6 +125,10 @@ class ExecuteMessage extends MessageWithData {
       this._handleSuspendSessionless();
     }
 
+    registrationIdMsb = Number((this.statement._registrationId >> 32n) &
+      0xffffffffn);
+    registrationIdLsb = Number(this.statement._registrationId & 0xffffffffn);
+
     this.writeFunctionHeader(buf);
     buf.writeUB4(options);                           // execute options
     buf.writeUB4(stmt.cursorId);                     // cursor id
@@ -159,14 +165,14 @@ class ExecuteMessage extends MessageWithData {
       buf.writeUInt8(0);
       buf.writeUB4(0);
     }
-    buf.writeUB4(0);                                 // registration id
+    buf.writeUB4(registrationIdLsb);
     buf.writeUInt8(0);                               // pointer (al8objlist)
     buf.writeUInt8(1);                               // pointer (al8objlen)
     buf.writeUInt8(0);                               // pointer (al8blv)
     buf.writeUB4(0);                                 // al8blv
     buf.writeUInt8(0);                               // pointer (al8dnam)
     buf.writeUB4(0);                                 // al8dnaml
-    buf.writeUB4(0);                                 // al8regid_msb
+    buf.writeUB4(registrationIdMsb);
     if (this.arrayDmlRowCounts) {
       buf.writeUInt8(1);                             // pointer (al8pidmlrc)
       buf.writeUB4(this.numExecs);                   // al8pidmlrcbl
@@ -323,7 +329,7 @@ class ExecuteMessage extends MessageWithData {
       const stmt = this.statement;
       if (stmt.cursorId !== 0 && !stmt.requiresFullExecute && !this.parseOnly
         && !stmt.requiresDefine && !stmt.noPrefetch && !stmt.isDdl
-        && !this.batchErrors) {
+        && !this.batchErrors && stmt._registrationId === 0n) {
         if (stmt.isQuery && this.options.prefetchRows > 0) {
           this.functionCode = constants.TNS_FUNC_REEXECUTE_AND_FETCH;
         } else {

package/lib/thin/protocol/messages/index.js

@@ -41,6 +41,8 @@ const PingMessage = require('./ping.js');
 const ProtocolMessage = require('./protocol.js');
 const RollbackMessage = require('./rollback.js');
 const SessionReleaseMessage = require('./sessionRelease.js');
+const SubscrMessage = require('./subscribe.js');
+const NotifyMessage = require('./notification.js');
 const FastAuthMessage = require('./fastAuth.js');
 const TransactionChangeStateMessage = require('./transactionChangeState.js');
 const TransactionSwitchMessage = require('./transactionSwitch.js');
@@ -62,6 +64,8 @@ module.exports = {
   ProtocolMessage,
   RollbackMessage,
   SessionReleaseMessage,
+  SubscrMessage,
+  NotifyMessage,
   TransactionChangeStateMessage,
   TransactionSwitchMessage
 };