oracledb 6.2.0 → 6.4.0

package/lib/thin/connection.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -31,8 +31,8 @@ const ConnectionImpl = require('../impl/connection.js');
 const ThinResultSetImpl = require('./resultSet.js');
 const ThinLobImpl  = require("./lob.js");
 const Protocol = require("./protocol/protocol.js");
-const { BaseBuffer } = require('./protocol/buffer.js');
-const {NetworkSession:nsi} = require("./sqlnet/networkSession.js");
+const { BaseBuffer } = require('../impl/datahandlers/buffer.js');
+const {NetworkSession: nsi} = require("./sqlnet/networkSession.js");
 const { Statement } = require("./statement");
 const thinUtil = require('./util');
 const sqlNetConstants = require('./sqlnet/constants.js');
@@ -41,6 +41,7 @@ const process = require('process');
 const types = require('../types.js');
 const errors = require("../errors.js");
 const messages = require('./protocol/messages');
+const StatementCache = require('./statementCache.js');
 
 const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
   heldValue.disconnect();
@@ -63,12 +64,10 @@ class ThinConnectionImpl extends ConnectionImpl {
       if (this._protocol.txnInProgress) {
         await this.rollback();
       }
-      this._protocol.callTimeout = 0;      // not applicable for close
       if (this._drcpEnabled) {
         await this._sessRelease();
         this._drcpEstablishSession = true;
       }
-
       if (this._pool && !this._dropSess) {
         await this._pool.release(this);
       } else {
@@ -94,13 +93,13 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   //---------------------------------------------------------------------------
-  // _determineElementObjType()
+  // _getElementTypeObj()
   //
-  // Determine the element type's object type. This is needed when processing
+  // Get the element type's object type. This is needed when processing
   // collections with an object as the element type since this information is
   // not available in the TDS.
   //---------------------------------------------------------------------------
-  async _determineElementObjType(info) {
+  async _getElementTypeObj(info) {
     const binds = [
       {
         name: "owner",
@@ -206,6 +205,9 @@ class ThinConnectionImpl extends ConnectionImpl {
 
     // process results
     const result = {};
+    if (message.warning) {
+      result.warning = message.warning;
+    }
     if (statement.numQueryVars > 0) {
       result.resultSet = message.resultSet;
     } else {
@@ -252,60 +254,77 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   //---------------------------------------------------------------------------
-  // _parseElementType()
+  // _parseTDSAttr()
   //
-  // Parses the element type from the TDS buffer.
+  // Returns the DB type and fills metadata from the TDS buffer.
   //---------------------------------------------------------------------------
-  async _parseElementType(buf, info) {
-    let oraTypeNum, csfrm;
-    const attrType = buf.readUInt8();
+  _parseTDSAttr(buf, metaData) {
+    let oraTypeNum, csfrm, attrType;
+
+    // skip until a type code that is of interest
+    for (;;) {
+      attrType = buf.readUInt8();
+      if (attrType === constants.TNS_OBJ_TDS_TYPE_EMBED_ADT_INFO) {
+        buf.skipBytes(1); // flags
+      } else if (attrType !== constants.TNS_OBJ_TDS_TYPE_SUBTYPE_MARKER) {
+        break;
+      }
+    }
+
+    // process the type code.
     switch (attrType) {
       case constants.TNS_OBJ_TDS_TYPE_NUMBER:
+        metaData.precision = buf.readInt8();
+        metaData.scale = buf.readInt8();
+        return types.DB_TYPE_NUMBER;
       case constants.TNS_OBJ_TDS_TYPE_FLOAT:
-        info.elementType = types.DB_TYPE_NUMBER;
-        break;
+        metaData.precision = buf.readInt8();
+        return types.DB_TYPE_NUMBER;
       case constants.TNS_OBJ_TDS_TYPE_VARCHAR:
       case constants.TNS_OBJ_TDS_TYPE_CHAR:
-        info.maxSize = buf.readUInt16BE();
+        metaData.maxSize = buf.readUInt16BE(); // maximum length
         oraTypeNum = (attrType === constants.TNS_OBJ_TDS_TYPE_VARCHAR) ?
           constants.TNS_DATA_TYPE_VARCHAR : constants.TNS_DATA_TYPE_CHAR;
         csfrm = buf.readUInt8();
-        info.elementType = types.getTypeByOraTypeNum(oraTypeNum, csfrm);
-        break;
+        csfrm = csfrm & 0x7f;
+        buf.skipBytes(2); // character set
+        return types.getTypeByOraTypeNum(oraTypeNum, csfrm);
       case constants.TNS_OBJ_TDS_TYPE_RAW:
-        info.elementType = types.DB_TYPE_RAW;
-        break;
+        metaData.maxSize = buf.readUInt16BE(); // maximum length
+        return types.DB_TYPE_RAW;
       case constants.TNS_OBJ_TDS_TYPE_BINARY_FLOAT:
-        info.elementType = types.DB_TYPE_BINARY_FLOAT;
-        break;
+        return types.DB_TYPE_BINARY_FLOAT;
       case constants.TNS_OBJ_TDS_TYPE_BINARY_DOUBLE:
-        info.elementType = types.DB_TYPE_BINARY_DOUBLE;
-        break;
+        return types.DB_TYPE_BINARY_DOUBLE;
       case constants.TNS_OBJ_TDS_TYPE_DATE:
-        info.elementType = types.DB_TYPE_DATE;
-        break;
+        return types.DB_TYPE_DATE;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP:
-        info.elementType = types.DB_TYPE_TIMESTAMP;
-        break;
+        buf.skipBytes(1); // precision
+        return types.DB_TYPE_TIMESTAMP;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP_LTZ:
-        info.elementType = types.DB_TYPE_TIMESTAMP_LTZ;
-        break;
+        buf.skipBytes(1); // precision
+        return types.DB_TYPE_TIMESTAMP_LTZ;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP_TZ:
-        info.elementType = types.DB_TYPE_TIMESTAMP_TZ;
-        break;
+        buf.skipBytes(1); // precision
+        return types.DB_TYPE_TIMESTAMP_TZ;
       case constants.TNS_OBJ_TDS_TYPE_BOOLEAN:
-        info.elementType = types.DB_TYPE_BOOLEAN;
-        break;
+        return types.DB_TYPE_BOOLEAN;
       case constants.TNS_OBJ_TDS_TYPE_CLOB:
-        this._determineElementTypeCharsetForm(info);
-        break;
+        return types.DB_TYPE_CLOB;
       case constants.TNS_OBJ_TDS_TYPE_BLOB:
-        info.elementType = types.DB_TYPE_BLOB;
-        break;
+        return types.DB_TYPE_BLOB;
       case constants.TNS_OBJ_TDS_TYPE_OBJ:
-        info.elementType = types.DB_TYPE_OBJECT;
-        await this._determineElementObjType(info);
-        break;
+        buf.skipBytes(5);
+        return types.DB_TYPE_OBJECT;
+      case constants.TNS_OBJ_TDS_TYPE_START_EMBED_ADT:
+        // loop until end type, TNS_OBJ_TDS_TYPE_END_EMBED_ADT
+        // is received.
+        while (this._parseTDSAttr(buf, {}) !== 0) {
+          continue;
+        }
+        return types.DB_TYPE_OBJECT;
+      case constants.TNS_OBJ_TDS_TYPE_END_EMBED_ADT:
+        return 0;
       default:
         errors.throwErr(errors.ERR_TDS_TYPE_NOT_SUPPORTED, attrType);
     }
@@ -314,12 +333,9 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   // _parseTDS()
   //
-  // Parses the TDS for the type. This is only needed for collection types, so
-  // if the TDS is determined to be for an object type, the remaining
-  // information is ignored.
+  // Parses the TDS (type descriptor segment) for the type.
   //---------------------------------------------------------------------------
   async _parseTDS(tds, info) {
-
     // parse initial TDS bytes
     const buf = new TDSBuffer(tds);
     buf.skipBytes(4);                   // end offset
@@ -329,10 +345,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     // if the number of attributes exceeds 1, the type cannot refer to a
     // collection, so nothing further needs to be done
     const numAttrs = buf.readUInt16BE();
-    if (numAttrs > 1) {
-      info.isCollection = false;
-      return;
-    }
 
     // continue parsing TDS bytes to discover if type refers to a collection
     buf.skipBytes(1);                   // TDS attributes?
@@ -340,23 +352,41 @@ class ThinConnectionImpl extends ConnectionImpl {
     buf.skipBytes(2);                   // ADT number (always zero)
     buf.skipBytes(4);                   // offset to index table
 
-    // if type of first attribute is not a collection, nothing further needs
-    // to be done
-    const attrType = buf.readUInt8();
-    info.isCollection = (attrType === constants.TNS_OBJ_TDS_TYPE_COLL);
-    if (!info.isCollection)
-      return;
-
-    // continue parsing TDS to determine element type
-    const elementPos = buf.readUInt32BE();
-    info.maxNumElements = buf.readUInt32BE();
-    info.collectionType = buf.readUInt8();
-    if (info.collectionType === constants.TNS_OBJ_PLSQL_INDEX_TABLE) {
-      info.collectionFlags = constants.TNS_OBJ_HAS_INDEXES;
+    // check to see if type refers to a collection (only one attribute is
+    // present in that case).
+    info.isCollection = false;
+    if (numAttrs === 1) {
+      const pos = buf.pos;
+      const attrType = buf.readUInt8();
+      if (attrType === constants.TNS_OBJ_TDS_TYPE_COLL) {
+        info.isCollection = true;
+      } else {
+        buf.pos = pos;
+      }
     }
-    buf.pos = elementPos;
 
-    await this._parseElementType(buf, info);
+    // Handle collections
+    if (info.isCollection) {
+      // continue parsing TDS to determine element type
+      const elementPos = buf.readUInt32BE();
+      info.maxNumElements = buf.readUInt32BE();
+      info.collectionType = buf.readUInt8();
+      if (info.collectionType === constants.TNS_OBJ_PLSQL_INDEX_TABLE) {
+        info.collectionFlags = constants.TNS_OBJ_HAS_INDEXES;
+      }
+      buf.pos = elementPos;
+      info.elementTypeInfo = {};
+      info.elementType = this._parseTDSAttr(buf, info.elementTypeInfo);
+      if (info.elementType === types.DB_TYPE_OBJECT) {
+        await this._getElementTypeObj(info);
+      }
+    } else {
+      if (info.attributes) { // skip for XML type as it has no attributes.
+        for (const attr of info.attributes) {
+          this._parseTDSAttr(buf, attr);
+        }
+      }
+    }
   }
 
   //---------------------------------------------------------------------------
@@ -482,9 +512,9 @@ class ThinConnectionImpl extends ConnectionImpl {
 
     // process TDS and attributes cursor
     info.version = result.outBinds.version;
-    await this._parseTDS(result.outBinds.tds, info);
     const attrRows = await result.outBinds.attrs_rc.getRows(1000, {});
     if (attrRows.length > 0) {
+      // Its an object not a collection.
       info.attributes = [];
       for (const row of attrRows) {
         const attr = { name: row[1] };
@@ -500,8 +530,9 @@ class ThinConnectionImpl extends ConnectionImpl {
         info.attributes.push(attr);
       }
     }
-    info.partial = false;
 
+    await this._parseTDS(result.outBinds.tds, info);
+    info.partial = false;
     return info;
 
   }
@@ -596,11 +627,8 @@ class ThinConnectionImpl extends ConnectionImpl {
     this.statementCache = null;
     this.currentSchema = "";
     this.invokeSessionCallback = true;
-    this.statementCache = new Map();
     this.statementCacheSize = params.stmtCacheSize;
-    this._numCursorsToClose = 0;
     this._currentSchemaModified = false;
-    this._cursorsToClose = new Set();
     this._tempLobsToClose = [];
     this._tempLobsTotalSize = 0;
     this._drcpEstablishSession = false;
@@ -704,6 +732,7 @@ class ThinConnectionImpl extends ConnectionImpl {
       throw err;
     }
 
+    this.statementCache = new StatementCache(this.statementCacheSize);
     // maintain a list of partially populated database object types
     this._partialDbObjectTypes = [];
 
@@ -716,51 +745,10 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   //---------------------------------------------------------------------------
-  // Sets that a statement is no longer in use
+  // Return the statement to the statement cache, if applicable
   //---------------------------------------------------------------------------
   _returnStatement(statement) {
-    if (statement.bindInfoList) {
-      statement.bindInfoList.forEach(bindInfo => {
-        bindInfo.bindVar = null;
-      });
-    }
-    if (statement.queryVars) {
-      statement.queryVars.forEach(queryVar => {
-        queryVar.values.fill(null);
-      });
-    }
-    if (statement.returnToCache) {
-      statement.inUse = false;
-    } else if (statement.cursorId !== 0) {
-      this._addCursorToClose(statement.cursorId);
-    }
-  }
-
-  //---------------------------------------------------------------------------
-  // Adds the cursors that needs to be closed to the _cursorsToClose set
-  //---------------------------------------------------------------------------
-  _addCursorToClose(cursorId) {
-    if (this._cursorsToClose.has(cursorId)) {
-      const reason = `attempt to close cursor ${cursorId} twice`;
-      errors.throwErr(errors.ERR_INTERNAL, reason);
-    }
-    this._cursorsToClose.add(cursorId);
-  }
-
-  //---------------------------------------------------------------------------
-  // Adjusts the statement cache to remove least recently used statements
-  //---------------------------------------------------------------------------
-  _adjustStatementCache() {
-    while (this.statementCache.size > this.statementCacheSize) {
-      const sql = this.statementCache.keys().next().value;
-      const stmt = this.statementCache.get(sql);
-      this.statementCache.delete(sql);
-      if (stmt.inUse) {
-        stmt.returnToCache = false;
-      } else if (stmt.cursorId !== 0) {
-        this._addCursorToClose(stmt.cursorId);
-      }
-    }
+    this.statementCache.returnStatement(statement);
   }
 
   //---------------------------------------------------------------------------
@@ -870,14 +858,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     return resultSet;
   }
 
-  //---------------------------------------------------------------------------
-  // Clears the statement cache for the connection
-  //---------------------------------------------------------------------------
-  resetStatementCache() {
-    this.statementCache.clear();
-    this._cursorsToClose.clear();
-  }
-
   //---------------------------------------------------------------------------
   // getDbObjectClass()
   //
@@ -942,31 +922,10 @@ class ThinConnectionImpl extends ConnectionImpl {
   // new session is going to be used.
   //---------------------------------------------------------------------------
   _getStatement(sql, cacheStatement = false) {
-    let statement = this.statementCache.get(sql);
-    if (!statement) {
-      statement = new Statement();
-      statement._prepare(sql);
-      if (cacheStatement && !this._drcpEstablishSession && !statement.isDdl &&
-          this.statementCacheSize > 0) {
-        statement.returnToCache = true;
-        this.statementCache.set(sql, statement);
-        this._adjustStatementCache();
-      }
-    } else if (statement.inUse || !cacheStatement ||
-        this._drcpEstablishSession) {
-      if (!cacheStatement) {
-        this.statementCache.delete(sql);
-        statement.returnToCache = false;
-      }
-      if (statement.inUse || this._drcpEstablishSession) {
-        statement = statement._copy();
-      }
-    } else {
-      this.statementCache.delete(sql);
-      this.statementCache.set(sql, statement);
+    if (this._drcpEstablishSession) {
+      cacheStatement = false;
     }
-    statement.inUse = true;
-    return statement;
+    return this.statementCache.getStatement(sql, cacheStatement);
   }
 
   //---------------------------------------------------------------------------
@@ -1061,7 +1020,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   // the connection object
   //---------------------------------------------------------------------------
   getStmtCacheSize() {
-    return this.statementCacheSize;
+    return this.statementCache._maxSize;
   }
 
   setCallTimeout(timeout) {
@@ -1085,6 +1044,47 @@ class ThinConnectionImpl extends ConnectionImpl {
   getInstanceName() {
     return this.instanceName;
   }
-}
 
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database domain name associated with the connection.
+  //---------------------------------------------------------------------------
+  getDbDomain() {
+    return this.dbDomain;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database name associated with the connection.
+  //---------------------------------------------------------------------------
+  getDbName() {
+    return this.dbName;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns maximum number of cursors that can be opened in one session.
+  //---------------------------------------------------------------------------
+  getMaxOpenCursors() {
+    return this.maxOpenCursors;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database service name associated with the connection.
+  //---------------------------------------------------------------------------
+  getServiceName() {
+    return this.serviceName;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns boolean based on this._protocol.txnInProgress value.
+  //---------------------------------------------------------------------------
+  getTransactionInProgress() {
+    return this._protocol.txnInProgress === constants.TNS_TXN_IN_PROGRESS;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the warning object.
+  //---------------------------------------------------------------------------
+  getWarning() {
+    return this.warning;
+  }
+}
 module.exports = ThinConnectionImpl;

package/lib/thin/dbObject.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -31,7 +31,8 @@ const constants = require('./protocol/constants.js');
 const errors = require('../errors.js');
 const types = require('../types.js');
 const DbObjectImpl = require('../impl/dbObject.js');
-const { GrowableBuffer } = require('./protocol/buffer.js');
+const { GrowableBuffer } = require('../impl/datahandlers/buffer.js');
+const ThinLobImpl = require('./lob.js');
 
 class DbObjectPickleBuffer extends GrowableBuffer {
 
@@ -125,6 +126,16 @@ class DbObjectPickleBuffer extends GrowableBuffer {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // _writeRawBytesAndLength()
+  //
+  // Writes the length in the format required before
+  // writing the bytes.
+  //---------------------------------------------------------------------------
+  _writeRawBytesAndLength(value, numBytes) {
+    this.writeLength(numBytes);
+    this.writeBytes(value);
+  }
 }
 
 class ThinDbObjectImpl extends DbObjectImpl {
@@ -269,9 +280,11 @@ class ThinDbObjectImpl extends DbObjectImpl {
           buf.writeBytesWithLength(value);
           break;
         case types.DB_TYPE_BINARY_DOUBLE:
+          buf.writeUInt8(8);
           buf.writeBinaryDouble(value);
           break;
         case types.DB_TYPE_BINARY_FLOAT:
+          buf.writeUInt8(4);
           buf.writeBinaryFloat(value);
           break;
         case types.DB_TYPE_DATE:
@@ -642,4 +655,37 @@ class ThinDbObjectImpl extends DbObjectImpl {
 
 }
 
-module.exports = ThinDbObjectImpl;
+//---------------------------------------------------------------------------
+// readXML()
+//
+// Decodes the raw Bytes to XML string or LOB object.
+//
+//---------------------------------------------------------------------------
+function readXML(conn, buf) {
+  let colValue;
+
+  const xmlObj = new DbObjectPickleBuffer(buf);
+  const tempobj = {};
+  xmlObj.readHeader(tempobj);
+  xmlObj.skipBytes(1);
+  const xmlflag = xmlObj.readUInt32BE();
+  if (xmlflag & constants.TNS_XML_TYPE_FLAG_SKIP_NEXT_4) {
+    xmlObj.skipBytes(4);
+  }
+  const numBytesLeft = xmlObj.numBytesLeft();
+  const ptr = xmlObj.readBytes(numBytesLeft);
+  if (xmlflag & constants.TNS_XML_TYPE_STRING) {
+    colValue = ptr.toString();
+  } else if (xmlflag & constants.TNS_XML_TYPE_LOB) {
+    const lobImpl = new ThinLobImpl();
+    const locator = Buffer.from(ptr);
+    lobImpl.init(conn, locator, types.DB_TYPE_CLOB, 0, 0);
+    colValue = lobImpl;
+  } else {
+    // We only support String and Clob type.
+    errors.throwErr(errors.ERR_UNEXPECTED_XML_TYPE, xmlflag);
+  }
+  return colValue;
+}
+
+module.exports = { ThinDbObjectImpl, readXML };

package/lib/thin/index.js

@@ -30,7 +30,7 @@ const ThinConnectionImpl = require('./connection.js');
 const ThinResultSetImpl = require('./resultSet.js');
 const ThinPoolImpl = require('./pool.js');
 const ThinLobImpl = require('./lob.js');
-const ThinDbObjectImpl = require('./dbObject.js');
+const { ThinDbObjectImpl } = require('./dbObject.js');
 
 const impl = require('../impl');
 impl.ConnectionImpl = ThinConnectionImpl;

package/lib/thin/lob.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -89,11 +89,11 @@ class ThinLobImpl extends LobImpl {
     return this.dbType;
   }
 
-  async getData() {
-    if (this._length < 0) {
-      errors.throwErr(errors.ERR_INVALID_LOB);
+  async getData(offset = 1, len = this._length) {
+    if (!len) {
+      len = this._length;
     }
-    return await this.read(1, this._length);
+    return await this.read(offset, len);
   }
 
   async read(offset, length) {
@@ -157,7 +157,7 @@ class ThinLobImpl extends LobImpl {
 
   checkConn() {
     if (!this.conn.nscon.connected)
-      errors.throwErr(errors.ERR_LOB_CLOSED);
+      errors.throwErr(errors.ERR_INVALID_CONNECTION);
   }
 
   close() {

package/lib/thin/pool.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -53,6 +53,7 @@ class ThinPoolImpl extends PoolImpl {
     this._poolIncrement = params.poolIncrement;
     this._poolTimeout = params.poolTimeout;
     this._poolPingInterval = params.poolPingInterval;
+    this._poolPingTimeout = params.poolPingTimeout;
     this._stmtCacheSize = params.stmtCacheSize;
 
     // The user Config filterd from common layer is cached except
@@ -102,6 +103,7 @@ class ThinPoolImpl extends PoolImpl {
       this._userConfig.privateKey = null;
     }
     this._accessTokenFn = params.accessTokenFn;
+    this._accessTokenConfig = params.accessTokenConfig;
     this._isDRCPEnabled = false;
     this.eventEmitter = new EventEmitter();
     // listener to remove dead or idle connections
@@ -176,7 +178,7 @@ class ThinPoolImpl extends PoolImpl {
         protocolUtil.getDeobfuscatedValue(this._token, this._obfuscatedToken);
       if (util.isTokenExpired(clonedAttrs.token)) {
         if (typeof this._accessTokenFn === 'function') {
-          accessToken = await this._accessTokenFn(true);
+          accessToken = await this._accessTokenFn(true, this._accessTokenConfig);
           if (typeof accessToken === 'string') {
             clonedAttrs.token = accessToken;
             if (util.isTokenExpired(clonedAttrs.token)) {
@@ -199,7 +201,6 @@ class ThinPoolImpl extends PoolImpl {
               const objToken = protocolUtil.setObfuscatedValue(clonedAttrs.token);
               this._token = objToken.value;
               this._obfuscatedToken = objToken.obfuscatedValue;
-
               const objKey = protocolUtil.setObfuscatedValue(clonedAttrs.privateKey);
               this._privateKey = objKey.value;
               this._obfuscatedPrivateKey = objKey.obfuscatedValue;
@@ -318,6 +319,13 @@ class ThinPoolImpl extends PoolImpl {
     return this._poolPingInterval;
   }
 
+  //---------------------------------------------------------------------------
+  // returns the pool ping Timeout (milliseconds)
+  //---------------------------------------------------------------------------
+  getPoolPingTimeout() {
+    return this._poolPingTimeout;
+  }
+
   //---------------------------------------------------------------------------
   // returns the pool timeout
   //---------------------------------------------------------------------------
@@ -363,13 +371,13 @@ class ThinPoolImpl extends PoolImpl {
   _scanIdleConnection() {
     while ((this._usedConnectionList.size + this._freeConnectionList.length) >
         this._poolMin && this._freeConnectionList.length > 0) {
-      const conn = this._freeConnectionList[this._freeConnectionList.length - 1];
+      const conn = this._freeConnectionList[0];
       if (Date.now() - conn._lastTimeUsed < this._poolTimeout * 1000) {
         break;
       }
 
       this.eventEmitter.emit('_removePoolConnection', conn);
-      this._freeConnectionList.pop();
+      this._freeConnectionList.shift();
     }
 
     this._schedulerJob = null;
@@ -495,11 +503,21 @@ class ThinPoolImpl extends PoolImpl {
           requiresPing = true;
       }
       if (requiresPing) {
+        let pingTimer;
         try {
+          if (this._poolPingTimeout) {
+            pingTimer = setTimeout(() => {
+              // force disconnect causes ping task to unblock
+              // and return.
+              conn.nscon.forceDisconnect();
+            }, this._poolPingTimeout);
+          }
           await conn.ping();
         } catch {
-          this.eventEmitter.emit('_removePoolConnection', conn);
+          conn.nscon.forceDisconnect();
           continue;
+        } finally {
+          clearTimeout(pingTimer);
         }
       }
 
@@ -541,6 +559,7 @@ class ThinPoolImpl extends PoolImpl {
 
   // release connection to connection pool
   release(conn) {
+    conn.warning = undefined;
     this._usedConnectionList.delete(conn);
     if (conn.nscon.connected) {
       conn._lastTimeUsed = Date.now();