oracledb 7.0.1 → 26.0.0

package/lib/thin/connection.js

@@ -39,10 +39,20 @@ const sqlNetConstants = require('./sqlnet/constants.js');
 const constants = require('./protocol/constants.js');
 const process = require('process');
 const types = require('../types.js');
+const pubConstants = require('../constants.js');
 const errors = require("../errors.js");
 const messages = require('./protocol/messages');
 const StatementCache = require('./statementCache.js');
+const ThinSubscrImpl = require('./subscr.js');
 const { ThinQueueImpl } = require('./aq.js');
+const parserHelpers = require('../impl/parserHelpers.js');
+const { createNVPair, findNVPair } = require('./sqlnet/nvStrToNvPair.js');
+const { ObfuscatedValue } = require('../obfuscation.js');
+
+// Oracle can return a named UTC alias instead of the equivalent fixed offset
+// +00:00. These aliases have no offset changes, so Thin can safely treat them
+// as a zero fixed offset after the DBTIMEZONE fallback query identifies one.
+const UTC_DB_TIME_ZONE_NAMES = new Set(['UTC', 'GMT', 'UNIVERSAL', 'ZULU']);
 
 const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
   heldValue.disconnect();
@@ -84,6 +94,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   async close() {
     try {
       this.clearEndUserSecurityContext();
+      this._clearDatabaseOpenTelemetryTracing();
       if (this._protocol.txnInProgress) {
         if (this.tpcContext) {
           const message = this.createTpcRollbackMessage();
@@ -246,7 +257,9 @@ class ThinConnectionImpl extends ConnectionImpl {
     if (statement.isPlSql && (statement.cursorId === 0 ||
       statement.requiresFullExecute)) {
       message.numExecs = 1;
-      message.noImplicitRelease = true;
+      // Suppress release only when another iteration follows.
+      message.noImplicitRelease = numIters > 1;
+
       await this._protocol._processMessage(message);
       statement.requiresFullExecute = false;
       message.numExecs = numIters - 1;
@@ -286,7 +299,6 @@ class ThinConnectionImpl extends ConnectionImpl {
           if (statement.isPlSql && (statement.cursorId === 0 ||
             statement.requiresFullExecute)) {
             message.numExecs = 1;
-            message.noImplicitRelease = true;
             await this._protocol._encodeMessage(message);
             message.requiresSingleExecute = true;
           } else if (message.numExecs > 0) {
@@ -637,13 +649,19 @@ class ThinConnectionImpl extends ConnectionImpl {
       case constants.TNS_OBJ_TDS_TYPE_DATE:
         return types.DB_TYPE_DATE;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP:
-        buf.skipBytes(1); // precision
+        metaData.scale = buf.readInt8();
+        if (metaData.scale !== null && metaData.scale !== undefined)
+          metaData.precision = 0;
         return types.DB_TYPE_TIMESTAMP;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP_LTZ:
-        buf.skipBytes(1); // precision
+        metaData.scale = buf.readInt8();
+        if (metaData.scale !== null && metaData.scale !== undefined)
+          metaData.precision = 0;
         return types.DB_TYPE_TIMESTAMP_LTZ;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP_TZ:
-        buf.skipBytes(1); // precision
+        metaData.scale = buf.readInt8();
+        if (metaData.scale !== null && metaData.scale !== undefined)
+          metaData.precision = 0;
         return types.DB_TYPE_TIMESTAMP_TZ;
       case constants.TNS_OBJ_TDS_TYPE_BOOLEAN:
         return types.DB_TYPE_BOOLEAN;
@@ -750,8 +768,10 @@ class ThinConnectionImpl extends ConnectionImpl {
         case
           when data_precision is null and data_scale is null
             then 0
-          when data_precision is null
+          when data_precision is null and data_type = 'NUMBER'
             then 38
+          when data_precision is null and data_type != 'NUMBER'
+            then 0
           else data_precision
         end,
         case
@@ -1019,9 +1039,12 @@ class ThinConnectionImpl extends ConnectionImpl {
           if (tempMaxSize)
             attr.maxSize = tempMaxSize;
         }
-        if (attr.type === types.DB_TYPE_NUMBER) {
-          attr.precision = Number(attrInfo.dataPrecision);
-          attr.scale = Number(attrInfo.dataScale);
+        if (attr.type === types.DB_TYPE_NUMBER ||
+            attr.type === types.DB_TYPE_TIMESTAMP ||
+            attr.type === types.DB_TYPE_TIMESTAMP_TZ ||
+            attr.type === types.DB_TYPE_TIMESTAMP_LTZ) {
+          attr.precision = Number(attrInfo.dataPrecision ?? 0);
+          attr.scale = Number(attrInfo.dataScale ?? 0);
         }
       }
     }
@@ -1147,12 +1170,16 @@ class ThinConnectionImpl extends ConnectionImpl {
     this._clientIdentifierModified = false;
     this._action = "";
     this._actionModified = false;
+    this._ecid = "";
+    this._ecidModified = false;
     this._dbOp = "";
     this._dbOpModified = false;
     this._clientInfo = "";
     this._clientInfoModified = false;
     this._module = "";
     this._moduleModified = false;
+    this.databaseOpenTelemetryTracing = false;
+    this._otelModified = false;
     this._drcpEnabled = false;
     this.serviceName = '';
     this.remoteAddress = '';
@@ -1160,6 +1187,13 @@ class ThinConnectionImpl extends ConnectionImpl {
     this.tpcContext = null;
     this._sessionlessData = null;
     this._nameSpaceMap = new Map();
+    this._txnPriority = "";
+    this._pendingTxnPriority = undefined;
+    this._txnPriorityModified = false;
+
+    if (!this._isNotificationConnection) {
+      this._setNotificationConnectParams(params);
+    }
 
     this.nscon = new nsi();
     finalizationRegistry.register(this, this.nscon);
@@ -1234,15 +1268,22 @@ class ThinConnectionImpl extends ConnectionImpl {
         await this._protocol._processMessage(authMessage); // OAUTH
       }
       this._postConnect(authMessage);
+      if (params.txnPriority === "") {
+        this.setTxnPriority("");
+      }
+
+      this.statementCache = new StatementCache(this.statementCacheSize);
+      // maintain a list of partially populated database object types
+      this._partialDbObjectTypes = [];
+
+      if (this._requiresDbTimeZoneInitialization()) {
+        await this._initializeDbTimeZone();
+      }
     } catch (err) {
       this.nscon.disconnect();
       throw err;
     }
 
-    this.statementCache = new StatementCache(this.statementCacheSize);
-    // maintain a list of partially populated database object types
-    this._partialDbObjectTypes = [];
-
     if (params.debugJDWP) {
       this.jdwpData = Buffer.from(params.debugJDWP);
     } else if (process.env.ORA_DEBUG_JDWP) {
@@ -1251,6 +1292,68 @@ class ThinConnectionImpl extends ConnectionImpl {
     this._protocol.connInProgress = false;
   }
 
+  //---------------------------------------------------------------------------
+  // _requiresDbTimeZoneInitialization()
+  //
+  // The DBTIMEZONE fallback is an ordinary SQL query and must only be sent on
+  // application connections. An EMON notification connection never fetches or
+  // binds TIMESTAMP WITH LOCAL TIME ZONE values, and servers can close it when
+  // sent this query.
+  //---------------------------------------------------------------------------
+  _requiresDbTimeZoneInitialization() {
+    return !this._isNotificationConnection &&
+      this._protocol.caps.dbTzOffset === null;
+  }
+
+  //---------------------------------------------------------------------------
+  // _initializeDbTimeZone()
+  //
+  // A TZ_EX response supplies a fixed DBTIMEZONE offset directly. Region
+  // responses supply an Oracle region ID instead, and older servers do not
+  // return a DBTIMEZONE value. In both cases, query DBTIMEZONE once to get
+  // the offset, recognize a named UTC zero-offset alias, or identify a
+  // region configuration unsupported for LTZ.
+  //---------------------------------------------------------------------------
+  async _initializeDbTimeZone() {
+    const options = {
+      connection: { _impl: this },
+      keepInStmtCache: false
+    };
+
+    // Use DBTIMEZONE so named regions are preserved. Using TZ_OFFSET(DBTIMEZONE)
+    // would reduce a DST-aware region to a single offset.
+    const result = await this.execute('SELECT DBTIMEZONE FROM DUAL', 1, [],
+      options, false);
+    let rows;
+    try {
+      rows = await result.resultSet.getRows(1, options);
+    } finally {
+      await result.resultSet.close();
+    }
+    const value = rows[0][0];
+    const match = /^([+-])(\d{2}):(\d{2})$/.exec(value);
+    if (match || UTC_DB_TIME_ZONE_NAMES.has(value.toUpperCase())) {
+      let offset = 0;
+      if (match) {
+        offset = Number(match[2]) * 60 + Number(match[3]);
+        if (match[1] === '-') {
+          offset = -offset;
+        }
+      }
+      this._protocol.caps.dbTzOffset = offset;
+
+      // A fixed DBTIMEZONE, including a UTC alias, does not need a region
+      // name or Oracle timezone-rule processing.
+      this._protocol.caps.dbTzRegion = null;
+    } else {
+      // The TTC response contains only an Oracle internal region ID. Do not
+      // use Node.js ICU rules as a substitute for Oracle's timezone rules.
+      // LTZ fetches and binds reject this configuration in BaseBuffer.
+      this._protocol.caps.dbTzOffset = null;
+      this._protocol.caps.dbTzRegion = value;
+    }
+  }
+
   //---------------------------------------------------------------------------
   // Return the statement to the statement cache, if applicable
   //---------------------------------------------------------------------------
@@ -1258,6 +1361,35 @@ class ThinConnectionImpl extends ConnectionImpl {
     this.statementCache.returnStatement(statement);
   }
 
+  //---------------------------------------------------------------------------
+  // Synchronize query variables after result set setup recalculates fetch
+  // types for the current execute. If a LOB-like column's requested define
+  // type has changed, the cached cursor cannot be reused as-is and must be
+  // cleared so that a fresh define round trip is performed.
+  //---------------------------------------------------------------------------
+  _syncQueryVars(statement, previousTypes) {
+    if (!statement.isQuery || statement.queryVars.length === 0) {
+      return;
+    }
+
+    const defineTypeChanged = statement.queryVars.some((variable, i) => {
+      const dbType = variable.fetchInfo.dbType;
+      const requiresLobDefine = dbType === types.DB_TYPE_CLOB ||
+        dbType === types.DB_TYPE_NCLOB ||
+        dbType === types.DB_TYPE_BLOB ||
+        dbType === types.DB_TYPE_JSON ||
+        dbType === types.DB_TYPE_VECTOR;
+      return requiresLobDefine &&
+        previousTypes[i] !== variable.fetchInfo.fetchType;
+    });
+
+    if (defineTypeChanged && statement.cursorId !== 0) {
+      // Clearing the cursor forces a full TNS_FUNC_EXECUTE with fresh defines.
+      this.statementCache._addCursorToClose(statement);
+      statement._clearState();
+    }
+  }
+
   //---------------------------------------------------------------------------
   // Parses the sql statement and puts it into cache if keepInStmtCache
   // option is true
@@ -1265,6 +1397,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   _prepare(sql, options) {
     const forceNew = Boolean(options.fetchTypeMap);
     const statement = this._getStatement(sql, options.keepInStmtCache, forceNew);
+    statement._registrationId = options._subscriptionRegId || 0n;
     statement.bufferRowIndex = 0;
     statement.bufferRowCount = 0;
     statement.lastRowIndex = 0;
@@ -1272,6 +1405,124 @@ class ThinConnectionImpl extends ConnectionImpl {
     return statement;
   }
 
+  //---------------------------------------------------------------------------
+  // _buildNotificationConnectString()
+  //
+  // Build a connect string that requests an EMON server connection.
+  //---------------------------------------------------------------------------
+  async _buildNotificationConnectString(connectString, configDir) {
+    if (!connectString) {
+      return connectString;
+    }
+
+    // Resolve aliases before modifying CONNECT_DATA so every connection
+    // string form, including tnsnames.ora aliases, requests EMON.
+    const resolved = await parserHelpers.resolveConnectStr(connectString,
+      configDir);
+    const descriptor = typeof resolved === 'string' ? resolved :
+      resolved.toString();
+
+    let root;
+    try {
+      root = createNVPair(descriptor);
+    } catch {
+      return connectString;
+    }
+
+    const stack = [root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!node) {
+        continue;
+      }
+
+      if (String(node.name).toUpperCase() === "DESCRIPTION") {
+        let connectData = findNVPair(node, "CONNECT_DATA");
+        if (!connectData) {
+          connectData = new node.constructor("CONNECT_DATA");
+          node.addListElement(connectData);
+        }
+
+        let serverNode = findNVPair(connectData, "SERVER");
+        if (!serverNode) {
+          serverNode = new connectData.constructor("SERVER");
+          connectData.addListElement(serverNode);
+        }
+        serverNode.setAtom = "EMON";
+      }
+
+      for (let i = 0; i < node.getListSize(); i++) {
+        stack.push(node.getListElement(i));
+      }
+    }
+
+    return root.toString();
+  }
+
+  //---------------------------------------------------------------------------
+  // _setNotificationConnectParams()
+  //
+  // Retain only the connection attributes needed to establish the dedicated
+  // notification connection. Sensitive values are obfuscated rather than kept
+  // directly on the connection object.
+  //---------------------------------------------------------------------------
+  _setNotificationConnectParams(params) {
+    this._connectParams = {...params};
+
+    // _connInfo contains pool-specific connection metadata. The EMON
+    // connection must establish its own standalone connection.
+    delete this._connectParams._connInfo;
+    this._password = new ObfuscatedValue();
+    this._walletPassword = new ObfuscatedValue();
+    this._walletContent = new ObfuscatedValue();
+    this._token = new ObfuscatedValue();
+    this._privateKey = new ObfuscatedValue();
+
+    if (params.password !== undefined) {
+      this._password.set(params.password);
+      this._connectParams.password = null;
+    }
+    if (params.walletPassword !== undefined) {
+      this._walletPassword.set(params.walletPassword);
+      this._connectParams.walletPassword = null;
+    }
+    if (params.walletContent !== undefined) {
+      this._walletContent.set(params.walletContent);
+      this._connectParams.walletContent = null;
+    }
+    if (params.token !== undefined) {
+      this._token.set(params.token);
+      this._connectParams.token = null;
+    }
+    if (params.privateKey !== undefined) {
+      this._privateKey.set(params.privateKey);
+      this._connectParams.privateKey = null;
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // _getNotificationConnectParams()
+  //
+  // Return connect parameters suitable for the dedicated notification channel.
+  //---------------------------------------------------------------------------
+  async _getNotificationConnectParams() {
+    const params = {...this._connectParams};
+    if (params.password === null)
+      params.password = this._password.get();
+    if (params.walletPassword === null)
+      params.walletPassword = this._walletPassword.get();
+    if (params.walletContent === null)
+      params.walletContent = this._walletContent.get();
+    if (params.token === null)
+      params.token = this._token.get();
+    if (params.privateKey === null)
+      params.privateKey = this._privateKey.get();
+    params.connectString = await this._buildNotificationConnectString(
+      this._connectParams.connectString,
+      this._connectParams.configDir);
+    return params;
+  }
+
   //---------------------------------------------------------------------------
   // Binds the values by user to the statement object
   //---------------------------------------------------------------------------
@@ -1363,8 +1614,10 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
     resultSet._resultSetNew(this, statement, options);
     if (statement.queryVars.length > 0) {
+      const previousTypes = statement.queryVars.map(variable => variable.type);
       const metadata = thinUtil.getMetadataMany(statement.queryVars);
       resultSet._setup(options, metadata);
+      this._syncQueryVars(statement, previousTypes);
     }
     return resultSet;
   }
@@ -1385,19 +1638,17 @@ class ThinConnectionImpl extends ConnectionImpl {
   //
   // Parses the SQL statement and returns information about the statement.
   //---------------------------------------------------------------------------
-  async getStatementInfo(sql) {
-    const options = {};
+  async getStatementInfo(sql, options) {
     const result = {};
     const statement = this._prepare(sql, options);
-    options.connection = this;
     try {
       if (!statement.isDdl) {
         const message = new messages.ExecuteMessage(this, statement, options);
         message.parseOnly = true;
         await this._protocol._processMessage(message);
-      }
-      if (statement.numQueryVars > 0) {
-        result.metaData = thinUtil.getMetadataMany(statement.queryVars);
+        if (message.resultSet) {
+          result.metaData = message.resultSet.metaData;
+        }
       }
       result.bindNames = Array.from(statement.bindInfoDict.keys());
       result.statementType = statement.statementType;
@@ -1407,6 +1658,66 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // subscribe()
+  //
+  // Creates or reuses a thin subscription and optionally registers a query for
+  // DBCHANGE subscriptions.
+  //---------------------------------------------------------------------------
+  async subscribe(inSubscr, options) {
+    if (!options.clientInitiated) {
+      errors.throwNotImplemented("server initiated subscription");
+    }
+
+    let subscr = inSubscr;
+    if (subscr?._listenerStopped) {
+      // Same-name subscribe can recover from an unavailable listener. First
+      // deregister the previous server registration, then create a replacement.
+      try {
+        await subscr.unsubscribe(this);
+      } catch (err) {
+        if (err.code !== errors.getErr(errors.ERR_INVALID_SUBSCR).code) {
+          throw err;
+        }
+      }
+      subscr = null;
+    }
+    if (!subscr) {
+      subscr = new ThinSubscrImpl(this, options);
+      await subscr.subscribe(options);
+    } else {
+      if (!(subscr instanceof ThinSubscrImpl)) {
+        errors.throwErr(errors.ERR_INVALID_SUBSCR);
+      }
+      if (subscr.namespace !== options.namespace) {
+        errors.throwErr(errors.ERR_INVALID_SUBSCR);
+      }
+      if (options.namespace === pubConstants.SUBSCR_NAMESPACE_DBCHANGE) {
+        await subscr.registerQuery(options);
+      }
+    }
+
+    if (options.namespace === pubConstants.SUBSCR_NAMESPACE_DBCHANGE) {
+      return {
+        regId: subscr.regId,
+        subscription: subscr
+      };
+    }
+    return subscr;
+  }
+
+  //---------------------------------------------------------------------------
+  // unsubscribe()
+  //
+  // Unregisters and closes a thin subscription.
+  //---------------------------------------------------------------------------
+  async unsubscribe(subscr) {
+    if (!subscr || !(subscr instanceof ThinSubscrImpl)) {
+      errors.throwErr(errors.ERR_INVALID_SUBSCR);
+    }
+    await subscr.unsubscribe(this);
+  }
+
   async _handleDefines(statement, message) {
     if (statement.requiresDefine && statement.sql) {
       statement.requiresFullExecute = true;
@@ -1501,6 +1812,13 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.currentSchema;
   }
 
+  getDatabaseOpenTelemetryTracing() {
+    if (!this._protocol.caps.supportsServerOtelTracing) {
+      errors.throwErr(errors.ERR_UNSUPPORTED_DB_OTEL_FEATURE);
+    }
+    return this.databaseOpenTelemetryTracing;
+  }
+
   setClientId(clientId) {
     this._clientIdentifierModified = true;
     this._clientIdentifier = clientId;
@@ -1511,6 +1829,28 @@ class ThinConnectionImpl extends ConnectionImpl {
     this._dbOp = dbOp;
   }
 
+  setDatabaseOpenTelemetryTracing(value) {
+    if (!this._protocol.caps.supportsServerOtelTracing) {
+      errors.throwErr(errors.ERR_UNSUPPORTED_DB_OTEL_FEATURE);
+    }
+    this._otelModified = true;
+    this.databaseOpenTelemetryTracing = value;
+  }
+
+  _clearDatabaseOpenTelemetryTracing() {
+    if (this.databaseOpenTelemetryTracing) {
+      this.databaseOpenTelemetryTracing = false;
+      // the new connection acquired would send tracing
+      // as disabled on server unless application explicitly enables it.
+      this._otelModified = true;
+    }
+  }
+
+  setECID(ecid) {
+    this._ecidModified = true;
+    this._ecid = ecid;
+  }
+
   setExternalName(value) {
     this.externalName = value;
   }
@@ -1540,6 +1880,22 @@ class ThinConnectionImpl extends ConnectionImpl {
     this._action = action;
   }
 
+  // Always queue the requested priority, even if it matches the last known
+  // server value. _txnPriority contains only the last value synchronized from
+  // the server, while _pendingTxnPriority contains only the last value
+  // requested through this method. Neither can reliably account for changes
+  // made through explicit ALTER SESSION.
+  setTxnPriority(priority) {
+    this._protocol.caps.assertTxnPrioritySupported();
+    this._pendingTxnPriority = priority;
+    this._txnPriorityModified = true;
+  }
+
+  getTxnPriority() {
+    this._protocol.caps.assertTxnPrioritySupported();
+    return this._txnPriority;
+  }
+
   async changePassword(user, password, newPassword) {
     const config = {
       user: user,
@@ -1905,6 +2261,12 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   clearEndUserSecurityContext() {
+    // A provider-created context belongs to this borrowed thin connection.
+    // A pool release invokes close(), so reset resolution before this
+    // physical connection is available to its next borrower.
+    if (this._securityContextInitialized) {
+      this._securityContextInitialized = false;
+    }
     this.securityContext = null;
   }
 

package/lib/thin/dbObject.js

@@ -208,7 +208,8 @@ class ThinDbObjectImpl extends DbObjectImpl {
   _getPackedData() {
     if (this.packedData)
       return this.packedData;
-    const buf = new DbObjectPickleBuffer();
+    const caps = this._objType._connection._protocol.caps;
+    const buf = new DbObjectPickleBuffer(undefined, caps);
     buf.writeHeader(this);
     this._packData(buf);
     const size = buf.pos;
@@ -316,7 +317,8 @@ class ThinDbObjectImpl extends DbObjectImpl {
   // Unpacks the packed data into a map of JavaScript values.
   //---------------------------------------------------------------------------
   _unpackData() {
-    const buf = new DbObjectPickleBuffer(this.packedData);
+    const caps = this._objType._connection._protocol.caps;
+    const buf = new DbObjectPickleBuffer(this.packedData, caps);
     buf.readHeader(this);
     this._unpackDataFromBuf(buf);
     this.packedData = undefined;
@@ -368,7 +370,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
   // Unpacks a single value and returns it.
   //---------------------------------------------------------------------------
   _unpackValue(buf, type, typeClass) {
-    let isNull, obj, value, isCollection;
+    let isCollection, obj, value;
     const caps = this._objType._connection._protocol.caps;
     switch (type) {
       case types.DB_TYPE_NUMBER:
@@ -396,6 +398,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
       case types.DB_TYPE_TIMESTAMP:
         return buf.readOracleDate(true);
       case types.DB_TYPE_TIMESTAMP_LTZ:
+        return buf.readOracleDate(false, true);
       case types.DB_TYPE_TIMESTAMP_TZ:
         return buf.readOracleDate(false);
       case types.DB_TYPE_BOOLEAN:
@@ -403,14 +406,20 @@ class ThinDbObjectImpl extends DbObjectImpl {
       case types.DB_TYPE_OBJECT:
       case types.DB_TYPE_XMLTYPE:
         obj = new ThinDbObjectImpl(typeClass);
+
+        // check for XMLType
+        if (obj._objType.isXmlType) {
+          const xmlBytes = buf.readBytesWithLength();
+          if (!xmlBytes)
+            return null;
+          return readXML(obj._objType._connection, xmlBytes);
+        }
+
+        // check the type of object
         isCollection = obj._objType.isCollection ||
           this._objType.isCollection;
-        isNull = buf.getIsAtomicNull(isCollection);
-        if (isNull)
+        if (buf.getIsAtomicNull(isCollection))
           return null;
-        if (obj._objType.isXmlType) {
-          return readXML(obj._objType._connection, buf.readBytesWithLength());
-        }
         if (isCollection) {
           obj.packedData = Buffer.from(buf.readBytesWithLength());
         } else {

package/lib/thin/pool.js

@@ -434,7 +434,7 @@ class ThinPoolImpl extends PoolImpl {
     // continue until a close request is received
     while (!this._poolCloseWaiter) {
 
-      const numToCreate = this._getNumConnsToCreate();
+      let numToCreate = this._getNumConnsToCreate();
       // connection creation is going on serially and not concurrently
       for (let i = 0; i < numToCreate; i++) {
         try {
@@ -480,8 +480,9 @@ class ThinPoolImpl extends PoolImpl {
         break;
       }
 
+      numToCreate = this._getNumConnsToCreate();
       // if no pending requests, wait for pending requests to appear!
-      if ((this._pendingRequests.length == 0 || this._bgErr) &&
+      if ((numToCreate <= 0 || this._bgErr) &&
         this.getConnectionsOpen() >= this._poolMin) {
         await new Promise((resolve) => {
           this.bgWaiter = resolve;