oracledb 6.3.0 → 6.4.0

package/lib/thin/protocol/messages/auth.js

@@ -322,7 +322,7 @@ class AuthMessage extends Message {
 
       this.conn.dbDomain = this.sessionData['AUTH_SC_DB_DOMAIN'];
       this.conn.dbName = this.sessionData['AUTH_SC_DBUNIQUE_NAME'];
-      this.conn.maxOpenCursors = Number(this.sessionData['AUTH_MAX_OPEN_CURSORS']);
+      this.conn.maxOpenCursors = Number(this.sessionData['AUTH_MAX_OPEN_CURSORS'] || 0);
       this.conn.serviceName = this.sessionData['AUTH_SC_SERVICE_NAME'];
       this.conn.instanceName = this.sessionData['AUTH_INSTANCENAME'];
       const fullVersionNum = Number(this.sessionData['AUTH_VERSION_NO']);

package/lib/thin/protocol/messages/base.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -90,11 +90,11 @@ class Message {
       buf.skipBytesChunked();
     }
     // batch error codes
-    let numEntries = buf.readUB2();             // batch error codes array
-    if (numEntries > 0) {
+    const numErrors = buf.readUB2();             // batch error codes array
+    if (numErrors > 0) {
       this.errorInfo.batchErrors = [];
       const firstByte = buf.readUInt8();
-      for (let i = 0; i < numEntries; i++) {
+      for (let i = 0; i < numErrors; i++) {
         if (firstByte === constants.TNS_LONG_LENGTH_INDICATOR) {
           buf.skipUB4();                        // chunk length ignored
         }
@@ -107,14 +107,21 @@ class Message {
     }
 
     // batch error offset
-    numEntries = buf.readUB2();                 // batch error row offset array
-    if (numEntries > 0) {
+    const numOffsets = buf.readUB4();           // batch error row offset array
+    if (numOffsets > 0) {
+      if (numOffsets > 65535) {
+        errors.throwErr(errors.ERR_TOO_MANY_BATCH_ERRORS);
+      }
       const firstByte = buf.readUInt8();
-      for (let i = 0; i < numEntries; i++) {
+      let offset;
+      for (let i = 0; i < numOffsets; i++) {
         if (firstByte === constants.TNS_LONG_LENGTH_INDICATOR) {
           buf.skipUB4();                        // chunk length ignored
         }
-        this.errorInfo.batchErrors[i].offset = buf.readUB4();
+        offset = buf.readUB4();
+        if (i < numErrors) {
+          this.errorInfo.batchErrors[i].offset = offset;
+        }
       }
       if (firstByte === constants.TNS_LONG_LENGTH_INDICATOR) {
         buf.skipBytes(1);                       // ignore end marker
@@ -122,10 +129,10 @@ class Message {
     }
 
     // batch error messages
-    numEntries = buf.readUB2();                 // batch error messages array
-    if (numEntries > 0) {
+    const errMsgArr = buf.readUB2();                 // batch error messages array
+    if (errMsgArr > 0) {
       buf.skipBytes(1);                         // ignore packed size
-      for (let i = 0; i < numEntries; i++) {
+      for (let i = 0; i < errMsgArr; i++) {
         buf.skipUB2();                          // skip chunk length
 
         this.errorInfo.batchErrors[i].message = buf.readStr(constants.CSFRM_IMPLICIT);
@@ -275,7 +282,7 @@ class Message {
       const flags = buf.readUB4();              // session flags
       if (flags & constants.TNS_SESSGET_SESSION_CHANGED) {
         if (this.connection._drcpEstablishSession) {
-          this.connection.resetStatementCache();
+          this.connection.statementCache.clearOpenCursors();
         }
       }
       this.connection._drcpEstablishSession = false;
@@ -290,7 +297,7 @@ class Message {
     if (this.connection._currentSchemaModified) {
       this._writeCurrentSchemaPiggyback(buf);
     }
-    if (this.connection._cursorsToClose.size > 0 && !this.connection._drcpEstablishSession) {
+    if (this.connection.statementCache._cursorsToClose.size > 0 && !this.connection._drcpEstablishSession) {
       this.writeCloseCursorsPiggyBack(buf);
     }
     if (
@@ -319,11 +326,7 @@ class Message {
   writeCloseCursorsPiggyBack(buf) {
     this.writePiggybackHeader(buf, constants.TNS_FUNC_CLOSE_CURSORS);
     buf.writeUInt8(1);
-    buf.writeUB4(this.connection._cursorsToClose.size);
-    for (const cursorNum of this.connection._cursorsToClose.keys()) {
-      buf.writeUB4(cursorNum);
-    }
-    this.connection._cursorsToClose.clear();
+    this.connection.statementCache.writeCursorsToClose(buf);
   }
 
   writeCloseTempLobsPiggyback(buf) {

package/lib/thin/protocol/messages/dataType.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -392,7 +392,8 @@ const dataTypes = [
   [constants.TNS_DATA_TYPE_UDS, constants.TNS_DATA_TYPE_UDS, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_TNP, constants.TNS_DATA_TYPE_TNP, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_OER, constants.TNS_DATA_TYPE_OER, constants.TNS_TYPE_REP_UNIVERSAL],
-  [constants.TNS_DATA_TYPE_OAC, constants.TNS_DATA_TYPE_OAC, constants.TNS_TYPE_REP_UNIVERSAL]
+  [constants.TNS_DATA_TYPE_OAC, constants.TNS_DATA_TYPE_OAC, constants.TNS_TYPE_REP_UNIVERSAL],
+  [constants.TNS_DATA_TYPE_VECTOR, constants.TNS_DATA_TYPE_VECTOR, constants.TNS_TYPE_REP_UNIVERSAL]
 ];
 
 module.exports = DataTypeMessage;

package/lib/thin/protocol/messages/withData.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -117,7 +117,7 @@ class MessageWithData extends Message {
       this.errorOccurred = false;
       this.statement.moreRowsToFetch = false;
     } else if (this.errorInfo.num !== 0 && this.errorInfo.cursorId !== 0) {
-      this.connection.statementCache.delete(this.statement.sql);
+      this.connection.statementCache._cachedStatements.delete(this.statement.sql);
       this.statement.returnToCache = false;
     }
     if (this.errorInfo.batchErrors) {
@@ -148,15 +148,16 @@ class MessageWithData extends Message {
       buf.skipUB1();
     }
     resultSet.metadata = [];
+    const metadata = [];
+    const queryVars = [];
     for (let i = 0; i < statement.numQueryVars; i++) {
       const variable = this.processColumnInfo(buf, i + 1);
       if (prevQueryVars && i < prevQueryVars.length) {
         this._adjustFetchType(prevQueryVars[i], variable);
       }
-      statement.queryVars.push(variable);
-      resultSet.metadata.push(variable.fetchInfo);
+      queryVars.push(variable);
+      metadata.push(variable.fetchInfo);
     }
-
     let numBytes = buf.readUB4();
     if (numBytes > 0) {
       buf.skipBytesChunked();                   // current date
@@ -170,6 +171,13 @@ class MessageWithData extends Message {
       buf.skipBytesChunked();
     }
 
+    /*
+     * The message state(resultSet) and statement state(queryVars) is modified
+     * at end of the DescribeInfo function so that an OutOfPacketsError
+     * won't cause partial information state to be stored.
+     */
+    resultSet.metadata = metadata;
+    statement.queryVars = queryVars;
     this.resultSetsToSetup.push(resultSet);
   }
 
@@ -223,6 +231,7 @@ class MessageWithData extends Message {
       nullable: nullable
     };
     fetchInfo.isJson = Boolean(udsFlags & constants.TNS_UDS_FLAGS_IS_JSON);
+    fetchInfo.isOson = Boolean(udsFlags & constants.TNS_UDS_FLAGS_IS_OSON);
     if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_1) {
       numBytes = buf.readUB4();
       if (numBytes > 0) {
@@ -254,6 +263,19 @@ class MessageWithData extends Message {
         buf.skipUB4();                          // flags
       }
     }
+    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_4) {
+      const dimensions = buf.readUB4();
+      const vectorFormat = buf.readUInt8();
+      const vectorFlags = buf.readUInt8();
+      if (fetchInfo.dbType === types.DB_TYPE_VECTOR) {
+        if (!(vectorFlags & constants.VECTOR_META_FLAG_FLEXIBLE_DIM)) {
+          fetchInfo.vectorDimensions = dimensions;
+        }
+        if (vectorFormat !== constants.VECTOR_FORMAT_FLEX) {
+          fetchInfo.vectorFormat = vectorFormat;
+        }
+      }
+    }
 
     switch (fetchInfo.dbType) {
       case types.DB_TYPE_VARCHAR:
@@ -481,6 +503,8 @@ class MessageWithData extends Message {
       }
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_JSON) {
       colValue = buf.readOson();
+    } else if (oraTypeNum === constants.TNS_DATA_TYPE_VECTOR) {
+      colValue = buf.readVector();
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_INT_NAMED) {
       const obj = buf.readDbObject();
       if (obj.packedData) {
@@ -589,7 +613,8 @@ class MessageWithData extends Message {
         if (variable.type === types.DB_TYPE_CLOB ||
             variable.type === types.DB_TYPE_NCLOB ||
             variable.type === types.DB_TYPE_BLOB ||
-            variable.type === types.DB_TYPE_JSON) {
+            variable.type === types.DB_TYPE_JSON ||
+            variable.type === types.DB_TYPE_VECTOR) {
           if (variable.type !== variable.fetchInfo.fetchType) {
             variable.type = variable.fetchInfo.fetchType;
             variable.maxSize = constants.TNS_MAX_LONG_LENGTH;
@@ -674,6 +699,9 @@ class MessageWithData extends Message {
       } else if (variable.type === types.DB_TYPE_JSON) {
         contFlag = constants.TNS_LOB_PREFETCH_FLAG;
         maxSize = lobPrefetchLength = constants.TNS_JSON_MAX_LENGTH;
+      } else if (variable.type === types.DB_TYPE_VECTOR) {
+        contFlag = constants.TNS_LOB_PREFETCH_FLAG;
+        maxSize = lobPrefetchLength = constants.TNS_VECTOR_MAX_LENGTH;
       }
       buf.writeUInt8(oraTypeNum);
       buf.writeUInt8(flag);
@@ -794,8 +822,10 @@ class MessageWithData extends Message {
     ) {
       buf.writeOracleDate(value, variable.type);
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_BINARY_DOUBLE) {
+      buf.writeUInt8(8);
       buf.writeBinaryDouble(value);
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_BINARY_FLOAT) {
+      buf.writeUInt8(4);
       buf.writeBinaryFloat(value);
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_CURSOR) {
       let cursor = value;
@@ -823,6 +853,8 @@ class MessageWithData extends Message {
       buf.writeBytesWithLength(Buffer.from(value));
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_JSON) {
       buf.writeOson(value);
+    } else if (oraTypeNum === constants.TNS_DATA_TYPE_VECTOR) {
+      buf.writeVector(value);
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_INT_NAMED) {
       buf.writeDbObject(value);
     } else {

package/lib/thin/protocol/packet.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -26,11 +26,12 @@
 
 'use strict';
 
-const { BaseBuffer } = require('./buffer.js');
+const { BaseBuffer } = require('../../impl/datahandlers/buffer.js');
 const { Buffer } = require('buffer');
-const constants = require("./constants.js");
-const oson = require('./oson.js');
+const constants = require('./constants.js');
+const oson = require('../../impl/datahandlers/oson.js');
 const utils = require('./utils.js');
+const vector = require('../../impl/datahandlers/vector.js');
 const errors = require("../../errors.js");
 
 const TNS_BASE64_ALPHABET_ARRAY = Buffer.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", 'utf8');
@@ -395,6 +396,22 @@ class ReadPacket extends BaseBuffer {
     return {rba, partitionID, blockNum, slotNum};
   }
 
+  /**
+   * Reads VECTOR data (QLocator followed by data) and decodes it into a
+   * JavaScript object.
+   */
+  readVector() {
+    const numBytes = this.readUB4();
+    if (numBytes === 0) {
+      return null;
+    }
+    this.skipUB8();                     // size (unused)
+    this.skipUB4();                     // chunk size (unused)
+    const decoder = new vector.VectorDecoder(this.readBytesWithLength());
+    this.skipBytesChunked();            // locator (unused)
+    return decoder.decode();
+  }
+
   skipBytesChunked() {
     const numBytes = this.readUInt8();
     if (numBytes === 0 || numBytes === constants.TNS_NULL_LENGTH_INDICATOR) {
@@ -479,6 +496,9 @@ class WritePacket extends BaseBuffer {
       buf = Buffer.from(buf);
       this.startPacket();
     }
+    if (!this.nsi.ntAdapter) {
+      errors.throwErr(errors.ERR_INVALID_CONNECTION);
+    }
     this.nsi.ntAdapter.send(buf);
   }
 
@@ -537,6 +557,40 @@ class WritePacket extends BaseBuffer {
     this.protocol.sequenceId = (this.protocol.sequenceId + 1) % 256;
   }
 
+  /**
+   * Encodes a JavaScript object into VECTOR data and then writes it (QLocator
+   * followed by data) to the buffer.
+   */
+  writeVector(value) {
+    const encoder = new vector.VectorEncoder();
+    const buf = encoder.encode(value);
+    this.writeQLocator(buf.length);
+    this.writeBytesWithLength(buf);
+  }
+
+  //---------------------------------------------------------------------------
+  // writeQLocator()
+  //
+  // Writes a QLocator. QLocators are always 40 bytes in length.
+  //---------------------------------------------------------------------------
+  writeQLocator(numBytes) {
+    this.writeUB4(40);                  // QLocator length
+    this.writeUInt8(40);                // repeated length
+    this.writeUInt16BE(38);             // internal length
+    this.writeUInt16BE(constants.TNS_LOB_QLOCATOR_VERSION);
+    this.writeUInt8(constants.TNS_LOB_LOC_FLAGS_VALUE_BASED |
+      constants.TNS_LOB_LOC_FLAGS_BLOB | constants.TNS_LOB_LOC_FLAGS_ABSTRACT);
+    this.writeUInt8(constants.TNS_LOB_LOC_FLAGS_INIT);
+    this.writeUInt16BE(0);              // additional flags
+    this.writeUInt16BE(1);              // byt1
+    this.writeUInt64BE(numBytes);
+    this.writeUInt16BE(0);              // unused
+    this.writeUInt16BE(0);              // csid
+    this.writeUInt16BE(0);              // unused
+    this.writeUInt64BE(0);              // unused
+    this.writeUInt64BE(0);              // unused
+  }
+
 }
 
 module.exports = {

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.
 
 //-----------------------------------------------------------------------------
 //
@@ -530,6 +530,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/statement.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -219,10 +219,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 +233,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;
   }
 
   /**

package/lib/thin/statementCache.js

@@ -0,0 +1,167 @@
+// 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);
+      }
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  //clearOpenCursors() {
+  // 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.
+  //---------------------------------------------------------------------------
+  clearOpenCursors() {
+    const newOpenCursors = new Set();
+    for (const stmt of this._openCursors) {
+      stmt.cursorId = 0;
+      if (stmt.inUse) {
+        newOpenCursors.add(stmt);
+      }
+    }
+    this._openCursors = newOpenCursors;
+  }
+
+  //---------------------------------------------------------------------------
+  // 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) {
+    let stmt = null;
+    if (sql) {
+      stmt = this._cachedStatements.get(sql);
+      if (!cacheStatement) {
+        this._openCursors.add(stmt);
+        this._cachedStatements.delete(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 (stmt.inUse || !cacheStatement) {
+      stmt = stmt._copy();
+      this._openCursors.add(stmt);
+    } else {
+      this._cachedStatements.delete(sql);
+      this._cachedStatements.set(sql, 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 if (statement.cursorId !== 0) {
+      this._addCursorToClose(statement);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // 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/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.isDate(value) || nodbUtil.isVectorValue(value))
     return value;
 
   // arrays are transformed to a new array with processed values
@@ -220,6 +221,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
@@ -353,6 +362,7 @@ 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,