orcaq 1.0.33 → 1.1.2

package/.output/server/node_modules/oracledb/lib/poolStatistics.js

@@ -0,0 +1,143 @@
+// Copyright (c) 2021, 2025, 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 process = require('process');
+const settings = require('./settings.js');
+
+//-----------------------------------------------------------------------------
+// class PoolStatistics
+//  collection of statistics metrics for Pool object
+//-----------------------------------------------------------------------------
+
+class PoolStatistics {
+
+  constructor(pool) {
+    let averageTimeInQueue = 0;
+
+    if (pool._totalRequestsEnqueued !== 0) {
+      averageTimeInQueue = Math.round(pool._totalTimeInQueue /
+        pool._totalRequestsEnqueued);
+    }
+
+    this.gatheredDate = Date.now ();
+    this.upTime = this.gatheredDate - pool._createdDate;
+    this.upTimeSinceReset = this.gatheredDate - pool._timeOfReset;
+    this.connectionRequests = pool._totalConnectionRequests;
+    this.requestsEnqueued = pool._totalRequestsEnqueued;
+    this.requestsDequeued = pool._totalRequestsDequeued;
+    this.failedRequests = pool._totalFailedRequests;
+    this.rejectedRequests = pool._totalRequestsRejected;
+    this.requestTimeouts = pool._totalRequestTimeouts;
+    this.maximumQueueLength = pool._maximumQueueLength;
+    this.currentQueueLength = pool._pendingRequestQueue.size;
+    this.timeInQueue = pool._totalTimeInQueue;
+    this.minimumTimeInQueue = pool._minTimeInQueue;
+    this.maximumTimeInQueue = pool._maxTimeInQueue;
+    this.averageTimeInQueue = averageTimeInQueue;
+    this.connectionsInUse = pool.connectionsInUse;
+    this.connectionsOpen = pool.connectionsOpen;
+    this.connectString = pool.connectString;
+    this.edition = pool.edition;
+    this.events = pool.events;
+    this.externalAuth = pool.externalAuth;
+    this.homogeneous = pool.homogeneous;
+    this.poolAlias = pool.poolAlias;
+    this.poolIncrement = pool.poolIncrement;
+    this.poolMax = pool.poolMax;
+    this.poolMaxPerShard = pool.poolMaxPerShard;
+    this.poolMin = pool.poolMin;
+    this.poolPingInterval = pool.poolPingInterval;
+    this.poolPingTimeout = pool.poolPingTimeout;
+    this.poolTimeout = pool.poolTimeout;
+    this.maxLifetimeSession = pool.maxLifetimeSession;
+    this.queueMax = pool.queueMax;
+    this.queueTimeout = pool.queueTimeout;
+    this.sodaMetaDataCache = pool.sodaMetaDataCache;
+    this.stmtCacheSize = pool.stmtCacheSize;
+    this.user = pool.user;
+    this.threadPoolSize = process.env.UV_THREADPOOL_SIZE;
+    this.thin = settings.thin;
+  }
+
+  //---------------------------------------------------------------------------
+  // logStatistics()
+  //
+  // To print the statistics metrics of the pool
+  //---------------------------------------------------------------------------
+  logStatistics() {
+    console.log('\nDriver:');
+    console.log('...thin mode:', this.thin);
+    console.log('Pool statistics:');
+    console.log('...gathered at:', new Date(this.gatheredDate).toISOString());
+    console.log('...up time (milliseconds):', this.upTime);
+    console.log('...up time from last reset (milliseconds)',
+      this.upTimeSinceReset);
+    console.log('...connection requests:', this.connectionRequests);
+    console.log('...requests enqueued:', this.requestsEnqueued);
+    console.log('...requests dequeued:', this.requestsDequeued);
+    console.log('...requests failed:', this.failedRequests);
+    console.log('...requests exceeding queueMax:', this.rejectedRequests);
+    console.log('...requests exceeding queueTimeout:', this.requestTimeouts);
+    console.log('...current queue length:', this.currentQueueLength);
+    console.log('...maximum queue length:', this.maximumQueueLength);
+    console.log('...sum of time in queue (milliseconds):', this.timeInQueue);
+    console.log('...minimum time in queue (milliseconds):',
+      this.minimumTimeInQueue);
+    console.log('...maximum time in queue (milliseconds):',
+      this.maximumTimeInQueue);
+    console.log('...average time in queue (milliseconds):',
+      this.averageTimeInQueue);
+    console.log('...pool connections in use:', this.connectionsInUse);
+    console.log('...pool connections open:', this.connectionsOpen);
+    console.log('Pool attributes:');
+    console.log('...connectString:', this.connectString);
+    console.log('...edition:', this.edition);
+    console.log('...events:', this.events);
+    console.log('...externalAuth:', this.externalAuth);
+    console.log('...homogeneous:', this.homogeneous);
+    console.log('...poolAlias:', this.poolAlias);
+    console.log('...poolIncrement:', this.poolIncrement);
+    console.log('...poolMax:', this.poolMax);
+    console.log('...poolMaxPerShard:', this.poolMaxPerShard);
+    console.log('...poolMin:', this.poolMin);
+    console.log('...poolPingInterval (seconds):', this.poolPingInterval);
+    console.log('...poolPingTimeout (milliseconds):', this.poolPingTimeout);
+    console.log('...poolTimeout (seconds):', this.poolTimeout);
+    console.log('...maxLifetimeSession (seconds):', this.maxLifetimeSession);
+    console.log('...queueMax:', this.queueMax);
+    console.log('...queueTimeout (milliseconds):', this.queueTimeout);
+    console.log('...sessionCallback:', this.sessionCallback);
+    console.log('...sodaMetaDataCache:', this.sodaMetaDataCache);
+    console.log('...stmtCacheSize:', this.stmtCacheSize);
+    console.log('...user:', this.user);
+    console.log('Related environment variables:');
+    console.log('...UV_THREADPOOL_SIZE:', this.threadPoolSize);
+  }
+}
+
+module.exports = PoolStatistics;

