orcaq 1.0.32 → 1.1.1

package/.output/server/node_modules/oracledb/lib/thin/statementCache.js

@@ -0,0 +1,195 @@
+// Copyright (c) 2024, 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.
+//
+// Node file defining the StatementCache class used to manage cached statements
+//-----------------------------------------------------------------------------
+
+const errors = require("../errors.js");
+const { Statement } = require("./statement");
+
+class StatementCache {
+  constructor(maxSize) {
+    this._cachedStatements = new Map();
+    this._maxSize = maxSize;
+    this._cursorsToClose = new Set();
+    this._openCursors = new Set();
+  }
+
+  //---------------------------------------------------------------------------
+  // _addCursorToClose()
+  //
+  // Add the statement's cursor to the list of cursors that need to be closed.
+  //---------------------------------------------------------------------------
+  _addCursorToClose(statement) {
+    if (this._cursorsToClose.has(statement.cursorId)) {
+      const reason = `attempt to close cursor ${statement.cursorId} twice`;
+      errors.throwErr(errors.ERR_INTERNAL, reason);
+    }
+    if (statement.cursorId != 0) {
+      this._cursorsToClose.add(statement.cursorId);
+    }
+    this._openCursors.delete(statement);
+  }
+
+  //---------------------------------------------------------------------------
+  // _adjustCache()
+  // Adjust the cache so that no more than the maximum number of statements
+  // are cached by removing least recently used statements
+  //---------------------------------------------------------------------------
+  _adjustCache() {
+    while (this._cachedStatements.size > this._maxSize) {
+      const sql = this._cachedStatements.keys().next().value;
+      const stmt = this._cachedStatements.get(sql);
+      this._cachedStatements.delete(sql);
+      if (stmt.inUse) {
+        stmt.returnToCache = false;
+      } else if (stmt.cursorId !== 0) {
+        this._addCursorToClose(stmt);
+      }
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  //clearCursors() {
+  // Clears the list of open cursors and removes the list of cursors that
+  // need to be closed. This is required when a DRCP session change has
+  // taken place as the cursor ID values are invalidated.
+  //---------------------------------------------------------------------------
+  clearCursors() {
+    const newOpenCursors = new Set();
+    for (const stmt of this._openCursors) {
+      if (stmt.inUse || stmt.returnToCache) {
+        stmt.pendingClear = true;
+        newOpenCursors.add(stmt);
+      }
+      stmt._clearState();
+    }
+    this._openCursors = newOpenCursors;
+    this._cursorsToClose.clear();
+  }
+
+  //---------------------------------------------------------------------------
+  //clearPendingState() {
+  // Clears state for statment with pending clear flag set and not in use.
+  // This will clear all state for open cursors.
+  // Called after rows processing is completed.
+  //---------------------------------------------------------------------------
+  clearPendingStatus() {
+    for (const stmt of this._openCursors) {
+      if (stmt.pendingClear && !stmt.inUse) {
+        stmt._clearAllState();
+        stmt.pendingClear = false;
+      }
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // get_statement()
+  // Get a statement from the statement cache, or prepare a new statement
+  // for use. If a statement is already in use or the statement is not
+  // supposed to be cached, a copy will be made (and not returned to the
+  // cache).
+  //---------------------------------------------------------------------------
+  getStatement(sql, cacheStatement = false, forceNew = false) {
+    let stmt = null;
+    if (sql) {
+      stmt = this._cachedStatements.get(sql);
+    }
+    if (!stmt) {
+      stmt = new Statement();
+      if (sql) {
+        stmt._prepare(sql);
+      }
+      if (cacheStatement && !stmt.isDdl && this._maxSize > 0) {
+        stmt.returnToCache = true;
+        this._cachedStatements.set(sql, stmt);
+        this._adjustCache();
+      }
+      this._openCursors.add(stmt);
+    } else if (forceNew || stmt.inUse) {
+      if (!cacheStatement) {
+        this._addCursorToClose(stmt);
+        this._cachedStatements.delete(sql);
+      }
+      stmt = stmt._copy();
+      this._openCursors.add(stmt);
+    } else if (!cacheStatement) {
+      this._cachedStatements.delete(sql);
+      stmt.returnToCache = false;
+    } else {
+      this._cachedStatements.delete(sql);
+      this._cachedStatements.set(sql, stmt);
+    }
+    this._openCursors.add(stmt);
+    stmt.inUse = true;
+    return stmt;
+  }
+
+  clearCursor(statement) {
+    this._addCursorToClose(statement);
+    statement.cursorId = 0;
+  }
+
+  //---------------------------------------------------------------------------
+  // returnStatement()
+  // Return the statement to the statement cache, if applicable. If the
+  // statement must not be returned to the statement cache, add the cursor
+  // id to the list of cursor ids to close on the next round trip to the
+  // database. Clear all bind variables and fetch variables in order to
+  // ensure that unnecessary references are not retained.
+  //---------------------------------------------------------------------------
+  returnStatement(statement) {
+    if (statement.bindInfoList) {
+      statement.bindInfoList.forEach(bindInfo => {
+        bindInfo.bindVar = null;
+      });
+    }
+    if (statement.queryVars) {
+      statement.queryVars.forEach(queryVar => {
+        queryVar.values.fill(null);
+      });
+    }
+    if (statement.returnToCache) {
+      statement.inUse = false;
+    } else {
+      this._addCursorToClose(statement);
+    }
+    // clear all state for statement which is having flag set and not in use
+    this.clearPendingStatus();
+  }
+
+  //---------------------------------------------------------------------------
+  // writeCursorsToClose()
+  // Write the list of cursors to close to the buffer.
+  //---------------------------------------------------------------------------
+  writeCursorsToClose(buf) {
+    buf.writeUB4(this._cursorsToClose.size);
+    for (const cursorNum of this._cursorsToClose.keys()) {
+      buf.writeUB4(cursorNum);
+    }
+    this._cursorsToClose.clear();
+  }
+}
+
+module.exports = StatementCache;

package/.output/server/node_modules/oracledb/lib/thin/util.js

@@ -0,0 +1,254 @@
+// Copyright (c) 2022, 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 constants = require('../constants');
+const errors = require('../errors.js');
+const os = require('os');
+const nodbUtil = require('../util.js');
+
+//---------------------------------------------------------------------------
+// populateClientInfo()
+//
+// Populates client process information
+//---------------------------------------------------------------------------
+function populateClientInfo() {
+  this.program = nodbUtil.sanitize(process.argv0);
+  this.terminal = "unknown";
+  this.pid = process.pid.toString();
+  try {
+    this.userName = nodbUtil.sanitize(os.userInfo().username);
+  } catch {
+    this.userName = "unknown";
+  }
+  this.hostName = nodbUtil.sanitize(os.hostname());
+}
+// Initialize client data on startup.
+const CLIENT_INFO = new populateClientInfo();
+
+//---------------------------------------------------------------------------
+// getMetadataMany(sql)
+//
+// Get metadata info for all the columns in the table
+//---------------------------------------------------------------------------
+function getMetadataMany(vars) {
+  const metadata = [];
+  for (const queryVar of vars) {
+    metadata.push(queryVar.fetchInfo);
+  }
+  return metadata;
+}
+
+//---------------------------------------------------------------------------
+// getOutBindValues(sql)
+//
+// Return the values for the out binds at the given position (row).
+//---------------------------------------------------------------------------
+function getOutBindValues(bindVars, pos) {
+  const bindByPos = (bindVars[0].name === undefined);
+  const outBindValues = (bindByPos) ? [] : {};
+  for (let i = 0; i < bindVars.length; i++) {
+    if (bindByPos) {
+      outBindValues.push(bindVars[i].values[pos]);
+    } else {
+      outBindValues[bindVars[i].name] = bindVars[i].values[pos];
+    }
+  }
+  return outBindValues;
+}
+
+//---------------------------------------------------------------------------
+// getOutBinds()
+//
+// Return the out binds for the given statement.
+//---------------------------------------------------------------------------
+function getOutBinds(statement, numIters, executeManyFlag) {
+  const bindVars = statement.bindInfoList.map(i => i.bindVar);
+  const outBinds = bindVars.filter(v => v.dir !== constants.BIND_IN);
+  if (outBinds.length > 0) {
+    if (executeManyFlag) {
+      const outBindValues = new Array(numIters);
+      for (let i = 0; i < numIters; i++) {
+        outBindValues[i] = getOutBindValues(outBinds, i);
+      }
+      return outBindValues;
+    }
+    return getOutBindValues(outBinds, 0);
+  }
+}
+
+//---------------------------------------------------------------------------
+// checkProxyUserValidity()
+//
+// Check validity status for proxy authentication
+//---------------------------------------------------------------------------
+function checkProxyUserValidity(userName) {
+  let schemaUser = '', proxyUser = '';
+  let quoteFound = false, openSquareBracketFound = false;
+  let lastQuoteFoundIndex = 0;
+  const result = {
+    status: -1,
+    proxyUser: '',
+    schemaUser: ''
+  };
+  const userNameLength = userName.length;
+  let index = 0, i, j;
+  while (index < userNameLength) {
+    // check for double quotes
+    if (userName.charAt(index) === '"') {
+      quoteFound = !quoteFound;
+      lastQuoteFoundIndex = index;
+    }
+
+    // check for open square bracket
+    if (userName.charAt(index) === '[' && !quoteFound) {
+      openSquareBracketFound = true;
+      // skip leading space and extract proxy user name
+      if (lastQuoteFoundIndex != 0) {
+        for (i = lastQuoteFoundIndex + 1; i < index; i++) {
+          if (userName.charAt(i) !== ' ') {
+            return result;
+          }
+        }
+
+        for (i = 0; i <= lastQuoteFoundIndex; i++) {
+          proxyUser += userName.charAt(i);
+        }
+      } else {
+        for (i = 0; i < index; i++) {
+          if (userName.charAt(i) !== ' ') {
+            proxyUser += userName.charAt(i);
+          } else {
+            break;
+          }
+        }
+      }
+      break;
+    }
+    index++;
+  }
+
+  if (proxyUser.length != 0) {
+    result.proxyUser = proxyUser;
+  }
+
+  // extract schema user
+  index = index + 1;
+  quoteFound = false;
+  const schemaUserStartIndex = index;
+  lastQuoteFoundIndex = 0;
+  while (index < userNameLength) {
+    // check for double quotes
+    if (userName.charAt(index) === '"') {
+      quoteFound = !quoteFound;
+      lastQuoteFoundIndex = index;
+    }
+
+    if (userName.charAt(index) === '[' && !quoteFound &&
+        openSquareBracketFound) {
+      return result;
+    }
+
+    if (userName.charAt(index) === ']' && !quoteFound) {
+      if (lastQuoteFoundIndex != schemaUserStartIndex &&
+          lastQuoteFoundIndex != 0) {
+        for (i = schemaUserStartIndex; i <= lastQuoteFoundIndex; i++) {
+          schemaUser += userName.charAt(i);
+        }
+        // check for character between double quotes and close brackets
+        for (i = lastQuoteFoundIndex + 1; i < index; i++) {
+          if (userName.charAt(i) != ' ') {
+            return result;
+          }
+        }
+      } else {
+        // skip trailing spaces
+        for (i = schemaUserStartIndex; i < index; i++) {
+          if (userName.charAt(i) != ' ') {
+            break;
+          }
+        }
+        if (i == index) {
+          return result;
+        }
+
+        for (j = i; j < index; j++) {
+          schemaUser += userName[j];
+        }
+      }
+
+      // check for character from [ till end of string
+      for (i = index + 1; i < userNameLength; i++) {
+        if (userName[i] != ' ') {
+          return result;
+        }
+      }
+    }
+    index++;
+  }
+
+  if (schemaUser.length === 0) {
+    return result;
+  } else {
+    result.schemaUser = schemaUser;
+  }
+
+  result.status = 0;
+  return result;
+}
+
+//---------------------------------------------------------------------------
+// checkCredentials()
+//
+// Check Credentials for Password Authentication
+//---------------------------------------------------------------------------
+function checkCredentials(params) {
+  if (params.externalAuth === false) {
+    if (params.password === undefined) {
+      errors.throwErr(errors.ERR_MISSING_CREDENTIALS);
+    }
+  }
+}
+
+//---------------------------------------------------------------------------
+// normalizePrivateKey()
+//
+// Add header and footer to private key
+//---------------------------------------------------------------------------
+function normalizePrivateKey(privateKey) {
+  return '-----BEGIN PRIVATE KEY-----\n' + privateKey +
+  '\n' + '-----END PRIVATE KEY-----';
+}
+
+module.exports = {
+  getMetadataMany,
+  CLIENT_INFO,
+  getOutBinds,
+  checkProxyUserValidity,
+  checkCredentials,
+  normalizePrivateKey,
+};

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

@@ -0,0 +1,133 @@
+// Copyright (c) 2024, 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';
+
+/**
+ * TraceHandler interface defination which application needs to implement
+ * the hooks defined. The hooks will be called by the driver with traceContext
+ * data.
+ *
+ * TraceContext Data details.
+ * connectLevelConfig - Connection Config details.
+ *      protcol         - tcp/tcps protocol.
+ *      user            - user/schema associated.
+ *      instanceName    - instance Name.
+ *      pdbName         - PDB name.
+ *      serviceName     - service name.
+ *      connectString   - connect string passed.
+ *      hostName        - host name.
+ *      port            - port number.
+ *      poolMin         - pool Min.
+ *      poolMax         - pool Max.
+ *      poolIncrement   - pool Increment.
+ *
+ * callLevelConfig - Post connection, call leveldetails.
+ *      statement       - SQL statement.
+ *      values          - Bind values.
+ *
+ * additionalConfig - Custom Config based on the methods executed.
+ *      args            - input arguments of function.
+ *      self            - the current instance on which function is called.
+ *      result          - the result object returned after calling function.
+ *      implicitRelease - true if implicit release is done.
+ *
+ */
+
+class TraceHandlerBase {
+
+  constructor() {
+    this._config = {};
+  }
+
+  // check if sending traces is enabled.
+  isEnabled() {
+    return (this._config.enable);
+  }
+
+  // Enable sending traces
+  enable() {
+    this._config.enable = true;
+  }
+
+  // Disable sending traces
+  disable() {
+    this._config.enable = false;
+  }
+
+  // It is called before invoking a public async method.
+  onEnterFn(/*traceContext*/) {
+  }
+
+  // It is called after invoking a public async method.
+  // The same traceContext object passed inside onEnterFn
+  // will be passed in this function.
+  onExitFn(/*traceContext*/) {
+  }
+
+  // called when a round trip is begun
+  // OpenTelemetry will start a new span as a child of the public API span.
+  onBeginRoundTrip(/*traceContext*/) {
+  }
+
+  // called when a round trip has ended
+  // OpenTelemetry will end the span
+  // The same traceContext object passed inside onBeginRoundTrip
+  // is passed here.
+  onEndRoundTrip(/*traceContext*/) {
+  }
+
+}
+
+// singleton object pointing to traceHandler instance.
+let _currentTraceObject;
+
+// It enables user defined implementation of
+// TraceHandlerBase interface to be used.
+function setTraceInstance(obj) {
+  _currentTraceObject = obj;
+}
+
+// It returns the user defined instance implementing the interface.
+function getTraceInstance() {
+  return _currentTraceObject;
+}
+
+// returns if tracing is enabled.
+function isEnabled() {
+  return _currentTraceObject?.isEnabled();
+}
+
+module.exports = {
+  // class
+  TraceHandlerBase,
+
+  // methods
+  setTraceInstance,
+  getTraceInstance,
+  isEnabled
+
+};