oracledb 6.8.0 → 6.10.0

package/lib/thin/connection.js

@@ -42,6 +42,7 @@ const types = require('../types.js');
 const errors = require("../errors.js");
 const messages = require('./protocol/messages');
 const StatementCache = require('./statementCache.js');
+const { ThinQueueImpl } = require('./aq.js');
 
 const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
   heldValue.disconnect();
@@ -85,6 +86,9 @@ class ThinConnectionImpl extends ConnectionImpl {
       // immediate close of open socket on failure
       // exception won't be thrown to user
       this.nscon.disconnect(sqlNetConstants.NSFIMM);
+      // If connection is associated with a pool, we release it
+      if (this._pool)
+        await this._pool.release(this);
     }
   }
 
@@ -167,7 +171,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   //
   // Calls the RPC that executes a SQL statement and returns the results.
   //---------------------------------------------------------------------------
-  async _execute(statement, numIters, binds, options, executeManyFlag) {
+  async _execute(statement, numIters, binds, options, executeManyFlag, internalTempLobs = []) {
 
     // Throw error if executeMany is not called on a DML statement or PL/SQL
     if (executeManyFlag && statement.isQuery) {
@@ -191,7 +195,7 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     for (let i = 0; i < binds.length; i++) {
-      await this._bind(statement, binds[i], i + 1);
+      await this._bind(statement, binds[i], i + 1, internalTempLobs);
     }
     if (statement.isPlSql && (options.batchErrors || options.dmlRowCounts)) {
       errors.throwErr(errors.ERR_EXEC_MODE_ONLY_FOR_DML);
@@ -299,13 +303,20 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     // process the type code.
+    let tempPrecision, tempScale;
     switch (attrType) {
       case constants.TNS_OBJ_TDS_TYPE_NUMBER:
-        metaData.precision = buf.readInt8();
-        metaData.scale = buf.readInt8();
+        tempPrecision = buf.readInt8();
+        tempScale = buf.readInt8();
+        if (tempPrecision || tempScale) {
+          metaData.precision = tempPrecision;
+          metaData.scale = tempScale;
+        }
         return types.DB_TYPE_NUMBER;
       case constants.TNS_OBJ_TDS_TYPE_FLOAT:
-        metaData.precision = buf.readInt8();
+        tempPrecision = buf.readInt8();
+        if (tempPrecision)
+          metaData.precision = tempPrecision;
         return types.DB_TYPE_NUMBER;
       case constants.TNS_OBJ_TDS_TYPE_VARCHAR:
       case constants.TNS_OBJ_TDS_TYPE_CHAR:
@@ -433,11 +444,24 @@ class ThinConnectionImpl extends ConnectionImpl {
         case
           when data_type in
             ('CHAR', 'NCHAR', 'VARCHAR2', 'NVARCHAR2', 'RAW')
-          then data_length
+            then data_length
           else 0
         end,
-        nvl(data_precision, 0),
-        nvl(data_scale, 0)
+        case
+          when data_precision is null and data_scale is null
+            then 0
+          when data_precision is null
+            then 38
+          else data_precision
+        end,
+        case
+          when data_precision is null and data_scale is null
+              and data_type = 'NUMBER'
+            then -127
+          when data_scale is null
+            then 0
+          else data_scale
+        end
       from all_tab_cols
       where owner = :owner
         and table_name = :name
@@ -670,10 +694,36 @@ class ThinConnectionImpl extends ConnectionImpl {
         this._partialDbObjectTypes.push(attr.typeClass);
       }
     } else {
-      attr.type = types.getTypeByColumnTypeName(attrInfo.dataType);
-      attr.maxSize = attrInfo.maxSize;
-      attr.precision = attrInfo.dataPrecision;
-      attr.scale = attrInfo.dataScale;
+      if (attrInfo.dataType === 'INTEGER' || attrInfo.dataType === 'SMALLINT') {
+        attr.type = types.DB_TYPE_NUMBER;
+        attr.precision = 38;
+        attr.scale = 0;
+      } else if (attrInfo.dataType === 'REAL') {
+        attr.type = types.DB_TYPE_NUMBER;
+        attr.precision = 63;
+        attr.scale = -127;
+      } else if (attrInfo.dataType === 'DOUBLE PRECISION' || attrInfo.dataType === 'FLOAT') {
+        attr.type = types.DB_TYPE_NUMBER;
+        // the database sends type name "FLOAT" instead of type name "REAL"
+        // when looking at table metadata but not when examining database
+        // object attribute metadata so account for that here
+        if (attrInfo.dataPrecision != null || attrInfo.dataPrecision != undefined)
+          attr.precision = Number(attrInfo.dataPrecision);
+        else
+          attr.precision = 126;
+        attr.scale = -127;
+      } else {
+        attr.type = types.getTypeByColumnTypeName(attrInfo.dataType);
+        if (attrInfo.maxSize != null || attrInfo.maxSize != undefined) {
+          const tempMaxSize = Number(attrInfo.maxSize);
+          if (tempMaxSize)
+            attr.maxSize = tempMaxSize;
+        }
+        if (attr.type === types.DB_TYPE_NUMBER) {
+          attr.precision = Number(attrInfo.dataPrecision);
+          attr.scale = Number(attrInfo.dataScale);
+        }
+      }
     }
     attributes.push(attr);
   }
@@ -732,6 +782,36 @@ class ThinConnectionImpl extends ConnectionImpl {
     return (this._pool) ? true : false;
   }
 
+  _postConnect(authMessage) {
+    let releaseNum;
+    let updateNum;
+    let portReleaseNum;
+    let portUpdateNum;
+
+    this.dbDomain = authMessage.sessionData['AUTH_SC_DB_DOMAIN'];
+    this.dbName = authMessage.sessionData['AUTH_DBNAME'];
+    this.maxOpenCursors = Number(authMessage.sessionData['AUTH_MAX_OPEN_CURSORS'] || 0);
+    this.serviceName = authMessage.sessionData['AUTH_SC_SERVICE_NAME'];
+    this.instanceName = authMessage.sessionData['AUTH_INSTANCENAME'];
+    this.maxIdentifierLength = Number(authMessage.sessionData['AUTH_MAX_IDEN_LENGTH'] || 30);
+    const fullVersionNum = Number(authMessage.sessionData['AUTH_VERSION_NO']);
+    const versionNum = (fullVersionNum >> 24) & 0xFF;
+    this.warning = authMessage.warning;
+    if (this._protocol.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_18_1_EXT_1) {
+      releaseNum = (fullVersionNum >> 16) & 0xFF;
+      updateNum = (fullVersionNum >> 12) & 0x0F;
+      portReleaseNum = (fullVersionNum >> 4) & 0xFF;
+      portUpdateNum = fullVersionNum & 0x0F;
+    } else {
+      releaseNum = (fullVersionNum >> 20) & 0x0F;
+      updateNum = (fullVersionNum >> 12) & 0xFF;
+      portReleaseNum = (fullVersionNum >> 8) & 0x0F;
+      portUpdateNum = fullVersionNum & 0xFF;
+    }
+    this.serverVersionString = versionNum + '.' + releaseNum + '.' + updateNum + '.' + portReleaseNum + '.' + portUpdateNum;
+    this.serverVersion = versionNum * 100000000 + releaseNum * 1000000 + updateNum * 10000 + portReleaseNum * 100 + portUpdateNum * 1;
+  }
+
   /**
    *
    * @param {object} params  Configuration of the connection
@@ -772,6 +852,7 @@ class ThinConnectionImpl extends ConnectionImpl {
     this.remoteAddress = '';
     this.comboKey = null; // used in changePassword API
     this.tpcContext = null;
+    this._sessionlessData = null;
 
     this.nscon = new nsi();
     finalizationRegistry.register(this, this.nscon);
@@ -845,6 +926,7 @@ class ThinConnectionImpl extends ConnectionImpl {
       if (!params.externalAuth) { // non-token Authentication
         await this._protocol._processMessage(authMessage); // OAUTH
       }
+      this._postConnect(authMessage);
     } catch (err) {
       this.nscon.disconnect();
       throw err;
@@ -885,7 +967,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   // Binds the values by user to the statement object
   //---------------------------------------------------------------------------
-  async _bind(stmt, variable, pos = 0) {
+  async _bind(stmt, variable, pos = 0, internalTempLobs = []) {
     const bindInfoDict = stmt.bindInfoDict;
     const bindInfoList = stmt.bindInfoList;
 
@@ -927,6 +1009,7 @@ class ThinConnectionImpl extends ConnectionImpl {
           if (val && val.length > 0) {
             const lobImpl = new ThinLobImpl();
             await lobImpl.create(this, variable.type);
+            internalTempLobs.push(lobImpl);
             await lobImpl.write(1, val);
             variable.values[index] = lobImpl;
           } else {
@@ -1021,12 +1104,19 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   async execute(sql, numIters, binds, options, executeManyFlag) {
     const statement = this._prepare(sql, options);
+    const internalTempLobs = [];
     try {
       return await this._execute(statement, numIters, binds, options,
-        executeManyFlag);
+        executeManyFlag, internalTempLobs);
     } catch (err) {
       this._returnStatement(statement);
       throw err;
+    } finally {
+      // Add to freelist which will be sent in piggyback fashion
+      for (const lob of internalTempLobs) {
+        this._tempLobsToClose.push(lob._locator);
+        this._tempLobsTotalSize += lob._locator.length;
+      }
     }
   }
 
@@ -1233,6 +1323,55 @@ class ThinConnectionImpl extends ConnectionImpl {
       errors.throwErr(errors.ERR_UNKNOWN_TRANSACTION_STATE, message.state);
     }
   }
+  //---------------------------------------------------------------------------
+  // Ensure no sessionless transaction was started through server procedure
+  //---------------------------------------------------------------------------
+  _validateSessionlessState() {
+    if (this._sessionlessData?.startedOnServer) {
+      errors.throwErr(errors.ERR_SESSIONLESS_DIFFERING_METHODS);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // Begin/Resume a sessionless transaction with provided transactionId
+  //---------------------------------------------------------------------------
+  async startSessionlessTransaction(transactionId, timeout, flags,
+    deferRoundTrip) {
+    this._validateSessionlessState();
+    if (this._sessionlessData)
+      errors.throwErr(errors.ERR_SESSIONLESS_ALREADY_ACTIVE);
+    const message = new messages.TransactionSwitchMessage(this);
+    message.xid = {
+      globalTransactionId: transactionId,
+      branchQualifier: "",
+      formatId: constants.TNS_TPC_TRANS_SESSIONLESS_FORMAT
+    };
+    message.timeout = timeout;
+    message.operation = constants.TNS_TPC_TXN_START;
+    message.flags = constants.TNS_TPC_TRANS_SESSIONLESS | flags;
+    if (deferRoundTrip) {
+      message.messageType = constants.TNS_MSG_TYPE_PIGGYBACK;
+      this._sessionlessData = {
+        piggyback: message,
+        pending: true
+      };
+    } else {
+      await this._protocol._processMessage(message);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // Suspend the active sessionless transaction
+  //---------------------------------------------------------------------------
+  async suspendSessionlessTransaction() {
+    this._validateSessionlessState();
+    if (!this._sessionlessData)
+      errors.throwErr(errors.ERR_SESSIONLESS_INACTIVE);
+    const message = new messages.TransactionSwitchMessage(this);
+    message.operation = constants.TNS_TPC_TXN_DETACH;
+    message.flags = constants.TNS_TPC_TRANS_SESSIONLESS;
+    await this._protocol._processMessage(message);
+  }
 
 
   //---------------------------------------------------------------------------
@@ -1273,6 +1412,14 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.internalName;
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the Logical Transaction ID (ltxid) associated with the connection.
+  // Used with Oracle Database Transaction Guard feature.
+  //---------------------------------------------------------------------------
+  getLTXID() {
+    return this._ltxid;
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database domain name associated with the connection.
   //---------------------------------------------------------------------------
@@ -1343,5 +1490,15 @@ class ThinConnectionImpl extends ConnectionImpl {
   getWarning() {
     return this.warning;
   }
+
+  //---------------------------------------------------------------------------
+  // getQueue()
+  //
+  // Returns a queue for use with advanced queuing.
+  //---------------------------------------------------------------------------
+  getQueue(name, payloadTypeClass, payloadType) {
+    return new ThinQueueImpl(this, name, payloadTypeClass, payloadType);
+  }
 }
+
 module.exports = ThinConnectionImpl;

package/lib/thin/dbObject.js

@@ -55,10 +55,10 @@ class DbObjectPickleBuffer extends GrowableBuffer {
   // Reads the next byte and checks to see if the value is atomically null. If
   // not, the byte is returned to the buffer for further processing.
   //---------------------------------------------------------------------------
-  getIsAtomicNull() {
+  getIsAtomicNull(isCollection) {
     const value = this.readUInt8();
     if (value === constants.TNS_OBJ_ATOMIC_NULL ||
-        value === constants.TNS_NULL_LENGTH_INDICATOR) {
+      (isCollection && value === constants.TNS_NULL_LENGTH_INDICATOR)) {
       return true;
     }
     this.pos -= 1;
@@ -365,7 +365,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
   // Unpacks a single value and returns it.
   //---------------------------------------------------------------------------
   _unpackValue(buf, type, typeClass) {
-    let isNull, obj, value;
+    let isNull, obj, value, isCollection;
     switch (type) {
       case types.DB_TYPE_NUMBER:
         return buf.readOracleNumber();
@@ -396,14 +396,16 @@ class ThinDbObjectImpl extends DbObjectImpl {
         return buf.readBool();
       case types.DB_TYPE_OBJECT:
       case types.DB_TYPE_XMLTYPE:
-        isNull = buf.getIsAtomicNull();
+        obj = new ThinDbObjectImpl(typeClass);
+        isCollection = obj._objType.isCollection ||
+          this._objType.isCollection;
+        isNull = buf.getIsAtomicNull(isCollection);
         if (isNull)
           return null;
-        obj = new ThinDbObjectImpl(typeClass);
         if (obj._objType.isXmlType) {
           return readXML(obj._objType._connection, buf.readBytesWithLength());
         }
-        if (obj._objType.isCollection || this._objType.isCollection) {
+        if (isCollection) {
           obj.packedData = Buffer.from(buf.readBytesWithLength());
         } else {
           obj._unpackDataFromBuf(buf);

package/lib/thin/lob.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -220,10 +220,9 @@ class ThinLobImpl extends LobImpl {
     const options = {
       operation: constants.TNS_LOB_OP_CREATE_TEMP,
       sourceLobImpl: this,
-      amount: constants.TNS_DURATION_SESSION,
       destOffset: dbType._oraTypeNum,
       sourceOffset: dbType._csfrm,
-      sendAmount: true
+      destLength: constants.TNS_DURATION_SESSION
     };
     await this._sendMessage(options);
     await this._getChunkSizeAsync();

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.
 
 //-----------------------------------------------------------------------------
 //
@@ -81,6 +81,7 @@ class Capabilities {
       constants.TNS_CCAP_O9LOGON_LONG_PASSWORD;
     this.compileCaps[constants.TNS_CCAP_FIELD_VERSION] = this.ttcFieldVersion;
     this.compileCaps[constants.TNS_CCAP_SERVER_DEFINE_CONV] = 1;
+    this.compileCaps[constants.TNS_CCAP_DEQUEUE_WITH_SELECTOR] = 1;
     this.compileCaps[constants.TNS_CCAP_TTC1] =
       constants.TNS_CCAP_FAST_BVEC | constants.TNS_CCAP_END_OF_CALL_STATUS |
       constants.TNS_CCAP_IND_RCD;
@@ -104,20 +105,25 @@ 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) {
       this.compileCaps[constants.TNS_CCAP_TTC4] |= constants.TNS_CCAP_END_OF_REQUEST;
     }
     this.compileCaps[constants.TNS_CCAP_CTB_FEATURE_BACKPORT] =
-      constants.TNS_CCAP_CTB_IMPLICIT_POOL;
+      constants.TNS_CCAP_CTB_IMPLICIT_POOL |
+      constants.TNS_CCAP_CTB_OAUTH_MSG_ON_ERR;
     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;
   }