package/.output/server/node_modules/oracledb/lib/queryStream.js

@@ -0,0 +1,119 @@
+// Copyright (c) 2015, 2023, 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 process = require('process');
+const { Readable } = require('stream');
+
+class QueryStream extends Readable {
+
+  constructor(rs) {
+    super({ objectMode: true });
+    this._fetching = false;
+    this._numRows = 0;
+
+    // calling open via process.nextTick to allow event handlers to be
+    // registered prior to the events being emitted
+    if (rs) {
+      process.nextTick(() => {
+        this._open(rs);
+      });
+    }
+  }
+
+  // called by readable.destroy() and ensures that the result set is closed if
+  // it has not already been closed (never called directly)
+  async _destroy(err, cb) {
+    if (this._resultSet) {
+      const rs = this._resultSet;
+      this._resultSet = null;
+      if (this._fetching) {
+        await new Promise(resolve =>
+          this.once('_doneFetching', resolve));
+      }
+      try {
+        await rs._impl.close();
+      } catch (closeErr) {
+        cb(closeErr);
+        return;
+      }
+    }
+    cb(err);
+  }
+
+  // called when the query stream is to be associated with a result set; this
+  // takes place when the query stream if constructed (if a result set is known
+  // at that point) or by Connection.execute() when the result set is ready
+  _open(rs) {
+    this._resultSet = rs;
+
+    // trigger the event listener that may have been added in _read() now that
+    // the result set is ready
+    this.emit('open');
+
+    // emit a metadata event as a convenience to users
+    this.emit('metadata', rs.metaData);
+  }
+
+  // called by readable.read() and pushes rows to the internal queue maintained
+  // by the stream implementation (never called directly) appropriate
+  async _read() {
+
+    // still waiting on the result set to be added via _open() so add an event
+    // listener to retry when ready
+    if (!this._resultSet) {
+      this.once('open', this._read);
+      return;
+    }
+
+    // using the JS getRow() to leverage the JS row cache; the result set's
+    // _allowGetRowCall is set to true to allow the call for query streams
+    // created via ResultSet.toQueryStream()
+    try {
+      this._fetching = true;
+      this._resultSet._allowGetRowCall = true;
+      const row = await this._resultSet.getRow();
+      if (row) {
+        this.push(row);
+      } else {
+        this.push(null);
+      }
+    } catch (err) {
+      this.destroy(err);
+    } finally {
+      this._fetching = false;
+      if (this._resultSet) {
+        this._resultSet._allowGetRowCall = false;
+      } else {
+        this.emit('_doneFetching');
+      }
+    }
+  }
+
+}
+
+module.exports = QueryStream;

