oracledb 6.8.0 → 6.9.0

package/lib/thin/pool.js

@@ -35,7 +35,6 @@ const util = require('../util.js');
 const thinUtil = require('./util.js');
 const {getConnectionInfo} = require('./sqlnet/networkSession.js');
 const crypto = require('crypto');
-const EventEmitter = require('events');
 const Timers = require('timers');
 
 class ThinPoolImpl extends PoolImpl {
@@ -57,6 +56,7 @@ class ThinPoolImpl extends PoolImpl {
     this._poolTimeout = params.poolTimeout;
     this._poolPingInterval = params.poolPingInterval;
     this._poolPingTimeout = params.poolPingTimeout;
+    this._maxLifetimeSession = params.maxLifetimeSession || 0;
     this._stmtCacheSize = params.stmtCacheSize;
 
     // The user Config filterd from common layer is cached except
@@ -77,6 +77,9 @@ class ThinPoolImpl extends PoolImpl {
     this._schedulerJob = null;
     this._poolCloseWaiter = null;
     this._pendingRequests = [];
+    this._connsToDrop = [];
+    this._bgCleaner = null;
+    this._poolCloseCleaner = null;
 
     // password obfuscation
     if (this._password !== undefined) {
@@ -117,11 +120,6 @@ class ThinPoolImpl extends PoolImpl {
     this._accessTokenConfig = params.accessTokenConfig;
     this._isDRCPEnabled = false;
     this._implicitPool = null;
-    this.eventEmitter = new EventEmitter();
-    // listener to remove dead or idle connections
-    this.eventEmitter.on('_removePoolConnection', async (connImpl) => {
-      await this._destroy(connImpl);
-    });
   }
 
   //---------------------------------------------------------------------------
@@ -142,6 +140,9 @@ class ThinPoolImpl extends PoolImpl {
     // create a background task. It will create minimum connections in the pool
     // and expand the pool as required.
     this.bgThreadFunc();
+    // create a background task to remove connections that are to in
+    // _connsToDrop, reason for dropping may be poolTimeout or poolMax decrease
+    this._bgConnCleaner();
   }
 
   //---------------------------------------------------------------------------
@@ -254,9 +255,13 @@ class ThinPoolImpl extends PoolImpl {
   // destroy connection when pool close operation is called
   //---------------------------------------------------------------------------
   async _destroy(connection) {
-    if (connection.nscon.ntAdapter.connected) {
-      connection._dropSess = true;
-      await connection.close();
+    try {
+      if (connection.nscon.ntAdapter.connected) {
+        connection._dropSess = true;
+        await connection.close();
+      }
+    } catch (err) {
+      return;
     }
   }
 
@@ -290,7 +295,12 @@ class ThinPoolImpl extends PoolImpl {
       await this._destroy(conn);
     }
 
-    this.eventEmitter.removeAllListeners();
+    // Let the bgCleaner destroy all connsToDrop and stop
+    await new Promise((resolve) => {
+      this._poolCloseCleaner = resolve;
+      if (this._bgCleaner)
+        this._bgCleaner();
+    });
   }
 
   //---------------------------------------------------------------------------
@@ -356,6 +366,13 @@ class ThinPoolImpl extends PoolImpl {
     return this._poolTimeout;
   }
 
+  //---------------------------------------------------------------------------
+  // returns the pool max lifetime for a session  (seconds)
+  //---------------------------------------------------------------------------
+  getMaxLifetimeSession() {
+    return this._maxLifetimeSession;
+  }
+
   //---------------------------------------------------------------------------
   // returns whether the SODA metadata cache is enabled or not
   //---------------------------------------------------------------------------
@@ -399,10 +416,13 @@ class ThinPoolImpl extends PoolImpl {
         break;
       }
 
-      this.eventEmitter.emit('_removePoolConnection', conn);
+      this._connsToDrop.push(conn);
       this._freeConnectionList.shift();
     }
 
+    // call cleaner for destroying connections added to _connsToDrop
+    if (this._bgCleaner)
+      this._bgCleaner();
     this._schedulerJob = null;
     this._setScheduler();
   }
@@ -438,15 +458,6 @@ class ThinPoolImpl extends PoolImpl {
 
     // continue until a close request is received
     while (!this._poolCloseWaiter) {
-      // eliminate connections that exceed the poolMax (this should only happen
-      // after a reconfiguration has taken place where the maximum number of
-      // connections is reduced)
-      let numToDestroy = this._poolMax - this.getConnectionsOpen();
-      while (numToDestroy > 0 && this._freeConnectionList.length > 0) {
-        const connToBeRemoved = this._freeConnectionList.shift();
-        this.eventEmitter.emit('_removePoolConnection', connToBeRemoved);
-        numToDestroy--;
-      }
 
       const numToCreate = this._getNumConnsToCreate();
       // connection creation is going on serially and not concurrently
@@ -459,6 +470,7 @@ class ThinPoolImpl extends PoolImpl {
           await conn.connect(config);
           conn._newSession = true;
           conn._dropSess = false;
+          conn._creationTime = Date.now();
           conn._lastTimeUsed = Date.now();
           this._freeConnectionList.push(conn);
         } catch (err) {
@@ -491,7 +503,8 @@ class ThinPoolImpl extends PoolImpl {
       }
 
       // if no pending requests, wait for pending requests to appear!
-      if (this._pendingRequests.length == 0 || this._bgErr) {
+      if ((this._pendingRequests.length == 0 || this._bgErr) &&
+        this.getConnectionsOpen() >= this._poolMin) {
         await new Promise((resolve) => {
           this.bgWaiter = resolve;
         });
@@ -503,6 +516,27 @@ class ThinPoolImpl extends PoolImpl {
     this._poolCloseWaiter();
   }
 
+  //---------------------------------------------------------------------------
+  // _bgConnCleaner()
+  // Method which stays in the stack and performs cleanup whenever a connection
+  // gets added for cleanup to _connsToDrop
+  // acquire a connection from connection pool
+  //---------------------------------------------------------------------------
+  async _bgConnCleaner() {
+    // run until a pool.close() is issued
+    while (!this._poolCloseCleaner) {
+
+      // wait for _bgCleaner to be called for cleanup
+      if (this._connsToDrop.length == 0)
+        await new Promise(resolve => this._bgCleaner = resolve);
+
+      // destroy connections in _connsToDrop
+      while (this._connsToDrop.length)
+        await this._destroy(this._connsToDrop.pop());
+    }
+    this._poolCloseCleaner();
+  }
+
   //---------------------------------------------------------------------------
   // acquire()
   //
@@ -514,9 +548,10 @@ class ThinPoolImpl extends PoolImpl {
     while (this._freeConnectionList.length > 0) {
       const conn = this._freeConnectionList.pop();
 
-      // if connection is unhealthy, drop it from the pool
-      if (!conn.isHealthy()) {
-        this.eventEmitter.emit('_removePoolConnection', conn);
+      // drop from the pool if the connection is unhealthy, or if the
+      // connection's lifetime exceeds maxLifetimeSession
+      if (!this._shouldRetainInPool(conn)) {
+        this._invokeBgCleaner(conn);
         continue;
       }
 
@@ -595,11 +630,11 @@ class ThinPoolImpl extends PoolImpl {
     if (conn.nscon.connected) {
       conn._lastTimeUsed = Date.now();
       conn._newSession = false;
-      if ((this._freeConnectionList.length + this._usedConnectionList.size)
-        < this._poolMax) {
+      if ((this.getConnectionsOpen() < this._poolMax) &&
+          this._shouldRetainInPool(conn)) {
         this._freeConnectionList.push(conn);
       } else {
-        this.eventEmitter.emit('_removePoolConnection', conn);
+        this._invokeBgCleaner(conn);
       }
     }
 
@@ -652,9 +687,51 @@ class ThinPoolImpl extends PoolImpl {
       this._poolMin = params.poolMin;
     }
 
-    if (this.bgWaiter) {
+    if (params.maxLifetimeSession !== undefined) {
+      this._maxLifetimeSession = params.maxLifetimeSession;
+    }
+
+    let numToDestroy = this.getConnectionsOpen() - this._poolMax;
+    while (this._freeConnectionList.length && numToDestroy > 0) {
+      const conn = this._freeConnectionList.pop();
+      this._connsToDrop.push(conn);
+      numToDestroy--;
+    }
+
+    // call cleanup for destroying connections in _connsToDrop
+    if (this._bgCleaner)
+      this._bgCleaner();
+  }
+
+  //---------------------------------------------------------------------------
+  // _invokeBgCleaner()
+  //
+  // drop conn and invoke the bgCleaner while also ensuring min connections
+  //---------------------------------------------------------------------------
+  _invokeBgCleaner(conn) {
+    this._connsToDrop.push(conn);
+    if (this._bgCleaner)
+      this._bgCleaner();
+
+    // ensure min connections are maintained in pool
+    if ((this.getConnectionsOpen() < this._poolMin) && this.bgWaiter)
       this.bgWaiter();
+  }
+
+  //---------------------------------------------------------------------------
+  // _shouldRetainInPool()
+  //
+  // returns true if the connection should be retained in pool
+  //---------------------------------------------------------------------------
+  _shouldRetainInPool(conn) {
+    if (!conn.isHealthy())
+      return false;
+    // check if maxLifetimeSession of conn has expired
+    if (this._maxLifetimeSession !== 0) {
+      if ((Date.now() - conn._creationTime) > (this._maxLifetimeSession * 1000))
+        return false;
     }
+    return true;
   }
 }
 

package/lib/thin/protocol/capabilities.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -104,11 +104,14 @@ class Capabilities {
       constants.TNS_CCAP_LOB2_QUASI | constants.TNS_CCAP_LOB2_2GB_PREFETCH;
     this.compileCaps[constants.TNS_CCAP_TTC3] =
       constants.TNS_CCAP_IMPLICIT_RESULTS | constants.TNS_CCAP_BIG_CHUNK_CLR |
-      constants.TNS_CCAP_KEEP_OUT_ORDER;
+      constants.TNS_CCAP_KEEP_OUT_ORDER | constants.TNS_CCAP_LTXID;
+    this.compileCaps[constants.TNS_CCAP_OCI3] = constants.TNS_CCAP_OCI3_OCSSYNC;
     this.compileCaps[constants.TNS_CCAP_TTC2] = constants.TNS_CCAP_ZLNP;
     this.compileCaps[constants.TNS_CCAP_OCI2] = constants.TNS_CCAP_DRCP;
     this.compileCaps[constants.TNS_CCAP_CLIENT_FN] =
       constants.TNS_CCAP_CLIENT_FN_MAX;
+    this.compileCaps[constants.TNS_CCAP_SESS_SIGNATURE_VERSION] =
+      constants.TNS_CCAP_FIELD_VERSION_12_2;
     this.compileCaps[constants.TNS_CCAP_TTC4] =
       constants.TNS_CCAP_INBAND_NOTIFICATION;
     if (nscon.endOfRequestSupport) {
@@ -117,7 +120,8 @@ class Capabilities {
     this.compileCaps[constants.TNS_CCAP_CTB_FEATURE_BACKPORT] =
       constants.TNS_CCAP_CTB_IMPLICIT_POOL;
     this.compileCaps[constants.TNS_CCAP_TTC5] =
-      constants.TNS_CCAP_VECTOR_SUPPORT;
+      constants.TNS_CCAP_VECTOR_SUPPORT |
+      constants.TNS_CCAP_TTC5_SESSIONLESS_TXNS;
     this.compileCaps[constants.TNS_CCAP_VECTOR_FEATURES] =
       constants.TNS_CCAP_VECTOR_FEATURE_BINARY | constants.TNS_CCAP_VECTOR_FEATURE_SPARSE;
   }

package/lib/thin/protocol/constants.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -405,6 +405,7 @@ module.exports = {
   TNS_DATA_TYPE_UD21: 639,
   TNS_DATA_TYPE_TNP: 640,
   TNS_DATA_TYPE_OAC: 646,
+  TNS_DATA_TYPE_SESSSIGN: 647,
   TNS_DATA_TYPE_OER: 652,
   TNS_DATA_TYPE_UDS: 663,
 
@@ -439,6 +440,7 @@ module.exports = {
   // parameter keyword numbers,
   TNS_KEYWORD_NUM_CURRENT_SCHEMA: 168,
   TNS_KEYWORD_NUM_EDITION: 172,
+  TNS_KEYWORD_NUM_TRANSACTION_ID: 201,
 
   // bind flags
   TNS_BIND_USE_INDICATORS: 0x0001,
@@ -476,6 +478,7 @@ module.exports = {
   TNS_SERVER_PIGGYBACK_LTXID: 7,
   TNS_SERVER_PIGGYBACK_AC_REPLAY_CONTEXT: 8,
   TNS_SERVER_PIGGYBACK_EXT_SYNC: 9,
+  TNS_SERVER_PIGGYBACK_SESS_SIGNATURE: 10,
 
   // session return constants
   TNS_SESSGET_SESSION_CHANGED: 4,
@@ -582,7 +585,9 @@ module.exports = {
   TNS_CCAP_UB2_DTY: 27,
   TNS_CCAP_OCI2: 31,
   TNS_CCAP_CLIENT_FN: 34,
+  TNS_CCAP_OCI3: 35,
   TNS_CCAP_TTC3: 37,
+  TNS_CCAP_SESS_SIGNATURE_VERSION: 39,
   TNS_CCAP_TTC4: 40,
   TNS_CCAP_LOB2: 42,
   TNS_CCAP_TTC5: 44,
@@ -625,6 +630,7 @@ module.exports = {
   TNS_CCAP_RPC_VERSION_MAX: 7,
   TNS_CCAP_RPC_SIG_VALUE: 3,
   TNS_CCAP_DBF_VERSION_MAX: 1,
+  TNS_CCAP_LTXID: 0x08,
   TNS_CCAP_IMPLICIT_RESULTS: 0x10,
   TNS_CCAP_BIG_CHUNK_CLR: 0x20,
   TNS_CCAP_KEEP_OUT_ORDER: 0x80,
@@ -645,6 +651,8 @@ module.exports = {
   TNS_CCAP_VECTOR_SUPPORT: 0x08,
   TNS_CCAP_VECTOR_FEATURE_BINARY: 0x01,
   TNS_CCAP_VECTOR_FEATURE_SPARSE: 0x02,
+  TNS_CCAP_TTC5_SESSIONLESS_TXNS: 0x20,
+  TNS_CCAP_OCI3_OCSSYNC: 0x20,
 
   // runtime capability indices
   TNS_RCAP_COMPAT: 0,
@@ -674,6 +682,7 @@ module.exports = {
   // transaction switching op codes
   TNS_TPC_TXN_START: 0x01,
   TNS_TPC_TXN_DETACH: 0x02,
+  TNS_TPC_TXN_POST_DETACH: 0x04,
 
   // transaction change state op codes
   TNS_TPC_TXN_COMMIT: 0x01,
@@ -689,6 +698,25 @@ module.exports = {
   TNS_TPC_TXN_STATE_READ_ONLY: 4,
   TNS_TPC_TXN_STATE_FORGOTTEN: 5,
 
+  // sessionless transaction flag
+  TNS_TPC_TRANS_SESSIONLESS: 0x00000010,
+
+  // sessionless transaction format
+  TNS_TPC_TRANS_SESSIONLESS_FORMAT: 0x4e5c3e,
+
+  // sessionless sync version
+  TNS_TPC_TRANS_TRANSACTION_ID_SYNC_VERSION_1: 0x01,
+
+  // sessionless server states
+  TNS_TPC_TRANS_TRANSACTION_ID_SYNC_SET: 0x40,
+  TNS_TPC_TRANS_TRANSACTION_ID_SYNC_UNSET: 0x80,
+
+  // sessionless state reason
+  TNS_TPC_TRANS_TRANSACTION_ID_SYNC_SERVER: 0x01,
+  TNS_TPC_TRANS_TRANSACTION_ID_SYNC_CLIENT: 0x02,
+  TNS_TPC_TRANS_TRANSACTION_ID_SYNC_TXEND_XA: 0x03,
+
+
   // other constants
   TNS_ESCAPE_CHAR: 253,
   TNS_LONG_LENGTH_INDICATOR: dataHandlerConstants.TNS_LONG_LENGTH_INDICATOR,

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

@@ -114,6 +114,7 @@ class AuthMessage extends Message {
     } else if (process.env.ORA_EDITION) {
       this.edition = process.env.ORA_EDITION;
     }
+    this.appContext = config.appContext;
     this.setAuthMode(config);
   }
 
@@ -247,6 +248,9 @@ class AuthMessage extends Message {
         if (this.edition) {
           numPairs += 1;
         }
+        if (this.appContext) {
+          numPairs += this.appContext.length * 3;
+        }
         if (this.schemaUser.length !== 0) {
           numPairs += 1;
         }
@@ -319,6 +323,15 @@ class AuthMessage extends Message {
       if (this.edition) {
         buf.writeKeyValue("AUTH_ORA_EDITION", this.edition);
       }
+      if (this.appContext) {
+        // NOTE: these keys require a trailing null character as the server
+        // expects it!
+        for (const entry of this.appContext) {
+          buf.writeKeyValue("AUTH_APPCTX_NSPACE\0", entry[0]);
+          buf.writeKeyValue("AUTH_APPCTX_ATTR\0", entry[1]);
+          buf.writeKeyValue("AUTH_APPCTX_VALUE\0", entry[2]);
+        }
+      }
 
     }
   }

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -30,6 +30,34 @@ const { Buffer } = require('buffer');
 const constants = require("../constants.js");
 const errors = require("../../../errors.js");
 
+// List of recoverable errors
+const RECOVERABLE_ERRORS = new Set([
+  28,     // session has been terminated
+  31,     // session marked for kill
+  376,    // file %s cannot be read at this time
+  603,    // ORACLE server session terminated
+  1012,   // not logged on
+  1033,   // ORACLE initialization or shutdown in progress
+  1034,   // the Oracle instance is not available for use
+  1089,   // immediate shutdown or close in progress
+  1090,   // shutdown in progress
+  1092,   // ORACLE instance terminated
+  1115,   // IO error reading block from file %s (block # %s)
+  2396,   // exceeded maximum idle time
+  3113,   // end-of-file on communication channel
+  3114,   // not connected to ORACLE
+  3135,   // connection lost contact
+  12153,  // TNS:not connected
+  12514,  // Service %s is not registered with the listener
+  12537,  // TNS:connection closed
+  12547,  // TNS:lost contact
+  12570,  // TNS:packet reader failure
+  12571,  // TNS:packet writer failure
+  12583,  // TNS:no reader
+  12757,  // instance does not currently know of requested service
+  16456   // missing or invalid value
+]);
+
 /**
  *
  * Base class for all the RPC messages to support encode/decode functions
@@ -52,6 +80,7 @@ class Message {
   async postProcess() { }
 
   writeFunctionHeader(buf) {
+    this.writePiggybacks(buf);
     buf.writeUInt8(this.messageType);
     buf.writeUInt8(this.functionCode);
     buf.writeSeqNum();
@@ -160,6 +189,8 @@ class Message {
        */
       this.errorInfo.message = this.errorInfo.message.trim();
     }
+    this.errorInfo.isRecoverable = RECOVERABLE_ERRORS.has(this.errorInfo.num);
+
     this.endOfResponse = !this.connection.nscon.endOfRequestSupport;
   }
 
@@ -220,7 +251,7 @@ class Message {
     if (opcode === constants.TNS_SERVER_PIGGYBACK_LTXID) {
       const num_bytes = buf.readUB4();
       if (num_bytes > 0) {
-        buf.skipBytesChunked();
+        this.connection._ltxid = Buffer.from(buf.readBytesWithLength());
       }
     } else if ((opcode === constants.TNS_SERVER_PIGGYBACK_QUERY_CACHE_INVALIDATION)
      || (opcode === constants.TNS_SERVER_PIGGYBACK_TRACE_EVENT)) {
@@ -235,15 +266,22 @@ class Message {
       const num_elements = buf.readUB4();
       buf.skipBytes(1);                         // skip length
       for (let i = 0; i < num_elements; i++) {
-        let temp16 = buf.readUB2();
-        if (temp16 > 0) {                       // skip key
-          buf.skipBytesChunked();
+        let numBytes = buf.readUB2();
+        let keyTextValue, value;
+        if (numBytes > 0) {                       // read key
+          keyTextValue = buf.readStr(constants.CSFRM_IMPLICIT);
         }
-        temp16 = buf.readUB2();
-        if (temp16 > 0) {                       // skip value
-          buf.skipBytesChunked();
+        numBytes = buf.readUB2();
+        if (numBytes > 0)                         // read value
+          value = buf.readBytesWithLength();
+        const keywordNum = buf.readUB2();         // read keyword number
+        if (keywordNum == constants.TNS_KEYWORD_NUM_TRANSACTION_ID) {
+          this._updateSessionlessTxnState(value);
+        } else if (keywordNum === constants.TNS_KEYWORD_NUM_CURRENT_SCHEMA) {
+          this.connection.currentSchema = keyTextValue;
+        } else if (keywordNum === constants.TNS_KEYWORD_NUM_EDITION) {
+          this.connection._edition = keyTextValue;
         }
-        buf.skipUB2();                          // skip flags
       }
       buf.skipUB4();                            // skip overall flags
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_EXT_SYNC) {
@@ -286,12 +324,22 @@ class Message {
       this.connection._drcpEstablishSession = false;
       buf.skipUB4();                            // session id
       buf.skipUB2();                            // serial number
+    } else if (opcode === constants.TNS_SERVER_PIGGYBACK_SESS_SIGNATURE) {
+      buf.skipUB2();                              // number of dtys
+      buf.skipUB1();                              // length of dty
+      buf.skipUB8();                              // signature flags
+      buf.skipUB8();                              // client signature
+      buf.skipUB8();                              // server signature
     } else {
       errors.throwErr(errors.ERR_UNKOWN_SERVER_SIDE_PIGGYBACK, opcode);
     }
   }
 
   writePiggybacks(buf) {
+    // Don't write piggybacks if not authenticated yet
+    if (this.connection._protocol.connInProgress)
+      return;
+
     if (this.connection._currentSchemaModified) {
       this._writeCurrentSchemaPiggyback(buf);
     }
@@ -313,6 +361,11 @@ class Message {
     if (this.connection._tempLobsTotalSize > 0) {
       this.writeCloseTempLobsPiggyback(buf);
     }
+    if (this.connection._sessionlessData?.pending) {
+      this.connection._sessionlessData.pending = false;
+      this.connection._sessionlessData.piggyback.encode(buf);
+      this.connection._sessionlessData.piggyback = null;
+    }
   }
 
   writePiggybackHeader(buf, functionCode) {
@@ -474,6 +527,42 @@ class Message {
       this.deferredErr = errors.getErr(...arguments);
     }
   }
+
+  _updateSessionlessTxnState(buf) {
+    const length = buf.length;
+    const sessionlessState = buf.readUInt8(length - 2);
+    const syncVersion = buf.readUInt8(length - 1);
+    let startedOnServer;
+
+    if (syncVersion == constants.TNS_TPC_TRANS_TRANSACTION_ID_SYNC_VERSION_1) {
+      // transactionId got unset for this session (txn ended or suspended)
+      if (sessionlessState &
+        constants.TNS_TPC_TRANS_TRANSACTION_ID_SYNC_UNSET) {
+        this.connection._sessionlessData = null;
+        this.connection._protocol.txnInProgress = false;
+      // transactionId got set for this session
+      } else if (sessionlessState &
+        constants.TNS_TPC_TRANS_TRANSACTION_ID_SYNC_SET) {
+
+        // transaction initialized by PL/SQL procedure
+        if (sessionlessState &
+            constants.TNS_TPC_TRANS_TRANSACTION_ID_SYNC_SERVER)
+          startedOnServer = true;
+        // transaction initialized by calling client API(RPC call)
+        else if (sessionlessState &
+          constants.TNS_TPC_TRANS_TRANSACTION_ID_SYNC_CLIENT)
+          startedOnServer = false;
+
+        this.connection._sessionlessData = {
+          startedOnServer: startedOnServer,
+        };
+        this.connection._protocol.txnInProgress = true;
+      }
+    } else
+      errors.throwErr(errors.ERR_INTERNAL, 'Unexpected TransactionId sync ' +
+        'version in session sync piggyback.');
+  }
+
 }
 
 module.exports = Message;

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -394,6 +394,7 @@ const dataTypes = [
   [constants.TNS_DATA_TYPE_TNP, constants.TNS_DATA_TYPE_TNP, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_OER, constants.TNS_DATA_TYPE_OER, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_OAC, constants.TNS_DATA_TYPE_OAC, constants.TNS_TYPE_REP_UNIVERSAL],
+  [constants.TNS_DATA_TYPE_SESSSIGN, constants.TNS_DATA_TYPE_SESSSIGN, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_VECTOR, constants.TNS_DATA_TYPE_VECTOR, constants.TNS_TYPE_REP_UNIVERSAL]
 ];
 

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -29,6 +29,7 @@
 const MessageWithData = require("./withData.js");
 const constants = require("../constants.js");
 const errors = require("../../../errors.js");
+const TransactionSwitchMessage = require("./transactionSwitch.js");
 
 /**
  *
@@ -110,12 +111,18 @@ class ExecuteMessage extends MessageWithData {
       options |= constants.TNS_EXEC_OPTION_BATCH_ERRORS;
     }
     if (this.arrayDmlRowCounts) {
-      dmlOptions = constants.TNS_EXEC_OPTION_DML_ROWCOUNTS;
+      dmlOptions |= constants.TNS_EXEC_OPTION_DML_ROWCOUNTS;
     }
     if (this.options.autoCommit) {
       options |= constants.TNS_EXEC_OPTION_COMMIT;
     }
-    this.writePiggybacks(buf);
+
+    // In case SuspendOnSuccess is set for execute and a sessionless transaction
+    // is active we add a piggyback for post-call suspend
+    if (this.options.suspendOnSuccess) {
+      this._handleSuspendSessionless();
+    }
+
     this.writeFunctionHeader(buf);
     buf.writeUB4(options);                           // execute options
     buf.writeUB4(stmt.cursorId);                     // cursor id
@@ -258,7 +265,13 @@ class ExecuteMessage extends MessageWithData {
       }
       numIters = this.numExecs;
     }
-    this.writePiggybacks(buf);
+
+    // In case SuspendOnSuccess is set for execute and a sessionless transaction
+    // is active we add a piggyback for post-call suspend
+    if (this.options.suspendOnSuccess) {
+      this._handleSuspendSessionless();
+    }
+
     this.writeFunctionHeader(buf);
     buf.writeUB4(stmt.cursorId);
     buf.writeUB4(numIters);
@@ -267,6 +280,35 @@ class ExecuteMessage extends MessageWithData {
     return params;
   }
 
+  //-------------------------------------------------------------------------
+  // _handleSuspendSessionless()
+  //
+  // Suspend the active sessionless transaction after DML execution if
+  // suspendOnSuccess option was given to execute()
+  //-------------------------------------------------------------------------
+  _handleSuspendSessionless() {
+    const sessionlessData = this.connection._sessionlessData;
+    // If sessionless transaction was started by server-call we cannot suspend
+    // using client API(RPC) calls
+    this.connection._validateSessionlessState();
+
+    if (!sessionlessData)
+      errors.throwErr(errors.ERR_SESSIONLESS_INACTIVE);
+    // If a piggybacks already exists it is most likely a start/resume for a
+    // sessionless transaction, add a post-call detach opcode to it
+    if (sessionlessData.piggyback) {
+      sessionlessData.piggyback.operation |=
+        constants.TNS_TPC_TXN_POST_DETACH;
+    } else {
+      const message = new TransactionSwitchMessage(this.connection);
+      message.operation = constants.TNS_TPC_TXN_POST_DETACH;
+      message.flags = constants.TNS_TPC_TRANS_SESSIONLESS;
+      message.messageType = constants.TNS_MSG_TYPE_PIGGYBACK;
+      sessionlessData.piggyback = message;
+      sessionlessData.pending = true;
+    }
+  }
+
   //-------------------------------------------------------------------------
   // encode()
   //