oracledb 6.9.0 → 7.0.0

package/lib/impl/datahandlers/buffer.js

@@ -372,12 +372,23 @@ class BaseBuffer {
   //
   // Reads a boolean value from the buffer and returns a Boolean.
   //---------------------------------------------------------------------------
-  readBool() {
+  readBool(fromDBObject) {
     const buf = this.readBytesWithLength();
     if (!buf) {
       return null;
     }
-    return (buf[buf.length - 1] === 1);
+    if (fromDBObject) {
+      // inside a database object, the boolean is represented as a
+      // big endian 32-bit integer (either 0 or 1)
+      return (buf[buf.length - 1] === 1);
+    } else {
+      // outside a database object, the boolean is represented as an
+      // encoded integer (0x00 for false and 0x0101 for true); older
+      // versions like 12.1 also return 0x8101 (-1) for null values
+      // but this can safely be ignored as the null indicator is sent
+      // as a separate field afterwards.
+      return (buf[0] === 1);
+    }
   }
 
   //---------------------------------------------------------------------------
@@ -397,6 +408,18 @@ class BaseBuffer {
     return buf;
   }
 
+  //---------------------------------------------------------------------------
+  // readBytesAndLength()
+  //
+  // Reads the UB4 length from the buffer and then returns a Buffer containing
+  // the specified number of bytes.
+  //---------------------------------------------------------------------------
+  readBytesAndLength() {
+    const numBytes = this.readUB4();
+    if (numBytes > 0)
+      return this.readBytesWithLength();
+  }
+
   //---------------------------------------------------------------------------
   // readBytesWithLength()
   //
@@ -548,6 +571,17 @@ class BaseBuffer {
     return Buffer.from(buf).swap16().toString('utf16le');
   }
 
+  //---------------------------------------------------------------------------
+  // readStrAndLength()
+  //
+  // Reads a length from the buffer and then, if the length is non-zero, reads
+  // string from the buffer and returns it.
+  //---------------------------------------------------------------------------
+  readStrAndLength() {
+    const buf = this.readBytesAndLength();
+    return buf ? buf.toString() : null;
+  }
+
   //---------------------------------------------------------------------------
   // readUB2()
   //
@@ -897,7 +931,7 @@ class BaseBuffer {
   //
   // Writes the number (in string form) in Oracle Number format to the buffer.
   //---------------------------------------------------------------------------
-  writeOracleNumber(value) {
+  writeOracleNumber(value, writeLength = true) {
 
     // determine if number is negative
     let isNegative = false;
@@ -961,8 +995,11 @@ class BaseBuffer {
     } else if (value.length === 0 && exponent === 0) {
       exponentOnWire = 128;
     }
-    let pos = this.reserveBytes(numPairs + 2 + appendSentinel);
-    this.buf[pos++] = numPairs + 1 + appendSentinel;
+    let pos = this.reserveBytes(numPairs + 1 + writeLength + appendSentinel);
+
+    if (writeLength) {
+      this.buf[pos++] = numPairs + 1 + appendSentinel;
+    }
     this.buf[pos++] = exponentOnWire;
     for (let i = 0; i < value.length; i += 2) {
       const base100Digit = Number(value.substring(i, i + 2));
@@ -997,6 +1034,32 @@ class BaseBuffer {
     this.buf.writeInt32BE(n, pos);
   }
 
+  //---------------------------------------------------------------------------
+  // writeSB4()
+  //
+  // Writes a signed integer (up to 4 bytes in length) in variable length
+  // format to the buffer.
+  //---------------------------------------------------------------------------
+  writeSB4(value) {
+    let sign = 0;
+    if (value < 0) {
+      value = -value;
+      sign = 0x80;
+    }
+    if (value === 0) {
+      this.writeUInt8(0);
+    } else if (value <= 0xff) {
+      this.writeUInt8(1 | sign);
+      this.writeUInt8(value);
+    } else if (value <= 0xffff) {
+      this.writeUInt8(2 | sign);
+      this.writeUInt16BE(value);
+    } else {
+      this.writeUInt8(4 | sign);
+      this.writeUInt32BE(value);
+    }
+  }
+
   //---------------------------------------------------------------------------
   // writeUB4()
   //

package/lib/impl/datahandlers/oson.js

@@ -549,8 +549,13 @@ class OsonTreeSegment extends GrowableBuffer {
 
     // handle numbers
     } else if (typeof value === 'number') {
-      this.writeUInt8(constants.TNS_JSON_TYPE_NUMBER_LENGTH_UINT8);
-      this.writeOracleNumber(value.toString());
+      if (Number.isNaN(value)) {
+        this.writeUInt8(constants.TNS_JSON_TYPE_BINARY_DOUBLE);
+        this.writeBinaryDouble(value);
+      } else {
+        this.writeUInt8(constants.TNS_JSON_TYPE_NUMBER_LENGTH_UINT8);
+        this.writeOracleNumber(value.toString());
+      }
 
     // handle strings
     } else if (typeof value === 'string') {

package/lib/impl/datahandlers/vector.js

@@ -37,6 +37,21 @@ const types = require("../../types.js");
  */
 class VectorDecoder extends BaseBuffer {
 
+  //---------------------------------------------------------------------------
+  // _verifyVectorDataSize()
+  //
+  // Verifies that the VECTOR image contains enough bytes for the declared
+  // element count before allocating a typed array.
+  //---------------------------------------------------------------------------
+  _verifyVectorDataSize(numElements, elementSize) {
+    const numBytes = numElements * elementSize;
+    const numBytesLeft = this.numBytesLeft();
+    if (numBytes > numBytesLeft) {
+      errors.throwErr(errors.ERR_UNEXPECTED_END_OF_DATA, numBytes,
+        numBytesLeft);
+    }
+  }
+
   //---------------------------------------------------------------------------
   // decode()
   //
@@ -56,7 +71,7 @@ class VectorDecoder extends BaseBuffer {
     const flags = this.readUInt16BE();
     const vectorFormat = this.readUInt8();
     let numElements = this.readUInt32BE();
-    let elementSize, value, sparseValue;
+    let arrayType, elementSize, sparseValue;
 
     // For binary vector, NORM will never be present but space for NORM is reserved to keep
     // same header lengh across the different vector formats.
@@ -69,6 +84,7 @@ class VectorDecoder extends BaseBuffer {
       sparseValue = {};
       sparseValue.numDimensions = numElements; // vector dimensions.
       numElements = this.readUInt16BE(); // actual elements.
+      this._verifyVectorDataSize(numElements, 4);
       sparseValue.indices = new Uint32Array(numElements);
       for (let i = 0; i < numElements; i++) {
         sparseValue.indices[i] = this.readUInt32BE();
@@ -76,22 +92,26 @@ class VectorDecoder extends BaseBuffer {
     }
 
     if (vectorFormat === constants.VECTOR_FORMAT_FLOAT32) {
+      arrayType = Float32Array;
       elementSize = 4;
-      value = new Float32Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_FLOAT64) {
+      arrayType = Float64Array;
       elementSize = 8;
-      value = new Float64Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_INT8) {
+      arrayType = Int8Array;
       elementSize = 1;
-      value = new Int8Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_BINARY) {
+      arrayType = Uint8Array;
       elementSize = 1;
       // The number of dimensions are assumed to be multiple of 8.
+      if (numElements % 8 !== 0)
+        errors.throwErr(errors.ERR_UNEXPECTED_DATA, numElements);
       numElements = numElements / 8;
-      value = new Uint8Array(numElements);
     } else {
       errors.throwErr(errors.ERR_VECTOR_FORMAT_NOT_SUPPORTED, vectorFormat);
     }
+    this._verifyVectorDataSize(numElements, elementSize);
+    const value = new arrayType(numElements);
 
     if (sparseFormat) {
       sparseValue.values = value;

package/lib/impl/lob.js

@@ -81,6 +81,15 @@ class LobImpl extends BaseImpl {
     errors.throwNotImplemented("getting directory and filename of LOB(BFILE)");
   }
 
+  //---------------------------------------------------------------------------
+  // trim()
+  //
+  // trims non-BFILE LOBs to a smaller size.
+  //----------------------------------------------------------------------------
+  trim() {
+    errors.throwNotImplemented("trimming LOBs");
+  }
+
   //---------------------------------------------------------------------------
   // read()
   //

package/lib/impl/parserHelpers.js

@@ -0,0 +1,443 @@
+// Copyright (c) 2026, Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
+
+'use strict';
+
+const { createNVPair } = require('../thin/sqlnet/nvStrToNvPair.js');
+const EZConnectResolver = require('../thin/sqlnet/ezConnectResolver.js');
+const { NLParamParser, tnsnamesFilePath } = require('../thin/sqlnet/paramParser.js');
+const errors = require('../errors.js');
+const process = require('process');
+
+const NJS_PREFIX = 'njs.';
+const RHS_LIST = 2;
+const NUMBER_KEYS = new Set([
+  'poolIncrement', 'poolMax', 'poolMin', 'poolTimeout', 'queueTimeout',
+  'maxLifetimeSession', 'poolMaxPerShard', 'poolPingInterval',
+  'poolPingTimeout', 'stmtCacheSize', 'mode', 'getMode'
+]);
+
+const BOOLEAN_KEYS = new Set([
+  'events', 'externalAuth', 'homogeneous', 'useTcpFastOpen',
+  'disableOob', 'sodaMetaDataCache'
+]);
+
+const STRING_KEYS = new Set([
+  'driverName', 'edition', 'machine', 'osUser', 'program', 'terminal'
+]);
+
+const nlParamParser = new NLParamParser();
+const childLookupCache = new WeakMap();
+
+/**
+ * Formats a boolean value as a string 'true' or 'false'.
+ * @param {boolean} value - The boolean value to format.
+ * @returns {string} 'true' if value is true, 'false' otherwise.
+ */
+function formatBooleanTrueFalse(value) {
+  return value ? 'true' : 'false';
+}
+
+const CONNECT_OVERRIDES = [
+  // DESCRIPTION-level parameters
+  { opt: 'sdu', section: ['DESCRIPTION', 'SDU'], fmt: String },
+  { opt: 'failover', section: ['DESCRIPTION', 'FAILOVER'] },
+  { opt: 'loadBalance', section: ['DESCRIPTION', 'LOAD_BALANCE'] },
+  { opt: 'retryCount', section: ['DESCRIPTION', 'RETRY_COUNT'], fmt: String },
+  { opt: 'retryDelay', section: ['DESCRIPTION', 'RETRY_DELAY'], fmt: String },
+  { opt: 'sourceRoute', section: ['DESCRIPTION', 'SOURCE_ROUTE'] },
+  { opt: 'transportConnectTimeout', section: ['DESCRIPTION', 'TRANSPORT_CONNECT_TIMEOUT'], fmt: String },
+  { opt: 'useSNI', section: ['DESCRIPTION', 'USE_SNI'], fmt: formatBooleanTrueFalse },
+
+  // CONNECT_DATA parameters
+  { opt: 'poolBoundary', section: ['DESCRIPTION', 'CONNECT_DATA', 'POOL_BOUNDARY'] },
+  { opt: 'poolConnectionClass', section: ['DESCRIPTION', 'CONNECT_DATA', 'POOL_CONNECTION_CLASS'] },
+  { opt: 'poolName', section: ['DESCRIPTION', 'CONNECT_DATA', 'POOL_NAME'] },
+  { opt: 'poolPurity', section: ['DESCRIPTION', 'CONNECT_DATA', 'POOL_PURITY'] },
+  { opt: 'expireTime', section: ['DESCRIPTION', 'CONNECT_DATA', 'EXPIRE_TIME'], fmt: String },
+
+  // SECURITY parameters
+  { opt: 'walletLocation', section: ['DESCRIPTION', 'SECURITY', 'MY_WALLET_DIRECTORY'] },
+  { opt: 'sslServerCertDn', section: ['DESCRIPTION', 'SECURITY', 'SSL_SERVER_CERT_DN'] },
+  { opt: 'sslServerDnMatch', section: ['DESCRIPTION', 'SECURITY', 'SSL_SERVER_DN_MATCH'] },
+
+  // ADDRESS parameters
+  { opt: 'httpsProxy', section: ['DESCRIPTION', 'ADDRESS', 'HTTPS_PROXY'], perAddress: true },
+  { opt: 'httpsProxyPort', section: ['DESCRIPTION', 'ADDRESS', 'HTTPS_PROXY_PORT'], perAddress: true, fmt: String }
+];
+
+/**
+ * Returns the uppercase name of the node if it exists and is a string.
+ * @param {Object} node - The node to get the name from.
+ * @returns {string|undefined} Uppercase name or undefined.
+ */
+function getUpperName(node) {
+  if (!node || typeof node.name !== 'string') {
+    return undefined;
+  }
+  return node.name.toUpperCase();
+}
+// Drops the cached child-name lookup for a node so the next search rebuilds it after structural changes.
+function invalidateChildLookup(node) {
+  if (node) {
+    childLookupCache.delete(node);
+  }
+}
+// Builds (or reuses) a per-parent map from uppercase child names to their node arrays for quick lookups.
+function getChildLookup(parent) {
+  if (!parent || !Array.isArray(parent.list) || parent.list.length === 0) {
+    return null;
+  }
+  let lookup = childLookupCache.get(parent);
+  if (!lookup) {
+    lookup = Object.create(null);
+    for (const child of parent.list) {
+      const key = getUpperName(child);
+      if (!key) {
+        continue;
+      }
+      if (lookup[key]) {
+        lookup[key].push(child);
+      } else {
+        lookup[key] = [child];
+      }
+    }
+    childLookupCache.set(parent, lookup);
+  }
+  return lookup;
+}
+// Uses the cached lookup to return the first child whose name matches the provided string, or undefined if absent.
+function findFirstChild(parent, name) {
+  if (typeof name !== 'string') {
+    return undefined;
+  }
+  const lookup = getChildLookup(parent);
+  if (!lookup) {
+    return undefined;
+  }
+  const key = name.toUpperCase();
+  const list = lookup[key];
+  return list ? list[0] : undefined;
+}
+
+/**
+ * Collects all DESCRIPTION nodes from the root NVPair tree.
+ * Traverses the tree using a stack to find DESCRIPTION nodes.
+ * @param {Object} root - The root NVPair node.
+ * @returns {Array} Array of DESCRIPTION nodes.
+ */
+function collectDescriptions(root) {
+  if (!root || typeof root.name !== 'string') {
+    return [];
+  }
+  const stack = [root];
+  const descriptions = [];
+  while (stack.length) {
+    const node = stack.pop();
+    if (!node || typeof node.name !== 'string') {
+      continue;
+    }
+    const name = node.name.toUpperCase();
+    if (name === 'DESCRIPTION' && node.rhsType === RHS_LIST) {
+      descriptions.push(node);
+      continue;
+    }
+    if (name === 'DESCRIPTION_LIST' && node.list) {
+      for (let i = 0; i < node.list.length; i++) {
+        stack.push(node.list[i]);
+      }
+    }
+  }
+  return descriptions;
+}
+
+/**
+ * Ensures a child node with the given name exists under the parent.
+ * Creates it if necessary.
+ * @param {Object} parent - The parent NVPair node.
+ * @param {string} name - The name of the child node.
+ * @returns {Object} The child node.
+ */
+function ensureNode(parent, name) {
+  const key = name.toUpperCase();
+  if (parent.rhsType === RHS_LIST && Array.isArray(parent.list)) {
+    const cached = findFirstChild(parent, key);
+    if (cached) {
+      return cached;
+    }
+  }
+  const created = new parent.constructor(key);
+  parent.addListElement(created);
+  invalidateChildLookup(parent);
+  return created;
+}
+
+/**
+ * Finds all child nodes with the given name under the parent.
+ * @param {Object} parent - The parent NVPair node.
+ * @param {string} name - The name to search for.
+ * @returns {Array} Array of matching child nodes.
+ */
+function findChildren(parent, name) {
+  if (typeof name !== 'string') {
+    return [];
+  }
+  const lookup = getChildLookup(parent);
+  if (!lookup) {
+    return [];
+  }
+  const key = name.toUpperCase();
+  const matches = lookup[key];
+  if (!matches || matches.length === 0) {
+    return [];
+  }
+  return matches.slice();
+}
+
+/**
+ * Places a parameter node in the correct position within a DESCRIPTION list.
+ * Positions before ADDRESS, ADDRESS_LIST, or CONNECT_DATA.
+ * @param {Object} description - The DESCRIPTION NVPair node.
+ * @param {Object} node - The parameter node to place.
+ */
+function placeDescriptionParam(description, node) {
+  const list = description.list;
+  const idx = list.indexOf(node);
+  if (idx > -1) {
+    list.splice(idx, 1);
+  }
+  let pos = 0;
+  while (pos < list.length) {
+    const childName = getUpperName(list[pos]);
+    if (childName === 'ADDRESS' || childName === 'ADDRESS_LIST' || childName === 'CONNECT_DATA') {
+      break;
+    }
+    pos++;
+  }
+  list.splice(pos, 0, node);
+  invalidateChildLookup(description);
+}
+
+/**
+ * Applies overrides from the options object to the connectString.
+ * Handles NVPair format, TNS alias resolution, and updates the options.connectString in place.
+ * Only adds parameters if not already present in the descriptor.
+ * Supports EZConnect strings, TNS aliases (via tnsnames.ora), and full descriptors.
+ *
+ * @param {Object} options - The connection options object containing connectString and override parameters.
+ * @example
+ * // Example with full descriptor
+ * const options = {
+ *   connectString: '(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=host)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=service)))',
+ *   sdu: 8192,
+ *   retryCount: 3
+ * };
+ * await applyConnectStringOverrides(options);
+ * // options.connectString now includes (SDU=8192) and (RETRY_COUNT=3) if not already present
+ *
+ * // Example with TNS alias
+ * const options = {
+ *   connectString: 'mydb',
+ *   configDir: '/path/to/network/admin',
+ *   sdu: 8192
+ * };
+ * await applyConnectStringOverrides(options);
+ * // Resolves 'mydb' from tnsnames.ora and applies SDU if not present
+ *
+ * // Example with EZConnect
+ * const options = {
+ *   connectString: 'tcps://host:1521/service',
+ *   walletLocation: '/path/to/wallet'
+ * };
+ * await applyConnectStringOverrides(options);
+ * // Converts to descriptor and adds (SECURITY=(MY_WALLET_DIRECTORY=/path/to/wallet))
+ */
+async function applyConnectStringOverrides(options) {
+  const connectString = options.connectString;
+  const trimmed = connectString.trim();
+  let root;
+  if (trimmed.startsWith('(')) {
+    // Parse direct NVPair format
+    root = createNVPair(trimmed);
+  } else {
+    const configDir = options.configDir || process.env.TNS_ADMIN || '';
+    const resolved = await resolveConnectStr(trimmed, configDir);
+    root = (typeof resolved === 'string') ? createNVPair(resolved) : resolved;
+  }
+
+  const descriptions = collectDescriptions(root);
+  if (!descriptions.length) return;
+
+  const configured = [];
+  for (const def of CONNECT_OVERRIDES) {
+    const raw = options[def.opt];
+    if (raw === undefined) {
+      continue;
+    }
+    const formatter = def.fmt || (v => v);
+    const value = formatter(raw);
+    configured.push({ def, value });
+  }
+
+  if (!configured.length) return;
+
+  for (const description of descriptions) {
+    for (const entry of configured) {
+      const def = entry.def;
+      const value = entry.value;
+      const { section, perAddress } = def;
+      if (perAddress) {
+        const addresses = findChildren(description, section[1]);
+        if (!addresses.length) continue;
+        for (const addr of addresses) {
+          const existingNode = findFirstChild(addr, section[2]);
+          if (!existingNode) {
+            ensureNode(addr, section[2]).setAtom = value;
+          }
+        }
+        continue;
+      }
+      let node = description;
+      let existing = false;
+      for (let k = 1; k < section.length; k++) {
+        const child = findFirstChild(node, section[k]);
+        if (!child) break;
+        node = child;
+        if (k === section.length - 1) existing = true;
+      }
+      if (!existing) {
+        for (let k = 1; k < section.length; k++) {
+          node = ensureNode(node, section[k]);
+        }
+        node.setAtom = value;
+        if (section.length === RHS_LIST && section[0] === 'DESCRIPTION') {
+          placeDescriptionParam(description, node);
+        }
+      }
+    }
+  }
+
+  options.connectString = root.toString();
+}
+
+/**
+ * Merges extended parameters from the EZConnect resolver into the options object.
+ * Only processes keys starting with 'njs.' and coerces values based on predefined sets.
+ * @param {Object} options - The options object to merge into.
+ * @param {Object} resolver - The EZConnect resolver containing connection properties.
+ * @returns {Object} The updated options object.
+ * @example
+ * const resolver = new EZConnectResolver('tcp://host:port/service?njs.stmtCacheSize=10&njs.events=true');
+ * const options = {};
+ * const merged = mergeExtendedParams(options, resolver);
+ * // merged = { stmtCacheSize: 10, events: true }
+ */
+function mergeExtendedParams(options, resolver) {
+  for (const [rawKey, rawValue] of resolver.connectionProps.entries()) {
+    let key = rawKey;
+    if (key.startsWith(NJS_PREFIX)) {
+      key = key.slice(NJS_PREFIX.length);
+    } else {
+      continue;
+    }
+    let value = rawValue;
+    if (NUMBER_KEYS.has(key)) {
+      value = Number(rawValue);
+      if (isNaN(value) || !Number.isInteger(value)) continue;
+    } else if (BOOLEAN_KEYS.has(key)) {
+      const lower = rawValue.toLowerCase();
+      value = (lower === 'true' || lower === 'on' || lower === 'yes');
+    } else if (STRING_KEYS.has(key)) {
+      value = rawValue;
+    } else {
+      continue;
+    }
+    options[key] = value;
+  }
+  return options;
+}
+
+/**
+ * Resolves an EZConnect string to a connect descriptor.
+ * @param {string} connStr - The EZConnect string.
+ * @returns {Object} Object containing connectString and resolver.
+ * @example
+ * const result = getConnectDescriptorFromEZConnect('tcp://host:1521/service');
+ * // result = { connectString: '(DESCRIPTION=...)' , resolver: EZConnectResolver instance }
+ */
+function getConnectDescriptorFromEZConnect(connStr) {
+  if (connStr && ((connStr.indexOf(')') == -1) || (connStr.indexOf('(') != 0))) {
+    if (connStr.indexOf(':') !== -1 || connStr.indexOf('/') !== -1) {
+      const resolver = new EZConnectResolver(connStr);
+      return { connectString: resolver.getResolvedUrl(), resolver };
+    }
+  }
+  return { connectString: connStr, resolver: null };
+}
+
+/**
+ * Resolves a connect string, handling EZConnect or TNS aliases.
+ * @param {string} connectString - The connect string to resolve.
+ * @param {string} configDir - Directory for tnsnames.ora.
+ * @returns {Promise<Object|string>} Resolved connect descriptor or string.
+ * @example
+ * const resolved = await resolveConnectStr('mydb', '/path/to/network/admin');
+ * // Resolves 'mydb' from tnsnames.ora in the given directory
+ */
+async function resolveConnectStr(connectString, configDir) {
+  const connStr = connectString.trim();
+  let resolvedVal = connStr;
+  if ((connStr.indexOf(')') === -1) || (connStr.indexOf('(') != 0)) {
+    if ((connStr.indexOf(':') != -1) || (connStr.indexOf('/') != -1)) {
+      const ezcnObj = new EZConnectResolver(connStr);
+      resolvedVal = ezcnObj.getResolvedUrl();
+      return resolvedVal;
+    } else {
+      //try tns alias
+      const namesFilePath = tnsnamesFilePath(configDir);
+      const p = await nlParamParser.initializeNlpa(namesFilePath);
+      resolvedVal = p.get(connStr.toUpperCase());
+      if (!resolvedVal)
+        errors.throwErr(errors.ERR_TNS_ENTRY_NOT_FOUND, connStr, configDir ? configDir + '/tnsnames.ora' : process.env.TNS_ADMIN + '/tnsnames.ora');
+      if (resolvedVal.rhsType == 1) {
+        const rString = resolvedVal.atom;
+        if ((rString.indexOf(':') != -1) || (rString.indexOf('/') != -1)) {
+          return new EZConnectResolver(rString).getResolvedUrl();
+        }
+      }
+      resolvedVal = resolvedVal.getListElement(0);
+    }
+
+  }
+  return resolvedVal;
+}
+
+module.exports = {
+  applyConnectStringOverrides,
+  mergeExtendedParams,
+  getConnectDescriptorFromEZConnect,
+  resolveConnectStr
+};

package/lib/impl/resultset.js

@@ -287,7 +287,7 @@ class ResultSetImpl extends BaseImpl {
     const fetchArraySize = 100;
     // fetch all rows
     let rowsFetched = [];
-    while (true) {    // eslint-disable-line
+    while (true) {
       // constant default value for fetchArraySize
       const rows = await this.getRows(fetchArraySize, {});
       if (rows) {