Release 5.3.0

Author: Roman Balayan

README.md

@@ -1,26 +1,27 @@
 # node-oracledb-prebuilt-for-lambda
 
  - This module is forked from the currently un-maintained [node-oracledb-for-lambda](https://github.com/nalbion/node-oracledb-for-lambda).
- - Core oracledb libraries are derived from [node-oracledb](https://github.com/oracle/node-oracledb) v5.2.0
- - 5.2.0: Prebuilt for use with AWS Lambda nodejs12.x Runtime (Built using nodejsv12.18.3)
+ - Core oracledb libraries are derived from [node-oracledb](https://github.com/oracle/node-oracledb) v5.3.0
+ - 5.3.0: Prebuilt for use with AWS Lambda nodejs12.x Runtime (Built using nodejsv12.18.3)
  - Also tested to work with AWS Lambda nodejs14.x Runtime
 
 The scripts to reproduce the build process can be found at [node-oracledb-lambda-test](https://github.com/romanbalayan/node-oracledb-lambda-test). 
 
 # Usage
 
 ```bash
-npm install --save oracledb-prebuilt-for-lambda@5.2.0
+npm install --save oracledb-prebuilt-for-lambda@5.3.0
 ```
 
 # Versioning
  - Changed release version to match that of underlying node-oracledb version. 
- - i.e. for release based on oracledb 5.2.0, release will be oracledb-prebuilt-for-lambda@5.2.0
+ - i.e. for release based on oracledb 5.3.0, release will be oracledb-prebuilt-for-lambda@5.3.0
 
 
  # Releases
  | node-oracledb       | oracledb-prebuilt-for-lambda    |
  | ------------------- | ---------- |
+ | 5.3.0               | 5.3.0      |
  | 5.2.0               | 5.2.0      |
  | 5.1.0               | 5.1.0      |
  | 5.0.0               | 5.0.0      |
@@ -30,6 +31,7 @@ npm install --save oracledb-prebuilt-for-lambda@5.2.0
 
 
  # Changelog
+ - v5.3.0: [node-oracledb v5.3.0 changelog](https://github.com/oracle/node-oracledb/blob/main/CHANGELOG.md#node-oracledb-v530-22-oct-2021)
  - v5.2.0: [node-oracledb v5.2.0 changelog](https://github.com/oracle/node-oracledb/blob/main/CHANGELOG.md#node-oracledb-v520-7-jun-2021)
  - v5.1.0: [node-oracledb v5.1.0 changelog](https://github.com/oracle/node-oracledb/blob/master/CHANGELOG.md#node-oracledb-v510-8-dec-2020)
  - v5.0.0: [node-oracledb v5.0.0 changelog](https://github.com/oracle/node-oracledb/blob/master/CHANGELOG.md#node-oracledb-v500-29-jun-2020)

build/Release/oracledb.node

@@ -314,6 +314,145 @@ function buildDbObjectClass(schema, name, fqn) {
   return (DbObject);
 }
 
+//-----------------------------------------------------------------------------
+//  tpcBegin()
+//    Starts a two-phase-commit transaction
+//----------------------------------------------------------------------------
+async function tpcBegin(xid, flag, timeout) {
+  nodbUtil.checkArgCount(arguments, 1, 3);
+  nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1);
+
+  if (arguments.length < 3) {
+    timeout = 60;   // seconds
+  } else {
+    nodbUtil.assert(typeof timeout === 'number', 'NJS-005', 3);
+  }
+
+  if (arguments.length < 2) {
+    flag = this._oracledb.TPC_BEGIN_NEW;
+  } else {
+    nodbUtil.assert(typeof flag === 'number', 'NJS-005', 2);
+  }
+  await this._tpcBegin(xid, flag, timeout);
+}
+
+
+//-----------------------------------------------------------------------------
+//  tpcCommit
+//    Commit the two-phase-commit transaction
+//-----------------------------------------------------------------------------
+async function tpcCommit(xid, onePhase) {
+  nodbUtil.checkArgCount(arguments, 0, 2);
+
+  if (arguments.length < 2) {
+    onePhase = false;
+  } else {
+    nodbUtil.assert(typeof onePhase === 'boolean', 'NJS-005', 2);
+  }
+  if (arguments.length >= 1) {
+    nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1);
+  }
+  await this._tpcCommit(xid, onePhase);
+}
+
+
+//-----------------------------------------------------------------------------
+//  tpcEnd
+//    Ends the two-phase-commit transaction
+//-----------------------------------------------------------------------------
+async function tpcEnd(xid, flag) {
+  nodbUtil.checkArgCount(arguments, 0, 2);
+
+  if (arguments.length < 2) {
+    flag = this._oracledb.TPC_END_NORMAL;
+  } else {
+    nodbUtil.assert(typeof flag === 'number', 'NJS-005', 2);
+  }
+
+  if (arguments.length >= 1) {
+    nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1);
+  }
+
+  await this._tpcEnd(xid, flag);
+}
+
+
+//-----------------------------------------------------------------------------
+//  tpcForget
+//    causes the server to forget a heuristically completed global transaction.
+//-----------------------------------------------------------------------------
+async function tpcForget(xid) {
+
+  nodbUtil.checkArgCount(arguments, 1, 1);
+  nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1);
+
+  await this._tpcForget(xid);
+}
+
+
+//-----------------------------------------------------------------------------
+//  tpcPrepare
+//    prepares a global transaction for commit.
+//-----------------------------------------------------------------------------
+async function tpcPrepare(xid) {
+  nodbUtil.checkArgCount(arguments, 0, 1);
+
+  if (arguments.length >= 1) {
+    nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1);
+  }
+
+  return await this._tpcPrepare(xid);
+}
+
+
+//-----------------------------------------------------------------------------
+//  tpcRecover
+//    Returns a list of pending transactions
+//-----------------------------------------------------------------------------
+async function tpcRecover(asString) {
+  nodbUtil.checkArgCount(arguments, 0, 1);
+
+  if (arguments.length == 1) {
+    nodbUtil.assert(typeof asString === 'boolean', 'NJS-005', 1);
+  } else {
+    asString = true;
+  }
+
+  const sqlStr = `
+    SELECT
+        formatid as "formatId",
+        UTL_RAW.CAST_TO_VARCHAR2(globalid) as "globalTransactionId",
+        UTL_RAW.CAST_TO_VARCHAR2(branchid) as "branchQualifier"
+    FROM DBA_PENDING_TRANSACTIONS`;
+  const sqlBuf = `
+    SELECT
+        formatid as "formatId",
+        globalid as "globalTransactionId",
+        branchid as "branchQualifier"
+    FROM DBA_PENDING_TRANSACTIONS`;
+  const options = {
+    outFormat: this._oracledb.OUT_FORMAT_OBJECT,
+  };
+
+  const result = await this._execute(asString ? sqlStr : sqlBuf, {}, options);
+  return result.resultSet._getAllRows(options, result.metaData, false);
+}
+
+
+//-----------------------------------------------------------------------------
+//  tpcRollback()
+//    Rollbacks the current changes in two-phase-commit
+//-----------------------------------------------------------------------------
+async function tpcRollback(xid) {
+  nodbUtil.checkArgCount(arguments, 0, 1);
+  if (arguments.length == 1) {
+    nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1);
+  }
+
+  await this._tpcRollback(xid);
+}
+
+
 
 // define class
 class Connection extends EventEmitter {
@@ -344,6 +483,13 @@ class Connection extends EventEmitter {
     this.shutdown = nodbUtil.callbackify(nodbUtil.serialize(shutdown));
     this.startup = nodbUtil.callbackify(nodbUtil.serialize(startup));
     this.subscribe = nodbUtil.callbackify(nodbUtil.serialize(subscribe));
+    this.tpcBegin = nodbUtil.callbackify(nodbUtil.serialize(tpcBegin));
+    this.tpcCommit = nodbUtil.callbackify(nodbUtil.serialize(tpcCommit));
+    this.tpcEnd = nodbUtil.callbackify(nodbUtil.serialize(tpcEnd));
+    this.tpcForget = nodbUtil.callbackify(nodbUtil.serialize(tpcForget));
+    this.tpcPrepare = nodbUtil.callbackify(nodbUtil.serialize(tpcPrepare));
+    this.tpcRecover = nodbUtil.callbackify(nodbUtil.serialize(tpcRecover));
+    this.tpcRollback = nodbUtil.callbackify(nodbUtil.serialize(tpcRollback));
     this.unsubscribe = nodbUtil.callbackify(nodbUtil.serialize(unsubscribe));
   }
 

lib/connection.js

@@ -43,6 +43,7 @@ const BaseDbObject = require('./dbObject.js');
 const Connection = require('./connection.js');
 const Lob = require('./lob.js');
 const Pool = require('./pool.js');
+const PoolStatistics = require('./poolStatistics.js');
 const ResultSet = require('./resultset.js');
 const SodaDatabase = require('./sodaDatabase.js');
 const SodaCollection = require('./sodaCollection.js');
@@ -99,11 +100,11 @@ class OracleDb {
   }
 
   // extend class with promisified functions
-  _extend() {
-    this.getConnection = nodbUtil.callbackify(getConnection);
-    this.createPool = nodbUtil.callbackify(createPool);
-    this.shutdown = nodbUtil.callbackify(shutdown);
-    this.startup = nodbUtil.callbackify(startup);
+  _extend(_oracledb) {
+    this.getConnection = nodbUtil.callbackify(getConnection).bind(_oracledb);
+    this.createPool = nodbUtil.callbackify(createPool).bind(_oracledb);
+    this.shutdown = nodbUtil.callbackify(shutdown).bind(_oracledb);
+    this.startup = nodbUtil.callbackify(startup).bind(_oracledb);
   }
 
   // temporary method for determining if an object is a date until
@@ -380,6 +381,7 @@ proto.BaseDbObject = BaseDbObject;
 proto.Connection = Connection;
 proto.Lob = Lob;
 proto.Pool = Pool;
+proto.PoolStatistics = PoolStatistics;
 proto.ResultSet = ResultSet;
 proto.SodaDatabase = SodaDatabase;
 proto.SodaCollection = SodaCollection;

lib/oracledb.js

@@ -22,6 +22,8 @@
 const EventEmitter = require('events');
 const nodbUtil = require('./util.js');
 const util = require('util');
+const PoolStatistics = require('./poolStatistics.js');
+
 
 //-----------------------------------------------------------------------------
 // _checkRequestQueue()
@@ -328,44 +330,7 @@ function logStatistics() {
   if (stats === null) {
     throw new Error(nodbUtil.getErrorMessage('NJS-083'));
   }
-
-  console.log('\nPool statistics:');
-  console.log('...gathered at:', new Date(stats.gatheredDate).toISOString());
-  console.log('...up time (milliseconds):', stats.upTime);
-  console.log('...up time from last reset (milliseconds)',
-    stats.upTimeSinceReset);
-  console.log('...connection requests:', stats.connectionRequests);
-  console.log('...requests enqueued:', stats.requestsEnqueued);
-  console.log('...requests dequeued:', stats.requestsDequeued);
-  console.log('...requests failed:', stats.failedRequests);
-  console.log('...requests exceeding queueMax:', stats.rejectedRequests);
-  console.log('...requests exceeding queueTimeout:', stats.requestTimeouts);
-  console.log('...current queue length:', stats.currentQueueLength);
-  console.log('...maximum queue length:', stats.maximumQueueLength);
-  console.log('...sum of time in queue (milliseconds):', stats.timeInQueue);
-  console.log('...minimum time in queue (milliseconds):',
-    stats.minimumTimeInQueue);
-  console.log('...maximum time in queue (milliseconds):',
-    stats.maximumTimeInQueue);
-  console.log('...average time in queue (milliseconds):',
-    stats.averageTimeInQueue);
-  console.log('...pool connections in use:', stats.connectionsInUse);
-  console.log('...pool connections open:', stats.connectionsOpen);
-  console.log('Pool attributes:');
-  console.log('...poolAlias:', stats.poolAlias);
-  console.log('...queueMax:', stats.queueMax);
-  console.log('...queueTimeout (milliseconds):', stats.queueTimeout);
-  console.log('...poolMin:', stats.poolMin);
-  console.log('...poolMax:', stats.poolMax);
-  console.log('...poolIncrement:', stats.poolIncrement);
-  console.log('...poolTimeout (seconds):', stats.poolTimeout);
-  console.log('...poolPingInterval (seconds):', stats.poolPingInterval);
-  console.log('...poolMaxPerShard:', stats.poolMaxPerShard);
-  console.log('...sessionCallback:', stats.sessionCallback);
-  console.log('...stmtCacheSize:', stats.stmtCacheSize);
-  console.log('...sodaMetaDataCache:', stats.sodaMetaDataCache);
-  console.log('Related environment variables:');
-  console.log('...UV_THREADPOOL_SIZE:', stats.threadPoolSize);
+  stats.logStatistics();
 }
 
 
@@ -375,54 +340,12 @@ function logStatistics() {
 //  properties
 //-----------------------------------------------------------------------------
 function getStatistics() {
-  let averageTimeInQueue;
-  let stats = { };
-
-  // if the pool is not OPEN, throw appropriate err
   this._checkPoolOpen(false);
 
   if (this._enableStatistics !== true) {
     return null;
   }
-
-  averageTimeInQueue = 0;
-
-  if (this._totalRequestsEnqueued !== 0) {
-    averageTimeInQueue = Math.round(this._totalTimeInQueue /
-        this._totalRequestsEnqueued);
-  }
-
-  stats.gatheredDate = Date.now ();
-  stats.upTime = stats.gatheredDate - this._createdDate;
-  stats.upTimeSinceReset = stats.gatheredDate - this._timeOfReset;
-  stats.connectionRequests = this._totalConnectionRequests;
-  stats.requestsEnqueued = this._totalRequestsEnqueued;
-  stats.requestsDequeued = this._totalRequestsDequeued;
-  stats.failedRequests = this._totalFailedRequests;
-  stats.rejectedRequests = this._totalRequestsRejected;
-  stats.requestTimeouts = this._totalRequestTimeouts;
-  stats.maximumQueueLength = this._maximumQueueLength;
-  stats.currentQueueLength = this._connRequestQueue.length;
-  stats.timeInQueue = this._totalTimeInQueue;
-  stats.minimumTimeInQueue = this._minTimeInQueue;
-  stats.maximumTimeInQueue = this._maxTimeInQueue;
-  stats.averageTimeInQueue = averageTimeInQueue;
-  stats.connectionsInUse = this.connectionsInUse;
-  stats.connectionsOpen = this.connectionsOpen;
-  stats.poolAlias = this.poolAlias;
-  stats.queueMax = this.queueMax;
-  stats.queueTimeout = this.queueTimeout;
-  stats.poolMin = this.poolMin;
-  stats.poolMax = this.poolMax;
-  stats.poolIncrement = this.poolIncrement;
-  stats.poolTimeout = this.poolTimeout;
-  stats.poolPingInterval = this.poolPingInterval;
-  stats.poolMaxPerShard = this.poolMaxPerShard;
-  stats.stmtCacheSize = this.stmtCacheSize;
-  stats.sodaMetaDataCache = this.sodaMetaDataCache;
-  stats.threadPoolSize = process.env.UV_THREADPOOL_SIZE;
-
-  return stats;
+  return new PoolStatistics(this);
 }
 
 
@@ -467,6 +390,35 @@ function _setup(poolAttrs, poolAlias, oracledb) {
       this._sessionCallback = poolAttrs.sessionCallback;
   }
 
+  // Properties - edition, events, externalAuth - values can be set globally
+  // on oracledb and can be overridden at pool creation time.
+  if (typeof poolAttrs.edition !== 'undefined') {
+    this.edition = poolAttrs.edition;
+  } else {
+    this.edition = oracledb.edition;
+  }
+
+  if (typeof poolAttrs.events !== 'undefined') {
+    this.events = poolAttrs.events;
+  } else {
+    this.events = oracledb.events;
+  }
+
+  if (typeof poolAttrs.externalAuth !== 'undefined') {
+    this.externalAuth = poolAttrs.externalAuth;
+  } else {
+    this.externalAuth = oracledb.externalAuth;
+  }
+
+  // Properties - homogeneous, user, connectString - are NOT global properties
+  if (typeof poolAttrs.homogeneous !== 'undefined') {
+    this.homogeneous = poolAttrs.homogeneous;
+  } else {
+    this.homogeneous = true;
+  }
+  this.user = poolAttrs.user || poolAttrs.userName;
+  this.connectString = poolAttrs.connectString || poolAttrs.connectionString;
+
   // register event handler for when request queue should be checked
   this.on('_checkRequestQueue', this._checkRequestQueue);