oracledb 6.5.1 → 6.7.0

package/lib/impl/resultset.js

@@ -34,9 +34,10 @@ const future = require('../future.js');
 const types = require('../types.js');
 const Lob = require('../lob.js');
 const oson = require('./datahandlers/oson.js');
+const BaseImpl = require('./base.js');
 
 // define implementation class
-class ResultSetImpl {
+class ResultSetImpl extends BaseImpl {
 
   //---------------------------------------------------------------------------
   // _determineFetchType()
@@ -236,7 +237,8 @@ class ResultSetImpl {
         this.nestedCursorIndices.push(i);
       } else if (info.fetchType === types.DB_TYPE_CLOB ||
           info.fetchType === types.DB_TYPE_NCLOB ||
-          info.fetchType === types.DB_TYPE_BLOB) {
+          info.fetchType === types.DB_TYPE_BLOB ||
+          info.fetchType === types.DB_TYPE_BFILE) {
         this.lobIndices.push(i);
       } else if (info.fetchType === types.DB_TYPE_OBJECT) {
         this.dbObjectIndices.push(i);
@@ -275,6 +277,30 @@ class ResultSetImpl {
     errors.throwNotImplemented("getting rows");
   }
 
+  //---------------------------------------------------------------------------
+  // _getAllRows() [INTERNAL]
+  //
+  // Fetches all the rows from the database to use internally.
+  //---------------------------------------------------------------------------
+  async _getAllRows() {
+    const fetchArraySize = 100;
+    // fetch all rows
+    let rowsFetched = [];
+    while (true) {    // eslint-disable-line
+      // constant default value for fetchArraySize
+      const rows = await this.getRows(fetchArraySize, {});
+      if (rows) {
+        await this._processRows(rows, false);
+        rowsFetched = rowsFetched.concat(rows);
+      }
+      if (rows.length < fetchArraySize) {
+        break;
+      }
+    }
+
+    return rowsFetched;
+  }
+
 }
 
 module.exports = ResultSetImpl;

package/lib/impl/sodaCollection.js

@@ -27,8 +27,9 @@
 'use strict';
 
 const errors = require('../errors.js');
+const BaseImpl = require('./base.js');
 
-class SodaCollectionImpl {
+class SodaCollectionImpl extends BaseImpl {
 
   //---------------------------------------------------------------------------
   // _getConnImpl()

package/lib/impl/sodaDatabase.js

@@ -27,8 +27,9 @@
 'use strict';
 
 const errors = require('../errors.js');
+const BaseImpl = require('./base.js');
 
-class SodaDatabaseImpl {
+class SodaDatabaseImpl extends BaseImpl {
 
   //---------------------------------------------------------------------------
   // _getConnImpl()

package/lib/impl/sodaDocCursor.js

@@ -27,8 +27,9 @@
 'use strict';
 
 const errors = require('../errors.js');
+const BaseImpl = require('./base.js');
 
-class SodaDocCursorImpl {
+class SodaDocCursorImpl extends BaseImpl {
 
   //---------------------------------------------------------------------------
   // _getConnImpl()

package/lib/impl/sodaOperation.js

@@ -27,8 +27,9 @@
 'use strict';
 
 const errors = require('../errors.js');
+const BaseImpl = require('./base.js');
 
-class SodaOperationImpl {
+class SodaOperationImpl extends BaseImpl {
 
   //---------------------------------------------------------------------------
   // _getConnImpl()

package/lib/lob.js

@@ -46,6 +46,22 @@ class Lob extends Duplex {
     });
   }
 
+  // called by BFILE specific functions to throw errors for other
+  // datatypes.
+  _checkIsBfile() {
+    if (this.type !== types.DB_TYPE_BFILE) {
+      errors.throwErr(errors.ERR_OPERATION_ONLY_SUPPORTED_ON_BFILE);
+    }
+  }
+
+  // called by functions not allowed for BFILE and throw errors if
+  // such operations are performed on BFILE.
+  _checkNotBfile() {
+    if (this.type === types.DB_TYPE_BFILE) {
+      errors.throwErr(errors.ERR_OPERATION_NOT_SUPPORTED_ON_BFILE);
+    }
+  }
+
   // called by stream.destroy() and ensures that the LOB is closed if it has
   // not already been closed (never called directly)
   async _destroy(err, cb) {
@@ -101,7 +117,10 @@ class Lob extends Duplex {
   // called to associate a LOB implementation with this user facing object
   _setup(lobImpl, autoCloseLob) {
     this._impl = lobImpl;
-    this._chunkSize = lobImpl.getChunkSize();
+    // chunk size is not defined for BFILE LOBs
+    if (this.type !== types.DB_TYPE_BFILE) {
+      this._chunkSize = lobImpl.getChunkSize();
+    }
     this._pieceSize = lobImpl.getPieceSize();
     this._length = lobImpl.getLength();
     this._type = lobImpl.getType();
@@ -153,6 +172,7 @@ class Lob extends Duplex {
   // Property for the chunk size of the LOB.
   //---------------------------------------------------------------------------
   get chunkSize() {
+    this._checkNotBfile();
     return this._chunkSize;
   }
 
@@ -209,6 +229,36 @@ class Lob extends Duplex {
     return await this._impl.getData(offset, amount);
   }
 
+  //---------------------------------------------------------------------------
+  // getDirFileName()
+  //  To obtain the BFILE Lob object properties dirName & fileName
+  //---------------------------------------------------------------------------
+  getDirFileName() {
+    this._checkIsBfile();
+    return this._impl.getDirFileName();
+  }
+
+  //--------------------------------------------------------------------------
+  // setDirFileName()
+  //  To set the BFILE Lob object properties dirName & fileName
+  //--------------------------------------------------------------------------
+  setDirFileName(a1) {
+    this._checkIsBfile();
+    errors.assertArgCount(arguments, 1, 1);
+    errors.assertParamValue(nodbUtil.isObject(a1), 1);
+    this._impl.setDirFileName(a1);
+  }
+
+  //---------------------------------------------------------------------------
+  // fileExists
+  //
+  //   To obtain file existence status of BFILE file
+  //---------------------------------------------------------------------------
+  async fileExists() {
+    this._checkIsBfile();
+    return await this._impl.fileExists();
+  }
+
   //---------------------------------------------------------------------------
   // length
   //
@@ -248,8 +298,10 @@ class Lob extends Duplex {
 
 nodbUtil.wrapFns(Lob.prototype, errors.ERR_BUSY_LOB,
   "close",
+  "fileExists",
   "getData");
-Lob.prototype._serializedRead = nodbUtil.serialize(Lob.prototype._readData);
-Lob.prototype._serializedWrite = nodbUtil.serialize(Lob.prototype._writeData);
+Lob.prototype._serializedRead = nodbUtil.wrapFn(Lob.prototype._readData, true);
+Lob.prototype._serializedWrite =
+  nodbUtil.wrapFn(Lob.prototype._writeData, true);
 
 module.exports = Lob;

package/lib/oracledb.js

@@ -47,8 +47,10 @@ errors.assert(vs[0] > 14 || (vs[0] === 14 && vs[1] >= 6),
 const AqDeqOptions = require('./aqDeqOptions.js');
 const AqEnqOptions = require('./aqEnqOptions.js');
 const AqMessage = require('./aqMessage.js');
+const protocolUtil = require('./thin/protocol/utils.js');
 const AqQueue = require('./aqQueue.js');
 const future = require('./future.js');
+const traceHandler = require('./traceHandler.js');
 const BaseDbObject = require('./dbObject.js');
 const Connection = require('./connection.js');
 const Lob = require('./lob.js');
@@ -65,14 +67,23 @@ const SodaOperation = require('./sodaOperation.js');
 const poolCache = {};
 const tempUsedPoolAliases = {};
 const defaultPoolAlias = 'default';
+let configProviderCache;
 
 // save arguments for call to initOracleClient()
 let _initOracleClientArgs;
 
 // Load the Oracledb binary
 function _initCLib(options) {
+  // Ensure that webpack compile does not throw any issues or warnings
+  // See https://github.com/oracle/node-oracledb/issues/1156
+  // and https://github.com/oracle/node-oracledb/issues/1678
+  const nodeVer = typeof process !== 'undefined' && process.versions?.node;
   /*global __non_webpack_require__*/  // quieten eslint
-  const requireBinary = (typeof __non_webpack_require__ === 'function') ? __non_webpack_require__ : require; // See Issue 1156
+  const requireBinary = nodeVer
+    ? (typeof __webpack_require__ === 'function')
+      ? __non_webpack_require__
+      : require
+    : undefined;
   const binaryLocations = [
     '../' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BINARY_FILE,  // pre-built binary
     '../' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BUILD_FILE,   // binary built from source
@@ -129,6 +140,7 @@ async function _verifyOptions(options, inCreatePool) {
   // define normalized options (value returned to caller)
   const outOptions = {};
 
+  options = await _checkConfigProvider(options);
   // only one of "user" and "username" may be specified (and must be strings)
   if (options.user !== undefined) {
     errors.assertParamPropValue(typeof options.user === 'string', 1, "user");
@@ -177,6 +189,13 @@ async function _verifyOptions(options, inCreatePool) {
     outOptions.walletLocation = options.walletLocation;
   }
 
+  //wallet content must be a string
+  if (options.walletContent !== undefined) {
+    errors.assertParamPropValue(typeof options.walletContent === 'string', 1,
+      "walletContent");
+    outOptions.walletContent = options.walletContent;
+  }
+
   // edition must be a string
   if (options.edition !== undefined) {
     errors.assertParamPropValue(typeof options.edition === 'string', 1,
@@ -311,6 +330,38 @@ async function _verifyOptions(options, inCreatePool) {
     outOptions.privilege = options.privilege;
   }
 
+  // machine must be a string
+  if (options.machine !== undefined) {
+    nodbUtil.assertParamPropNetworkName(options, 1, "machine");
+    outOptions.machine = options.machine;
+  }
+
+  // osUser must be a string
+  if (options.osUser !== undefined) {
+    nodbUtil.assertParamPropNetworkName(options, 1, "osUser");
+    outOptions.osUser = options.osUser;
+  }
+
+  // driverName must be a string
+  if (options.driverName !== undefined) {
+    errors.assertParamPropValue(typeof options.driverName === 'string',
+      1, "driverName");
+    outOptions.driverName = options.driverName;
+  }
+
+  // program must be a string
+  if (options.program !== undefined) {
+    nodbUtil.assertParamPropNetworkName(options, 1, "program");
+    outOptions.program = options.program;
+  }
+
+  // terminal must be a string
+  if (options.terminal !== undefined) {
+    errors.assertParamPropValue(typeof options.terminal === 'string',
+      1, "terminal");
+    outOptions.terminal = options.terminal;
+  }
+
   // check pool specific options
   if (inCreatePool) {
 
@@ -537,9 +588,12 @@ async function createPool(options) {
   // add defaults to options, if needed
   settings.addToOptions(options,
     "connectionClass",
+    "driverName",
     "edition",
     "events",
     "externalAuth",
+    "machine",
+    "osUser",
     "stmtCacheSize",
     "poolMax",
     "poolMaxPerShard",
@@ -548,6 +602,8 @@ async function createPool(options) {
     "poolTimeout",
     "poolPingInterval",
     "poolPingTimeout",
+    "program",
+    "terminal",
     "queueMax",
     "queueTimeout");
 
@@ -572,6 +628,8 @@ async function createPool(options) {
   // create the pool, ensuring that the temporary pool alias cache is removed
   // once this has completed (either successfully or unsuccessfully)
   const pool = new Pool();
+  pool._impl._connectString = options.connectString;
+  pool._impl._user = options.user;
   try {
     await pool._impl.create(options);
   } finally {
@@ -598,6 +656,22 @@ async function createPool(options) {
   return pool;
 }
 
+//-----------------------------------------------------------------------------
+// getNetworkServiceNames()
+//
+// Returns a list of the network service names found in the
+// tnsnames.ora file which is inside the directory
+// configDir or the $TNS_ADMIN dir
+// If a tnsnames.ora file does not exist, then an exception is raised
+//-----------------------------------------------------------------------------
+async function getNetworkServiceNames(configDir) {
+  const { NLParamParser, tnsnamesFilePath } = require('thin/sqlnet/paramParser.js');
+  const nlParamParser =  new NLParamParser;
+  const filePath = tnsnamesFilePath(configDir);
+  const aliasht = await nlParamParser.initializeNlpa(filePath);
+  const keysArr = [ ...aliasht.keys() ];
+  return keysArr;
+}
 
 //-----------------------------------------------------------------------------
 // getConnection()
@@ -630,16 +704,23 @@ async function getConnection(a1) {
   options = await _verifyOptions(options, false);
   settings.addToOptions(options,
     "connectionClass",
+    "driverName",
     "edition",
     "events",
     "externalAuth",
-    "stmtCacheSize");
+    "machine",
+    "osUser",
+    "program",
+    "stmtCacheSize",
+    "terminal");
   if (_initOracleClientArgs === undefined && !settings.thinDriverInitialized) {
     _initializeThinDriver();
   }
-
   const conn = new Connection();
   conn._impl = new impl.ConnectionImpl();
+
+  conn._impl._connectString = options.connectString;
+  conn._impl._user = options.user;
   await conn._impl.connect(options);
   if (_initOracleClientArgs === undefined) {
     settings.thinDriverInitialized = true;
@@ -760,7 +841,120 @@ async function shutdown(a1, a2) {
   await conn.close();
 }
 
+//-----------------------------------------------------------------------------
+// _checkConfigProvider()
+//
+// Look for the config provider in the connection string and retreives
+// object stored in the config Provider.
+// Returns object based on precedence between input object and the one retrieved
+// from Config Provider.
+//-----------------------------------------------------------------------------
+async function _checkConfigProvider(options) {
+  // Time for Cache entries to be deleted in milliseconds
+  const cacheEntriesDuration = settings.configProviderCacheTimeout * 1000;
+  let secondOpts;
+  const url = options.connectString || options.connectionString;
+  if (!url)
+    return options;
+
+  if (configProviderCache && configProviderCache.has(url) && ((Date.now() - configProviderCache.get(url).timeAdded) < cacheEntriesDuration)) {
+    const cacheOpts1 = configProviderCache.get(url).cacheOpts;
+    secondOpts = { ...cacheOpts1};
+
+    //deobfuscate password
+    if (secondOpts.password)
+      secondOpts.password = protocolUtil.getDeobfuscatedValue(secondOpts.password.value, secondOpts.password.obfuscatedValue);
+
+    //deobfuscate walletContent
+    if (secondOpts.walletContent)
+      secondOpts.walletContent = protocolUtil.getDeobfuscatedValue(secondOpts.walletContent.value, secondOpts.walletContent.obfuscatedValue);
+
+  } else {
+    let parsedUrl = url;
+    let urlExtendedPart;
+    const baseRegex = new RegExp("^config-(?<provider>[A-Za-z0-9]+)(://)(?<provider_arg>[^?]+)");
+    if (url.indexOf('?') != -1) {
+      parsedUrl = url.substring(0, url.indexOf('?'));
+      urlExtendedPart = url.substring(url.indexOf('?'), url.length); //extended part
+    }
+    const match = parsedUrl.match(baseRegex);
+    if (match) {
+      const provider = match.groups.provider;
+      const provider_arg = match.groups.provider_arg;
+      let configPckg;
+      try {
+        configPckg = require('./configProviders/' + provider);
+      } catch (err) {
+        errors.throwErr(errors.ERR_CONFIG_PROVIDER_NOT_SUPPORTED, provider);
+      }
+      const configProvider = new configPckg(provider_arg, urlExtendedPart);
+      try {
+        configProvider.init();
+      } catch (err) {
+        errors.throwErr(errors.ERR_CONFIG_PROVIDER_LOAD_FAILED, err.message);
+      }
+      try {
+        if (!configProviderCache) {
+          configProviderCache = new Map();
+        }
+        secondOpts = await configProvider.returnConfig();
+        // obfuscate password & walletcontent and store config in the cache
+        const cacheOpts = { ...secondOpts};
+        if (secondOpts.password)
+          cacheOpts.password = protocolUtil.setObfuscatedValue(secondOpts.password);
+        if (secondOpts.walletContent)
+          cacheOpts.walletContent = protocolUtil.setObfuscatedValue(secondOpts.walletContent);
+        configProviderCache.set(url, { cacheOpts, timeAdded: Date.now()});
+      } catch (err) {
+        errors.throwErr(errors.ERR_CONFIG_PROVIDER_FAILED_TO_RETRIEVE_CONFIG, err.message);
+      }
+    }
+  }
+  if (secondOpts) {
+    options = modifyOptionsPrecedence(secondOpts, options);
+  }
+  return options;
+}
+/**
+  * Sets precedence for different parameters in cloudConfig/userConfig
+  * @param {cloudConfig} object - object retreived from cloud
+  * @param {userConfig} object -  user input Object
+  */
+function modifyOptionsPrecedence(cloudConfig, userConfig) {
+  // create a copy of userConfig object
+  userConfig = { ...userConfig };
+  if (!userConfig.user)
+    userConfig.user = cloudConfig.user;
+  if (!userConfig.password)
+    userConfig.password = cloudConfig.password;
+  if (cloudConfig.connectString) {
+    userConfig.connectString = cloudConfig.connectString;
+    userConfig.connectionString = undefined;
+  }
+  if (cloudConfig.walletContent)
+    userConfig.walletContent = cloudConfig.walletContent;
+  if (cloudConfig.poolMin)
+    userConfig.poolMin = cloudConfig.poolMin;
+  if (cloudConfig.poolMax)
+    userConfig.poolMax = cloudConfig.poolMax;
+  if (cloudConfig.poolIncrement)
+    userConfig.poolIncrement = cloudConfig.poolIncrement;
+  if (cloudConfig.poolTimeout)
+    userConfig.poolTimeout = cloudConfig.poolTimeout;
+  if (cloudConfig.poolPingInterval)
+    userConfig.poolPingInterval = cloudConfig.poolPingInterval;
+  if (cloudConfig.poolPingTimeout)
+    userConfig.poolPingTimeout = cloudConfig.poolPingTimeout;
+  if (cloudConfig.stmtCacheSize)
+    userConfig.stmtCacheSize = cloudConfig.stmtCacheSize;
+  if (cloudConfig.prefetchRows)
+    userConfig.prefetchRows = cloudConfig.prefetchRows;
+  if (cloudConfig.lobPrefetch)
+    userConfig.lobPrefetch = cloudConfig.lobPrefetch;
+
+  return userConfig;
 
+}
 //-----------------------------------------------------------------------------
 // startup()
 //
@@ -826,12 +1020,13 @@ module.exports = {
   SodaOperation,
 
   // top-level functions
-  getConnection: nodbUtil.callbackify(getConnection),
-  createPool: nodbUtil.callbackify(createPool),
+  getConnection: nodbUtil.callbackify(nodbUtil.wrapFn(getConnection)),
+  createPool: nodbUtil.callbackify(nodbUtil.wrapFn(createPool)),
+  getNetworkServiceNames: nodbUtil.callbackify(nodbUtil.wrapFn(getNetworkServiceNames)),
   getPool,
   initOracleClient,
-  shutdown: nodbUtil.callbackify(shutdown),
-  startup: nodbUtil.callbackify(startup),
+  shutdown: nodbUtil.callbackify(nodbUtil.wrapFn(shutdown)),
+  startup: nodbUtil.callbackify(nodbUtil.wrapFn(startup)),
 
   // CQN operation codes
   CQN_OPCODE_ALL_OPS: constants.CQN_OPCODE_ALL_OPS,
@@ -1007,6 +1202,7 @@ module.exports = {
   VECTOR_FORMAT_FLOAT32: constants.VECTOR_FORMAT_FLOAT32,
   VECTOR_FORMAT_FLOAT64: constants.VECTOR_FORMAT_FLOAT64,
   VECTOR_FORMAT_INT8: constants.VECTOR_FORMAT_INT8,
+  VECTOR_FORMAT_BINARY: constants.VECTOR_FORMAT_BINARY,
 
   // database type aliases
   BLOB: types.DB_TYPE_BLOB,
@@ -1022,6 +1218,9 @@ module.exports = {
   ARRAY: constants.OUT_FORMAT_ARRAY,
   OBJECT: constants.OUT_FORMAT_OBJECT,
 
+  // Trace Interface
+  traceHandler,
+
   // Instances
   future,
 
@@ -1126,6 +1325,10 @@ module.exports = {
     return settings.stmtCacheSize;
   },
 
+  get configProviderCacheTimeout() {
+    return settings.configProviderCacheTimeout;
+  },
+
   get thin() {
     return settings.thin;
   },
@@ -1159,6 +1362,11 @@ module.exports = {
     settings.dbObjectAsPojo = value;
   },
 
+  set driverName(value) {
+    errors.assertPropValue(typeof value === 'string', "driverName");
+    settings.driverName = value;
+  },
+
   set edition(value) {
     errors.assertPropValue(typeof value === 'string', "edition");
     settings.edition = value;
@@ -1211,11 +1419,25 @@ module.exports = {
     settings.lobPrefetchSize = value;
   },
 
+  set machine(value) {
+    errors.assertPropValue(typeof value === 'string', "machine");
+    const sanitizedValue = nodbUtil.sanitize(value);
+    errors.assertPropValue(value == sanitizedValue, "machine");
+    settings.machine = value;
+  },
+
   set maxRows(value) {
     errors.assertPropValue(Number.isInteger(value) && value >= 0, "maxRows");
     settings.maxRows = value;
   },
 
+  set osUser(value) {
+    errors.assertPropValue(typeof value === 'string', "osUser");
+    const sanitizedValue = nodbUtil.sanitize(value);
+    errors.assertPropValue(value == sanitizedValue, "osUser");
+    settings.osUser = value;
+  },
+
   set outFormat(value) {
     if (value !== constants.OUT_FORMAT_ARRAY &&
         value !== constants.OUT_FORMAT_OBJECT) {
@@ -1270,10 +1492,27 @@ module.exports = {
     settings.prefetchRows = value;
   },
 
+  set program(value) {
+    errors.assertPropValue(typeof value === 'string', "program");
+    const sanitizedValue = nodbUtil.sanitize(value);
+    errors.assertPropValue(value == sanitizedValue, "program");
+    settings.program = value;
+  },
+
   set stmtCacheSize(value) {
     errors.assertPropValue(Number.isInteger(value) && value >= 0,
       "stmtCacheSize");
     settings.stmtCacheSize = value;
   },
 
+  set terminal(value) {
+    errors.assertPropValue(typeof value === 'string', "terminal");
+    settings.terminal = value;
+  },
+  set configProviderCacheTimeout(value) {
+    errors.assertPropValue(Number.isInteger(value) && value >= 0,
+      "configProviderCacheTimeout");
+    settings.configProviderCacheTimeout = value;
+  }
+
 };

package/lib/pool.js

@@ -423,7 +423,7 @@ class Pool extends EventEmitter {
       throw err;
     }
 
-    if (this._connectionsOut >= poolMax ||
+    while (this._connectionsOut >= poolMax ||
         this.status === constants.POOL_STATUS_RECONFIGURING) {
 
       // when the queue is huge, throw error early without waiting for queue
@@ -798,12 +798,21 @@ class Pool extends EventEmitter {
     return this._user;
   }
 
+  //---------------------------------------------------------------------------
+  // connectTraceConfig
+  //
+  // Property for getting the connection related config.
+  //---------------------------------------------------------------------------
+  get connectTraceConfig() {
+    return this._impl && this._impl._getConnectTraceConfig();
+  }
 }
 
-Pool.prototype.close = nodbUtil.callbackify(Pool.prototype.close);
-Pool.prototype.getConnection = nodbUtil.callbackify(Pool.prototype.getConnection);
-Pool.prototype.reconfigure = nodbUtil.callbackify(Pool.prototype.reconfigure);
-Pool.prototype.setAccessToken = nodbUtil.callbackify(Pool.prototype.setAccessToken);
+nodbUtil.wrapFns(Pool.prototype, false,
+  "close",
+  "getConnection",
+  "reconfigure",
+  "setAccessToken");
 
 // DEPRECATED aliases
 Pool.prototype.terminate = Pool.prototype.close;

package/lib/settings.js

@@ -59,6 +59,7 @@ class Settings {
     this.queueTimeout = 60000;
     this.queueMax = 500;
     this.stmtCacheSize = 30;
+    this.configProviderCacheTimeout = 86400;
     this.thin = true;
     this.thinDriverInitialized = false;
     this.createFetchTypeMap(this.fetchAsString, this.fetchAsBuffer);