oracledb 6.3.0 → 6.5.0

package/lib/thin/sqlnet/networkSession.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -59,7 +59,7 @@ async function getConnectionInfo(userConfig) {
   const sid =   findValue(nvpair, ["DESCRIPTION", "CONNECT_DATA", "SID"]);
   const poolPurity = findValue(nvpair, ["DESCRIPTION", "CONNECT_DATA", "POOL_PURITY"]);
 
-  return [serverVal, connClass, svcname, poolPurity, sid, addressNode ];
+  return [serverVal, connClass, svcname, poolPurity, sid, addressNode];
 }
 
 /**
@@ -83,6 +83,12 @@ async function resolveConnectStr(connectString, configDir) {
       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 EzConnect(rString).getResolvedUrl();
+        }
+      }
       resolvedVal = resolvedVal.getListElement(0);
     }
 
@@ -354,8 +360,13 @@ class NetworkSession {
         break;
       case constants.NSPTAC: /* ACCEPT */
         Packet.AcceptPacket(packet, this.sAtts);
-        this.dbUUID = packet.dbUUID;
-        packet.dbUUID = null;
+        if (this.sAtts.version >= constants.TNS_VERSION_MIN_END_OF_RESPONSE
+          && (packet.flags & constants.TNS_ACCEPT_FLAG_HAS_END_OF_REQUEST)) {
+          this.endOfRequestSupport = true;
+        }
+        if (packet.flags & constants.TNS_ACCEPT_FLAG_FAST_AUTH) {
+          this.supportsFastAuth = true;
+        }
         break;
       case constants.NSPTRF: /* REFUSE */
         this.refusePkt = new Packet.RefusePacket(packet);
@@ -530,6 +541,18 @@ class NetworkSession {
     await this.connect1(address, addressNode, userConfig);
   }
 
+  /**
+   * Force Disconnect the stream, primarily used
+   * to disconnect dead/hung connections.
+   */
+  forceDisconnect(err) {
+    if (!this.connected) {
+      return;
+    }
+    this.ntAdapter.stream.destroy(err);
+    this.connected = false;
+  }
+
   /**
    * Disconnect
    * @param {int} type of disconnect

package/lib/thin/sqlnet/packet.js

@@ -246,11 +246,8 @@ function AcceptPacket(packet, sAtts) {
   this.flag0 = packet.buf.readUInt8(constants.NSPACFL0);
   this.flag1 = packet.buf.readUInt8(constants.NSPACFL1);
 
-  /* UUID - CDB Instance ID */
-  if (sAtts.version >= constants.TNS_VERSION_MIN_UUID) {
-    packet.dbUUID = packet.buf.subarray(constants.TNS_UUID_OFFSET,
-      constants.TNS_UUID_OFFSET + 16);
-    packet.dbUUID = packet.dbUUID.toString('base64');
+  if (sAtts.version >= constants.TNS_VERSION_MIN_DATA_FLAGS) {
+    packet.flags = packet.buf.readUInt32BE(constants.NSPACFL2);
   }
 }
 

package/lib/thin/statement.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -28,6 +28,7 @@
 
 const { Buffer } = require('buffer');
 const constants = require('../constants');