package/.output/server/node_modules/oracledb/lib/resultset.js

@@ -0,0 +1,368 @@
+// Copyright (c) 2016, 2023, 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 QueryStream = require('./queryStream.js');
+const BaseDbObject = require('./dbObject.js');
+const nodbUtil = require('./util.js');
+const constants = require('./constants.js');
+const Lob = require('./lob.js');
+const errors = require('./errors.js');
+
+class ResultSet {
+
+  constructor() {
+    this._rowCache = [];
+    this._processingStarted = false;
+    this._convertedToStream = false;
+    this._allowGetRowCall = false;
+    this._isActive = false;
+  }
+
+  //---------------------------------------------------------------------------
+  // _getAllRows()
+  //
+  // Return all of the rows in the result set.
+  //---------------------------------------------------------------------------
+  async _getAllRows() {
+
+    try {
+
+      // retain initial values of the maximum number of rows to fetch and the
+      // number of rows to fetch from the database at a single time
+      let maxRows = this._impl.maxRows;
+      let fetchArraySize = this._impl.fetchArraySize;
+
+      // fetch all rows
+      let rowsFetched = [];
+      while (true) {    // eslint-disable-line
+        if (maxRows > 0 && fetchArraySize >= maxRows) {
+          fetchArraySize = maxRows;
+        }
+        const rows = await this._getRows(fetchArraySize);
+        if (rows) {
+          await this._processRows(rows, true);
+          rowsFetched = rowsFetched.concat(rows);
+        }
+        if (rows.length == maxRows || rows.length < fetchArraySize) {
+          break;
+        }
+        if (maxRows > 0) {
+          maxRows -= rows.length;
+        }
+      }
+
+      return rowsFetched;
+
+    } finally {
+      await this._impl.close();
+      delete this._impl;
+    }
+
+  }
+
+  //---------------------------------------------------------------------------
+  // _getRows()
+  //
+  // Return up to the specified number of rows from the result set. If nested
+  // cursors are possible, setup the execute options so that they can be
+  // examined within the implementation's setup routine.
+  //---------------------------------------------------------------------------
+  async _getRows(numRows) {
+    let options = {};
+    if (this._impl.nestedCursorIndices.length > 0) {
+      options = {
+        connection: this._connection,
+        outFormat: this._impl.outFormat,
+        fetchArraySize: this._impl.fetchArraySize,
+        dbObjectAsPojo: this._impl.dbObjectAsPojo,
+        maxRows: this._impl.maxRows,
+        fetchTypeMap: this._impl.fetchTypeMap
+      };
+    }
+    return await this._impl.getRows(numRows, options);
+  }
+
+  //---------------------------------------------------------------------------
+  // _processRows()
+  //
+  // Process rows returned by the implementation. This will transform result
+  // set and LOB implementations into user facing objects. It will also perform
+  // any fetched that are needed (if a result set is undesirable)
+  //---------------------------------------------------------------------------
+  async _processRows(rows, expandNestedCursors) {
+
+    // transform any nested cursors into user facing objects
+    for (const i of this._impl.nestedCursorIndices) {
+      for (let j = 0; j < rows.length; j++) {
+        const val = rows[j][i];
+        if (val) {
+          const resultSet = new ResultSet();
+          resultSet._setup(this._connection, val);
+          this._impl.metaData[i].metaData = val.metaData;
+          if (expandNestedCursors) {
+            rows[j][i] = await resultSet._getAllRows();
+          } else {
+            rows[j][i] = resultSet;
+          }
+        }
+      }
+    }
+
+    // transform any LOBs into user facing objects
+    for (const i of this._impl.lobIndices) {
+      for (let j = 0; j < rows.length; j++) {
+        const val = rows[j][i];
+        if (val) {
+          const lob = rows[j][i] = new Lob();
+          lob._setup(val, true);
+        }
+      }
+    }
+
+    // transform any database objects into user facing objects
+    for (const i of this._impl.dbObjectIndices) {
+      const dbObjectClass = this._impl.metaData[i].dbTypeClass;
+      for (let j = 0; j < rows.length; j++) {
+        const val = rows[j][i];
+        if (val) {
+          const obj = rows[j][i] = Object.create(dbObjectClass.prototype);
+          obj._impl = val;
+          if (this._impl.dbObjectAsPojo) {
+            rows[j][i] = obj._toPojo();
+          } else if (obj.isCollection) {
+            rows[j][i] = new Proxy(obj, BaseDbObject._collectionProxyHandler);
+          }
+        }
+      }
+    }
+
+    // run any conversion functions, if applicable
+    // NOTE: we mark the connection as no longer in progress before making
+    // calls to the converter function; this is needed to allow calls against
+    // the database (like getting LOB data) to succeed, as this code is running
+    // in the middle of a call to connection.execute() or resultSet.getRows()
+    for (const i of this._impl.converterIndices) {
+      const fn = this._impl.metaData[i].converter;
+      this._connection._impl._inProgress = false;
+      try {
+        for (let j = 0; j < rows.length; j++) {
+          let result = fn(rows[j][i]);
+          if (result instanceof Promise) {
+            result = await result;
+          }
+          rows[j][i] = result;
+        }
+      } finally {
+        this._connection._impl._inProgress = true;
+      }
+    }
+
+    // create objects, if desired
+    if (this._impl.outFormat === constants.OUT_FORMAT_OBJECT) {
+      for (let i = 0; i < rows.length; i++) {
+        const origRow = rows[i];
+        const newRow = rows[i] = {};
+        const metaData = this._impl.metaData;
+        for (let j = 0; j < metaData.length; j++) {
+          newRow[metaData[j].name] = origRow[j];
+        }
+      }
+    }
+
+  }
+
+  //---------------------------------------------------------------------------
+  // _setup()
+  //
+  // Setup a result set.
+  // ---------------------------------------------------------------------------
+  _setup(connection, resultSetImpl) {
+    this._connection = connection;
+    this._impl = resultSetImpl;
+  }
+
+  //---------------------------------------------------------------------------
+  // close()
+  //
+  // Close the result set and make it unusable for further operations.
+  //---------------------------------------------------------------------------
+  async close() {
+    errors.assertArgCount(arguments, 0, 0);
+    errors.assert(this._impl && this._connection._impl, errors.ERR_INVALID_RS);
+
+    if (this._convertedToStream) {
+      errors.throwErr(errors.ERR_CANNOT_INVOKE_RS_METHODS);
+    }
+
+    this._processingStarted = true;
+    const resultSetImpl = this._impl;
+    delete this._impl;
+    await resultSetImpl.close();
+  }
+
+  //---------------------------------------------------------------------------
+  // getRow()
+  //
+  // Returns a single row to the caller from the result set, if one is
+  // available. Rows are buffered in a JavaScript array in order to avoid trips
+  // through the thread pool that would be required if implemented in C.
+  //---------------------------------------------------------------------------
+  async getRow() {
+    errors.assertArgCount(arguments, 0, 0);
+    errors.assert(this._impl && this._connection._impl, errors.ERR_INVALID_RS);
+
+    if (this._convertedToStream && !this._allowGetRowCall) {
+      errors.throwErr(errors.ERR_CANNOT_INVOKE_RS_METHODS);
+    }
+
+    this._allowGetRowCall = false;
+    this._processingStarted = true;
+
+    if (this._rowCache.length == 0) {
+      const rows = await this._getRows(this._impl.fetchArraySize);
+      await this._processRows(rows, false);
+      this._rowCache = rows;
+    }
+    return this._rowCache.shift();
+  }
+
+  //---------------------------------------------------------------------------
+  // getRows()
+  //
+  // Check to see if any rows are in the JS buffer (which could result from
+  // interspersed calls to getRow() and getRows()). If no rows are in the
+  // buffer, the call is just proxied to the implementation layer. Otherwise,
+  // rows are pulled from the buffer and potentially concatenated with rows
+  // from calls to the implementation's getRows().
+  //---------------------------------------------------------------------------
+  async getRows(numRows) {
+    let rowsNeeded;
+
+    errors.assertArgCount(arguments, 0, 1);
+    errors.assert(this._impl && this._connection._impl, errors.ERR_INVALID_RS);
+
+    if (arguments.length == 0) {
+      numRows = 0;
+    } else {
+      errors.assertParamValue(Number.isInteger(numRows) && numRows >= 0, 1);
+    }
+
+    if (this._convertedToStream) {
+      errors.throwErr(errors.ERR_CANNOT_INVOKE_RS_METHODS);
+    }
+
+    this._processingStarted = true;
+
+    let requestedRows;
+    if (numRows == 0) {
+      requestedRows = this._rowCache;
+      const fetchArraySize = this._impl.fetchArraySize;
+      while (true) {  // eslint-disable-line
+        const rows = await this._getRows(fetchArraySize);
+        if (rows) {
+          await this._processRows(rows, false);
+          requestedRows = requestedRows.concat(rows);
+        }
+        if (rows.length < fetchArraySize)
+          break;
+      }
+      return requestedRows;
+    }
+
+    if (this._rowCache.length === 0) {
+      requestedRows = await this._getRows(numRows);
+      await this._processRows(requestedRows, false);
+    } else {
+      rowsNeeded = numRows - this._rowCache.length;
+      if (rowsNeeded <= 0) {
+        requestedRows = this._rowCache.splice(0, numRows);
+      } else {
+        const rows = await this._getRows(rowsNeeded);
+        await this._processRows(rows, false);
+        requestedRows = this._rowCache.concat(rows);
+        this._rowCache = [];
+      }
+    }
+
+    return requestedRows;
+  }
+
+  //---------------------------------------------------------------------------
+  // metaData()
+  //
+  // Property returning the metadata associated with the result set.
+  //---------------------------------------------------------------------------
+  get metaData() {
+    if (this._impl) {
+      return this._impl.metaData;
+    }
+    return undefined;
+  }
+
+  //---------------------------------------------------------------------------
+  // toQueryStream()
+  //
+  // Converts a result set to a QueryStream object.
+  //---------------------------------------------------------------------------
+  toQueryStream() {
+    errors.assertArgCount(arguments, 0, 0);
+
+    if (this._processingStarted) {
+      errors.throwErr(errors.ERR_CANNOT_CONVERT_RS_TO_STREAM);
+    }
+
+    if (this._convertedToStream) {
+      errors.throwErr(errors.ERR_RS_ALREADY_CONVERTED);
+    }
+
+    this._convertedToStream = true;
+
+    return new QueryStream(this);
+  }
+
+  [Symbol.asyncIterator]() {
+    const resultSet = this;
+    return {
+      async next() {
+        const row = await resultSet.getRow();
+        return {value: row, done: row === undefined};
+      },
+      return() {
+        return {done: true};
+      }
+    };
+  }
+
+}
+
+nodbUtil.wrapFns(ResultSet.prototype, errors.ERR_BUSY_RS,
+  "close",
+  "getRow",
+  "getRows");
+
+module.exports = ResultSet;