+const errors = require('../errors');
 
 /**
  * It is used to cache the metadata about bind information
@@ -219,10 +220,10 @@ class Parser {
 
   /**
    * Single line comments consist of two dashes and all characters up to the
-   * next line break. This method is called when the first dash is detected
-   * and checks for the subsequent dash. If found, the single line comment
-   * is traversed and the current position is updated; otherwise, the
-   * current position is left untouched.
+   * next line break (or the end of the data). This method is called when
+   * the first dash is detected and checks for the subsequent dash. If found,
+   * the single line comment is traversed and the current position is updated;
+   * otherwise, the current position is left untouched.
    */
   _parseSingleLineComment() {
     let inComment = false;
@@ -233,15 +234,15 @@ class Parser {
       ch = this.sqlData[pos];
       if (!inComment) {
         if (ch !== '-') {
-          break;
+          return;
         }
         inComment = true;
       } else if (ch === '\n') {
-        this.pos = pos;
         break;
       }
       pos += 1;
     }
+    this.pos = pos;
   }
 
   /**
@@ -359,6 +360,7 @@ class Statement {
     this.inUse = false;
     this.bufferRowIndex = 0;
     this.bufferRowCount = 0;
+    this.pendingClear = false;
     this.statementType = constants.STMT_TYPE_UNKNOWN;
   }
 
@@ -495,6 +497,12 @@ class Statement {
       const info = new BindInfo(name, this.isReturning);
       this.bindInfoList.push(info);
       if (this.bindInfoDict.has(info.bindName)) {
+        if (this.isReturning) {
+          const origInfo = this.bindInfoDict.get(info.bindName)[0];
+          if (!origInfo.isReturnBind) {
+            errors.throwErr(errors.ERR_DML_RETURNING_DUP_BINDS, name);
+          }
+        }
         this.bindInfoDict.get(info.bindName).push(info);
       } else {
         this.bindInfoDict.set(info.bindName, [info]);
@@ -528,6 +536,34 @@ class Statement {
 
     bindInfo.bindVar = variable;
   }
+
+  //---------------------------------------------------------------------------
+  // _clearAllState
+  //
+  // clear all state associated with the cursor
+  //---------------------------------------------------------------------------
+  _clearAllState() {
+    this.cursorId = 0;
+    this.requiresDefine = false;
+    this.noPrefetch = false;
+    this.requiresFullExecute = false;
+    this.queryVars = [];
+    this.numQueryVars = 0;
+    this.bufferRowCount = 0;
+    this.bufferRowIndex = 0;
+  }
+
+  //---------------------------------------------------------------------------
+  // _clearState
+  //
+  // clear some state associated with the cursor
+  //---------------------------------------------------------------------------
+  _clearState() {
+    this.cursorId = 0;
+    this.requiresDefine = false;
+    this.noPrefetch = false;
+    this.requiresFullExecute = false;
+  }
 }
 
 module.exports.Statement = Statement;

package/lib/thin/statementCache.js

@@ -0,0 +1,190 @@
+// 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;
+  }
+
+  //---------------------------------------------------------------------------
+  // 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/lib/thin/util.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -254,5 +254,5 @@ module.exports = {
   getOutBinds,
   checkProxyUserValidity,
   checkCredentials,
-  normalizePrivateKey
+  normalizePrivateKey,
 };

package/lib/transformer.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -34,6 +34,7 @@ const constants = require('./constants.js');
 const errors = require('./errors.js');
 const util = require('util');
 const types = require('./types.js');
+const nodbUtil = require('./util.js');
 
 //-----------------------------------------------------------------------------
 // checkType()
@@ -86,9 +87,9 @@ function transformJsonValue(value) {
 
   // handle simple scalars
   if (value === undefined || value === null ||
-      typeof value === 'number' || typeof value === 'string' ||
-      typeof value === 'boolean' || Buffer.isBuffer(value) ||
-      util.isDate(value))
+    typeof value === 'number' || typeof value === 'string' ||
+    typeof value === 'boolean' || Buffer.isBuffer(value) ||
+    util.types.isDate(value) || nodbUtil.isVectorValue(value))
     return value;
 
   // arrays are transformed to a new array with processed values
@@ -104,6 +105,12 @@ function transformJsonValue(value) {
   if (value instanceof BaseDbObject)
     return {fields: [], values: []};
 
+  // JsonId is a special type to represent autogenerated id
+  // for SODA documents.
+  if (value instanceof types.JsonId) {
+    return value;
+  }
+
   // all other objects are transformed to an object with two arrays (fields
   // and values)
   const outValue = {};
@@ -165,7 +172,7 @@ function transformValueIn(info, value, options) {
     return value;
 
   // handle numbers
-  } else if (typeof value === 'number') {
+  } else if (typeof value === 'number' || typeof value === 'bigint') {
     checkType(info, options,
       types.DB_TYPE_NUMBER,
       types.DB_TYPE_BINARY_INTEGER,
@@ -182,7 +189,7 @@ function transformValueIn(info, value, options) {
     return value;
 
   // handle dates
-  } else if (util.isDate(value)) {
+  } else if (util.types.isDate(value)) {
     checkType(info, options,
       types.DB_TYPE_TIMESTAMP,
       types.DB_TYPE_TIMESTAMP_TZ,
@@ -220,6 +227,14 @@ function transformValueIn(info, value, options) {
     checkType(info, options, types.DB_TYPE_OBJECT);
     return value._impl;
 
+  // handle vectors
+  } else if (value instanceof Float32Array || value instanceof Float64Array ||
+    value instanceof Int8Array) {
+    checkType(info, options, types.DB_TYPE_VECTOR);
+    return value;
+  } else if (info.type === types.DB_TYPE_VECTOR && Array.isArray(value)) {
+    return new Float64Array(value);
+
   // handle arrays
   } else if (options.allowArray && Array.isArray(value)) {
     info.isArray = true;

package/lib/types.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -199,6 +199,9 @@ const DB_TYPE_VARCHAR = new DbType(2001,
 const DB_TYPE_XMLTYPE = new DbType(2032,
   "DB_TYPE_XMLTYPE", "XMLTYPE",
   { oraTypeNum: 109, csfrm: constants.CSFRM_IMPLICIT, bufferSizeFactor: 2147483647 });
+const DB_TYPE_VECTOR = new DbType(2033,
+  "DB_TYPE_VECTOR", "VECTOR",
+  { oraTypeNum: 127 });
 
 // database type conversion map: the top level key refers to the database
 // type being fetched and the value is another map; this map's key is the
@@ -276,6 +279,11 @@ const DB_TYPE_CONVERSION_MAP = new Map([
   [DB_TYPE_UROWID, new Map([
     [DB_TYPE_VARCHAR, DB_TYPE_ROWID]
   ])],
+  [DB_TYPE_VECTOR, new Map([
+    [DB_TYPE_VARCHAR, DB_TYPE_LONG],
+    [DB_TYPE_LONG, DB_TYPE_LONG],
+    [DB_TYPE_CLOB, DB_TYPE_CLOB]
+  ])],
 ]);
 
 // default fetch type map
@@ -308,7 +316,8 @@ const DB_TYPE_FETCH_TYPE_MAP = new Map([
   [DB_TYPE_TIMESTAMP_TZ, DB_TYPE_TIMESTAMP_TZ],
   [DB_TYPE_UROWID, DB_TYPE_UROWID],
   [DB_TYPE_VARCHAR, DB_TYPE_VARCHAR],
-  [DB_TYPE_XMLTYPE, DB_TYPE_XMLTYPE]
+  [DB_TYPE_XMLTYPE, DB_TYPE_XMLTYPE],
+  [DB_TYPE_VECTOR, DB_TYPE_VECTOR]
 ]);
 
 // additional aliases for types by column type name
@@ -323,6 +332,13 @@ dbTypeByColumnTypeName.set("SMALLINT", DB_TYPE_NUMBER);
 dbTypeByColumnTypeName.set("TIMESTAMP WITH LOCAL TZ", DB_TYPE_TIMESTAMP_LTZ);
 dbTypeByColumnTypeName.set("TIMESTAMP WITH TZ", DB_TYPE_TIMESTAMP_TZ);
 
+// It abstracts the autogenerated SODA Document key.
+class JsonId extends Uint8Array {
+  toJSON() {
+    return (Buffer.from(this.buffer).toString('hex'));
+  }
+}
+
 module.exports = {
   DbType,
   DB_TYPE_BFILE,
@@ -353,10 +369,12 @@ module.exports = {
   DB_TYPE_TIMESTAMP_TZ,
   DB_TYPE_UROWID,
   DB_TYPE_VARCHAR,
+  DB_TYPE_VECTOR,
   DB_TYPE_CONVERSION_MAP,
   DB_TYPE_FETCH_TYPE_MAP,
   DB_TYPE_XMLTYPE,
   getTypeByColumnTypeName,
   getTypeByNum,
-  getTypeByOraTypeNum
+  getTypeByOraTypeNum,
+  JsonId
 };

package/lib/util.js

@@ -231,7 +231,7 @@ function isShardingKey(value) {
     const element = value[i];
     const ok = typeof element === 'string' ||
       typeof element === 'number' || Buffer.isBuffer(element) ||
-      util.isDate(element);
+      util.types.isDate(element);
     if (!ok)
       return false;
   }
@@ -327,6 +327,33 @@ function addTypeProperties(obj, attrName) {
   }
 }
 
+//-----------------------------------------------------------------------------
+// isVectorValue()
+//
+// Returns true for list of typed arrays supported for vector column types
+//
+// -----------------------------------------------------------------------------
+function isVectorValue(value) {
+  return (value instanceof Float32Array ||
+      value instanceof Float64Array ||
+      value instanceof Int8Array);
+}
+
+//-----------------------------------------------------------------------------
+// makeDate()
+//
+// Returns a date from the given components.
+//
+// -----------------------------------------------------------------------------
+function makeDate(useLocal, year, month, day, hour, minute,
+  second, fseconds, offset) {
+  if (useLocal) {
+    return new Date(year, month - 1, day, hour, minute, second, fseconds);
+  }
+  return new Date(Date.UTC(year, month - 1, day, hour, minute, second,
+    fseconds) - offset * 60000);
+}
+
 // define exports
 module.exports = {
   BINARY_FILE,
@@ -346,7 +373,9 @@ module.exports = {
   isSodaDocument,
   isTokenExpired,
   isTokenValid,
+  isVectorValue,
   isXid,
+  makeDate,
   preventConcurrent,
   serialize,
   verifySodaDoc,

package/lib/version.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -30,7 +30,7 @@
 
 module.exports = {
   VERSION_MAJOR: 6,
-  VERSION_MINOR: 3,
+  VERSION_MINOR: 5,
   VERSION_PATCH: 0,
   VERSION_SUFFIX: ''
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oracledb",
-  "version": "6.3.0",
+  "version": "6.5.0",
   "description": "A Node.js module for Oracle Database access from JavaScript and TypeScript",
   "license": "(Apache-2.0 OR UPL-1.0)",
   "homepage": "http://oracle.github.io/node-oracledb/",

package/build/Release/oracledb-6.3.0-darwin-x64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.3.0-darwin-x64.node v18.16.0 6430a56e82b0405c4118fcc1060c3568be4c43aa 4b8ebc2af8c9d58f7260c9de81d220f14fcab777 Sun, 17 Dec 2023 09:33:07 GMT

package/build/Release/oracledb-6.3.0-js-buildinfo.txt

@@ -1 +0,0 @@
-6430a56e82b0405c4118fcc1060c3568be4c43aa

package/build/Release/oracledb-6.3.0-linux-arm64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.3.0-linux-arm64.node v16.20.2 6430a56e82b0405c4118fcc1060c3568be4c43aa 4b8ebc2af8c9d58f7260c9de81d220f14fcab777 Sun, 17 Dec 2023 09:47:35 GMT

package/build/Release/oracledb-6.3.0-linux-x64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.3.0-linux-x64.node v16.19.1 6430a56e82b0405c4118fcc1060c3568be4c43aa 4b8ebc2af8c9d58f7260c9de81d220f14fcab777 Fri, 15 Dec 2023 17:32:48 GMT

package/build/Release/oracledb-6.3.0-win32-x64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.3.0-win32-x64.node v14.17.3 6430a56e82b0405c4118fcc1060c3568be4c43aa 4b8ebc2af8c9d58f7260c9de81d220f14fcab777 Fri, 15 Dec 2023 17:43:19 GMT