oracledb 6.5.1 → 6.7.0

package/lib/connection.js

@@ -202,9 +202,7 @@ class Connection extends EventEmitter {
       typeof value === 'boolean' ||
       typeof value === 'bigint' ||
       Array.isArray(value) ||
-      value instanceof Float32Array ||
-      value instanceof Float64Array ||
-      value instanceof Int8Array ||
+      nodbUtil.isVectorValue(value) ||
       Buffer.isBuffer(value) ||
       util.types.isDate(value) ||
       value instanceof Lob ||
@@ -871,10 +869,15 @@ class Connection extends EventEmitter {
     let binds = [];
     let options = {};
 
+    errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
+
     // process arguments
     if (nodbUtil.isObject(sql) && typeof sql.statement === 'string') {
       errors.assertArgCount(arguments, 1, 2);
       if (sql.values) {
+        if (this._impl._callLevelTraceData) {
+          this._impl._callLevelTraceData.values = sql.values;
+        }
         binds = await this._processExecuteBinds(sql.values);
       }
       sql = sql.statement;
@@ -885,6 +888,9 @@ class Connection extends EventEmitter {
       errors.assertArgCount(arguments, 1, 3);
       errors.assertParamValue(typeof sql === 'string', 1);
       if (arguments.length >= 2) {
+        if (this._impl._callLevelTraceData) {
+          this._impl._callLevelTraceData.values = a2;
+        }
         binds = await this._processExecuteBinds(a2);
       }
       if (arguments.length == 3) {
@@ -892,11 +898,13 @@ class Connection extends EventEmitter {
       }
     }
     this._addDefaultsToExecOpts(options);
-    errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
 
     // perform actual execute
     let result;
     try {
+      if (this._impl._callLevelTraceData) {
+        this._impl._callLevelTraceData.statement = sql;
+      }
       result = await this._impl.execute(sql, numIters, binds, options, false);
     } catch (err) {
       if (err.errorNum === 1406)
@@ -1037,6 +1045,63 @@ class Connection extends EventEmitter {
     return this._impl && this._impl.getDbName();
   }
 
+  //---------------------------------------------------------------------------
+  // hostName (READONLY)
+  //
+  // Property for identifying the hostName of the Oracle Database.
+  //---------------------------------------------------------------------------
+  get hostName() {
+    return this._impl && this._impl.getHostName();
+  }
+
+  //---------------------------------------------------------------------------
+  // port (READONLY)
+  //
+  // Property for identifying the port to which client is connected.
+  //---------------------------------------------------------------------------
+  get port() {
+    return this._impl && this._impl.getPort();
+  }
+
+  //---------------------------------------------------------------------------
+  // protocol (READONLY)
+  //
+  // Property for identifying the protocol used to connect to Oracle Database.
+  //---------------------------------------------------------------------------
+  get protocol() {
+    return this._impl && this._impl.getProtocol();
+  }
+
+  //---------------------------------------------------------------------------
+  // connectString (READONLY)
+  //
+  // User provided connectString to connect to Oracle Database.
+  //---------------------------------------------------------------------------
+  get connectString() {
+    return this._impl && this._impl._connectString;
+  }
+
+  //---------------------------------------------------------------------------
+  // user
+  //
+  // User property provided to connect to Oracle Database.
+  //---------------------------------------------------------------------------
+  get user() {
+    if (this.currentSchema.length) {
+      return this.currentSchema;
+    }
+    return this._impl && this._impl._user;
+  }
+
+  //---------------------------------------------------------------------------
+  // connectTraceConfig
+  //
+  // Property for getting the connection related config.
+  //---------------------------------------------------------------------------
+  get connectTraceConfig() {
+    return this._impl && this._impl._getConnectTraceConfig();
+  }
+
   //---------------------------------------------------------------------------
   // getDbObjectClass()
   //
@@ -1412,7 +1477,7 @@ class Connection extends EventEmitter {
   async tpcBegin(xid, flag, timeout) {
     errors.assertArgCount(arguments, 1, 3);
     errors.assertParamValue(nodbUtil.isXid(xid), 1);
-
+    const normalizedXid = nodbUtil.normalizeXid(xid);
     if (arguments.length < 3) {
       timeout = 60;   // seconds
     } else {
@@ -1423,9 +1488,14 @@ class Connection extends EventEmitter {
       flag = constants.TPC_BEGIN_NEW;
     } else {
       errors.assertParamValue(typeof flag === 'number', 2);
+      const options = [constants.TPC_BEGIN_NEW, constants.TPC_BEGIN_JOIN,
+        constants.TPC_BEGIN_RESUME, constants.TPC_BEGIN_PROMOTE];
+      if (options.indexOf(flag) < 0) {
+        errors.throwErr(errors.ERR_INVALID_TPC_BEGIN_FLAGS);
+      }
     }
     errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
-    await this._impl.tpcBegin(xid, flag, timeout);
+    await this._impl.tpcBegin(normalizedXid, flag, timeout);
   }
 
   //---------------------------------------------------------------------------
@@ -1441,11 +1511,13 @@ class Connection extends EventEmitter {
     } else {
       errors.assertParamValue(typeof onePhase === 'boolean', 2);
     }
+    let normalizedXid;
     if (arguments.length >= 1) {
       errors.assertParamValue(nodbUtil.isXid(xid), 1);
+      normalizedXid = nodbUtil.normalizeXid(xid);
     }
     errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
-    await this._impl.tpcCommit(xid, onePhase);
+    await this._impl.tpcCommit(normalizedXid, onePhase);
   }
 
   //---------------------------------------------------------------------------
@@ -1460,14 +1532,19 @@ class Connection extends EventEmitter {
       flag = constants.TPC_END_NORMAL;
     } else {
       errors.assertParamValue(typeof flag === 'number', 2);
+      const options = [constants.TPC_END_NORMAL, constants.TPC_END_SUSPEND];
+      if (!options.includes(flag)) {
+        errors.throwErr(errors.ERR_INVALID_TPC_END_FLAGS);
+      }
     }
-
+    let normalizedXid;
     if (arguments.length >= 1) {
       errors.assertParamValue(nodbUtil.isXid(xid), 1);
+      normalizedXid = nodbUtil.normalizeXid(xid);
     }
     errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
 
-    await this._impl.tpcEnd(xid, flag);
+    await this._impl.tpcEnd(normalizedXid, flag);
   }
 
   //---------------------------------------------------------------------------
@@ -1479,9 +1556,10 @@ class Connection extends EventEmitter {
   async tpcForget(xid) {
     errors.assertArgCount(arguments, 1, 1);
     errors.assertParamValue(nodbUtil.isXid(xid), 1);
+    const normalizedXid = nodbUtil.normalizeXid(xid);
     errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
 
-    await this._impl.tpcForget(xid);
+    await this._impl.tpcForget(normalizedXid);
   }
 
   //---------------------------------------------------------------------------
@@ -1491,12 +1569,14 @@ class Connection extends EventEmitter {
   //---------------------------------------------------------------------------
   async tpcPrepare(xid) {
     errors.assertArgCount(arguments, 0, 1);
+    let normalizedXid;
     if (arguments.length >= 1) {
       errors.assertParamValue(nodbUtil.isXid(xid), 1);
+      normalizedXid = nodbUtil.normalizeXid(xid);
     }
     errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
 
-    return await this._impl.tpcPrepare(xid);
+    return await this._impl.tpcPrepare(normalizedXid);
   }
 
   //---------------------------------------------------------------------------
@@ -1541,12 +1621,14 @@ class Connection extends EventEmitter {
   //---------------------------------------------------------------------------
   async tpcRollback(xid) {
     errors.assertArgCount(arguments, 0, 1);
+    let normalizedXid;
     if (arguments.length == 1) {
       errors.assertParamValue(nodbUtil.isXid(xid), 1);
+      normalizedXid = nodbUtil.normalizeXid(xid);
     }
     errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
 
-    await this._impl.tpcRollback(xid);
+    await this._impl.tpcRollback(normalizedXid);
   }
 
   //---------------------------------------------------------------------------
@@ -1569,7 +1651,9 @@ class Connection extends EventEmitter {
 // that cannot take place concurrently
 // NOTE: breakExecution() should not be serialized
 Connection.prototype.break =
-    nodbUtil.callbackify(Connection.prototype.breakExecution);
+    nodbUtil.callbackify(nodbUtil.wrapFn(Connection.prototype.breakExecution));
+Connection.prototype.tpcRecover =
+    nodbUtil.callbackify(nodbUtil.wrapFn(Connection.prototype.tpcRecover));
 nodbUtil.wrapFns(Connection.prototype,
   "changePassword",
   "close",
@@ -1590,7 +1674,6 @@ nodbUtil.wrapFns(Connection.prototype,
   "tpcEnd",
   "tpcForget",
   "tpcPrepare",
-  "tpcRecover",
   "tpcRollback",
   "unsubscribe");
 

package/lib/constants.js

@@ -205,5 +205,6 @@ module.exports = {
   VECTOR_FORMAT_FLOAT32: 2,
   VECTOR_FORMAT_FLOAT64: 3,
   VECTOR_FORMAT_INT8: 4,
+  VECTOR_FORMAT_BINARY: 5,
 
 };

package/lib/errors.js

@@ -108,7 +108,7 @@ const ERR_MISSING_FILE = 91;
 const ERR_INVALID_NUMBER_OF_CONNECTIONS = 92;
 const ERR_EXEC_MODE_ONLY_FOR_DML = 95;
 const ERR_INVALID_BIND_NAME = 97;
-const ERR_WRONG_NUMBER_OF_POSITIONAL_BINDS = 98;
+const ERR_WRONG_NUMBER_OF_BINDS = 98;
 const ERR_BUFFER_LENGTH_INSUFFICIENT = 99;
 const ERR_NCHAR_CS_NOT_SUPPORTED = 100;
 const ERR_MISSING_CREDENTIALS = 101;
@@ -156,6 +156,14 @@ const ERR_VECTOR_VERSION_NOT_SUPPORTED = 145;
 const ERR_OBJECT_IS_NOT_A_COLLECTION = 146;
 const ERR_CURSOR_HAS_BEEN_CLOSED = 147;
 const ERR_DML_RETURNING_DUP_BINDS = 149;
+const ERR_INVALID_TPC_BEGIN_FLAGS = 150;
+const ERR_INVALID_TPC_END_FLAGS = 151;
+const ERR_UNKNOWN_TRANSACTION_STATE = 152;
+const ERR_INVALID_TRANSACTION_SIZE = 153;
+const ERR_INVALID_BRANCH_SIZE = 154;
+const ERR_OPERATION_NOT_SUPPORTED_ON_BFILE = 155;
+const ERR_OPERATION_ONLY_SUPPORTED_ON_BFILE = 156;
+const ERR_EXECMANY_NOT_ALLOWED_ON_QUERIES = 157;
 
 // Oracle Net layer errors start from 500
 const ERR_CONNECTION_CLOSED = 500;
@@ -179,6 +187,14 @@ const ERR_INVALID_SERVICE_NAME = 518;
 const ERR_INVALID_SID = 519;
 const ERR_TNS_NAMES_FILE_MISSING = 520;
 const ERR_CONNECTION_EOF = 521;
+const ERR_AZURE_CONFIG_PROVIDER_AUTH_FAILED = 522;
+const ERR_CONFIG_PROVIDER_FAILED_TO_RETRIEVE_CONFIG = 523;
+const ERR_CONFIG_PROVIDER_NOT_SUPPORTED = 524;
+const ERR_CONFIG_PROVIDER_LOAD_FAILED = 525;
+const ERR_OCIOBJECT_CONFIG_PROVIDER_AUTH_FAILED = 526;
+const ERR_AZURE_VAULT_AUTH_FAILED = 527;
+const ERR_AZURE_SERVICE_PRINCIPAL_AUTH_FAILED = 528;
+const ERR_WALLET_TYPE_NOT_SUPPORTED = 529;
 
 // Oracle SUCCESS_WITH_INFO warning start from 700
 const WRN_COMPILATION_CREATE = 700;
@@ -338,8 +354,8 @@ messages.set(ERR_EXEC_MODE_ONLY_FOR_DML,                // NJS-095
   'setting "batchErrors" or "dmlRowCounts" to true is only permitted for DML statements');
 messages.set(ERR_INVALID_BIND_NAME,                     // NJS-097
   'no bind placeholder named ":%s" was found in the statement text');
-messages.set(ERR_WRONG_NUMBER_OF_POSITIONAL_BINDS,      // NJS-098
-  '%s positional bind values are required but %s were provided');
+messages.set(ERR_WRONG_NUMBER_OF_BINDS,                 // NJS-098
+  '%s bind placeholders were used in the SQL statement but %s bind values were provided');
 messages.set(ERR_BUFFER_LENGTH_INSUFFICIENT,            // NJS-099
   'internal error: buffer of length %s insufficient to hold %s bytes');
 messages.set(ERR_NCHAR_CS_NOT_SUPPORTED,                // NJS-100
@@ -434,6 +450,22 @@ messages.set(ERR_CURSOR_HAS_BEEN_CLOSED,                // NJS-147
   'cursor has been closed by the database');
 messages.set(ERR_DML_RETURNING_DUP_BINDS,               // NJS-149
   'the bind variable placeholder "%s" cannot be used both before and after the RETURNING clause in a DML RETURNING statement');
+messages.set(ERR_INVALID_TPC_BEGIN_FLAGS,               // NJS-150
+  'invalid flags for tpcBegin() in Two Phase Commit');
+messages.set(ERR_INVALID_TPC_END_FLAGS,                 // NJS-151
+  'invalid flags for tpcEnd() in Two Phase Commit');
+messages.set(ERR_UNKNOWN_TRANSACTION_STATE,             // NJS-152
+  'internal error: unknown transaction state {state} in Two Phase Commit');
+messages.set(ERR_INVALID_TRANSACTION_SIZE,              // NJS-153
+  'size of the transaction ID is %d and cannot exceed 64');
+messages.set(ERR_INVALID_BRANCH_SIZE,                   // NJS-154
+  'size of the branch ID is %d and cannot exceed 64');
+messages.set(ERR_OPERATION_NOT_SUPPORTED_ON_BFILE,      // NJS-155
+  'operation is not supported on BFILE LOBs');
+messages.set(ERR_OPERATION_ONLY_SUPPORTED_ON_BFILE,     // NJS-156
+  'operation is only supported on BFILE LOBs');
+messages.set(ERR_EXECMANY_NOT_ALLOWED_ON_QUERIES,       // NJS-157
+  'executeMany() cannot be used with SELECT statement or WITH SQL clause');
 
 // Oracle Net layer errors
 
@@ -446,7 +478,7 @@ messages.set(ERR_CONNECTION_INCOMPLETE,                 // NJS-503
 messages.set(ERR_PROXY_CONNECTION_FAILURE,              // NJS-504
   'connection establishment through a web proxy at host %s port %d failed. (CONNECTION_ID=%s)\n%s');
 messages.set(ERR_TLS_INIT_FAILURE,                      // NJS-505
-  'unable to initiate TLS connection. Please check if wallet credentials are valid');
+  'unable to initiate TLS connection. Please check if wallet credentials are valid\n%s');
 messages.set(ERR_TLS_AUTH_FAILURE,                      // NJS-506
   'connection to host %s port %d encountered TLS handshake failure. (CONNECTION_ID=%s)\n%s');
 messages.set(ERR_TLS_DNMATCH_FAILURE,                   // NJS-507
@@ -479,7 +511,21 @@ messages.set(ERR_TNS_NAMES_FILE_MISSING,                // NJS-520
   'cannot connect to Oracle Database. File tnsnames.ora not found in %s');
 messages.set(ERR_CONNECTION_EOF,                        // NJS-521
   'connection to host %s port %d received end-of-file on communication channel. (CONNECTION_ID=%s)');
-
+messages.set(ERR_AZURE_CONFIG_PROVIDER_AUTH_FAILED,                        // NJS-522
+  'Azure Authentication Failed: The authentication parameter value %s may be incorrect');
+messages.set(ERR_CONFIG_PROVIDER_FAILED_TO_RETRIEVE_CONFIG,                        // NJS-523
+  'Failed to retrieve configuration from Centralized Configuration Provider:\n %s');
+messages.set(ERR_CONFIG_PROVIDER_NOT_SUPPORTED,               // NJS-524
+  'Configuration Provider not supported: %s');
+messages.set(ERR_CONFIG_PROVIDER_LOAD_FAILED,                 // NJS-525
+  'Centralized Config Provider failed to load required libraries. Please install the required libraries.\n %s');
+messages.set(ERR_OCIOBJECT_CONFIG_PROVIDER_AUTH_FAILED,                        // NJS-526
+  'OCI authentication failed: The authentication parameter value %s may be incorrect');
+messages.set(ERR_AZURE_VAULT_AUTH_FAILED,                        // NJS-527
+  'Azure Vault: Provide correct azure vault authentication details');
+messages.set(ERR_AZURE_SERVICE_PRINCIPAL_AUTH_FAILED,                        // NJS-528
+  'Azure service principal authentication requires either a client certificate path or a client secret string');
+messages.set(ERR_WALLET_TYPE_NOT_SUPPORTED, 'Invalid wallet content format. Supported format is PEM');// NJS-529
 // Oracle SUCCESS_WITH_INFO warning
 
 messages.set(WRN_COMPILATION_CREATE,                           // NJS-700
@@ -789,8 +835,16 @@ module.exports = {
   ERR_NO_CONFIG_DIR,
   ERR_TNS_ENTRY_NOT_FOUND,
   ERR_CONNECTION_EOF,
+  ERR_AZURE_CONFIG_PROVIDER_AUTH_FAILED,
+  ERR_OCIOBJECT_CONFIG_PROVIDER_AUTH_FAILED,
+  ERR_AZURE_VAULT_AUTH_FAILED,
+  ERR_AZURE_SERVICE_PRINCIPAL_AUTH_FAILED,
+  ERR_CONFIG_PROVIDER_FAILED_TO_RETRIEVE_CONFIG,
+  ERR_CONFIG_PROVIDER_NOT_SUPPORTED,
+  ERR_CONFIG_PROVIDER_LOAD_FAILED,
+  ERR_WALLET_TYPE_NOT_SUPPORTED,
   ERR_INVALID_BIND_NAME,
-  ERR_WRONG_NUMBER_OF_POSITIONAL_BINDS,
+  ERR_WRONG_NUMBER_OF_BINDS,
   ERR_BUFFER_LENGTH_INSUFFICIENT,
   ERR_NCHAR_CS_NOT_SUPPORTED,
   ERR_MISSING_CREDENTIALS,
@@ -841,7 +895,15 @@ module.exports = {
   ERR_OBJECT_IS_NOT_A_COLLECTION,
   ERR_CURSOR_HAS_BEEN_CLOSED,
   ERR_DML_RETURNING_DUP_BINDS,
+  ERR_INVALID_TPC_BEGIN_FLAGS,
+  ERR_INVALID_TPC_END_FLAGS,
+  ERR_UNKNOWN_TRANSACTION_STATE,
+  ERR_INVALID_TRANSACTION_SIZE,
+  ERR_INVALID_BRANCH_SIZE,
   ERR_CONNECTION_CLOSED_CODE: `${ERR_PREFIX}-${ERR_CONNECTION_CLOSED}`,
+  ERR_OPERATION_NOT_SUPPORTED_ON_BFILE,
+  ERR_OPERATION_ONLY_SUPPORTED_ON_BFILE,
+  ERR_EXECMANY_NOT_ALLOWED_ON_QUERIES,
   WRN_COMPILATION_CREATE,
   assert,
   assertArgCount,

package/lib/impl/aqQueue.js

@@ -27,8 +27,9 @@
 'use strict';
 
 const errors = require('../errors.js');
+const BaseImpl = require('./base.js');
 
-class AqQueueImpl {
+class AqQueueImpl extends BaseImpl {
 
   //---------------------------------------------------------------------------
   // _getConnImpl()

package/lib/impl/base.js

@@ -0,0 +1,45 @@
+// 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';
+
+class BaseImpl {
+
+  //---------------------------------------------------------------------------
+  // _getConnectTraceConfig()
+  //
+  // Retrieves connect trace config from connection object.
+  //---------------------------------------------------------------------------
+  _getConnectTraceConfig() {
+    const connImpl = this._getConnImpl();
+    if (connImpl) {
+      return connImpl._getConnectTraceConfig();
+    }
+  }
+
+}
+
+module.exports = BaseImpl;

package/lib/impl/connection.js

@@ -69,6 +69,32 @@ class ConnectionImpl {
     return this;
   }
 
+  //---------------------------------------------------------------------------
+  // _getConnectTraceConfig()
+  //
+  // returns the necessary connection config used for debug/trace.
+  // ---------------------------------------------------------------------------
+  _getConnectTraceConfig() {
+    let traceConfig;
+
+    if (this._pool) {
+      traceConfig = this._pool._getConnectTraceConfig();
+    } else {
+      traceConfig = {connectString: this._connectString, user: this._user};
+    }
+    traceConfig.serviceName = this.getServiceName();
+    traceConfig.instanceName = this.getInstanceName();
+    traceConfig.pdbName = this.getDbName();
+
+    // Thick mode doesnt have these properties for now.
+    if (settings.thin) {
+      traceConfig.hostName = this.getHostName();
+      traceConfig.port = this.getPort();
+      traceConfig.protocol = this.getProtocol();
+    }
+    return traceConfig;
+  }
+
   //---------------------------------------------------------------------------
   // _getDbObjectType()
   //
@@ -589,6 +615,33 @@ class ConnectionImpl {
     errors.throwNotImplemented("unsubscribing from events");
   }
 
+  //---------------------------------------------------------------------------
+  // getHostName()
+  //
+  // Returns the Oracle Database host name associated with the connection.
+  //---------------------------------------------------------------------------
+  getHostName() {
+    errors.throwNotImplemented("getting HostName");
+  }
+
+  //---------------------------------------------------------------------------
+  // getPort()
+  //
+  // Returns the Oracle Database port number associated with the connection.
+  //---------------------------------------------------------------------------
+  getPort() {
+    errors.throwNotImplemented("getting Port");
+  }
+
+  //---------------------------------------------------------------------------
+  // getProtocol()
+  //
+  // Returns the protocol associated with the connection.
+  //---------------------------------------------------------------------------
+  getProtocol() {
+    errors.throwNotImplemented("getting Protocol");
+  }
+
 }
 
 // export just the class

package/lib/impl/datahandlers/constants.js

@@ -32,7 +32,8 @@ module.exports = {
 
   // vector constants
   TNS_VECTOR_MAGIC_BYTE: 0xDB,
-  TNS_VECTOR_VERSION: 0,
+  TNS_VECTOR_VERSION_BASE: 0,
+  TNS_VECTOR_VERSION_WITH_BINARY: 1,
 
   // vector flags
   TNS_VECTOR_FLAG_NORMSRC: 0x0010,
@@ -99,6 +100,7 @@ module.exports = {
   VECTOR_FORMAT_FLOAT32: constants.VECTOR_FORMAT_FLOAT32,
   VECTOR_FORMAT_FLOAT64: constants.VECTOR_FORMAT_FLOAT64,
   VECTOR_FORMAT_INT8: constants.VECTOR_FORMAT_INT8,
+  VECTOR_FORMAT_BINARY: constants.VECTOR_FORMAT_BINARY,
 
   TNS_NULL_LENGTH_INDICATOR: 255,
   TNS_LONG_LENGTH_INDICATOR: 254,

package/lib/impl/datahandlers/vector.js

@@ -50,11 +50,11 @@ class VectorDecoder extends BaseBuffer {
       errors.throwErr(errors.ERR_UNEXPECTED_DATA,
         Buffer.from([magicByte]).toString('hex'));
     const version = this.readUInt8();
-    if (version != constants.TNS_VECTOR_VERSION)
+    if (version > constants.TNS_VECTOR_VERSION_WITH_BINARY)
       errors.throwErr(errors.ERR_VECTOR_VERSION_NOT_SUPPORTED, version);
     const flags = this.readUInt16BE();
     const vectorFormat = this.readUInt8();
-    const numElements = this.readUInt32BE();
+    let numElements = this.readUInt32BE();
     let elementSize, result;
     if (vectorFormat === constants.VECTOR_FORMAT_FLOAT32) {
       elementSize = 4;
@@ -65,10 +65,18 @@ class VectorDecoder extends BaseBuffer {
     } else if (vectorFormat === constants.VECTOR_FORMAT_INT8) {
       elementSize = 1;
       result = new Int8Array(numElements);
+    } else if (vectorFormat === constants.VECTOR_FORMAT_BINARY) {
+      elementSize = 1;
+      // The number of dimensions are assumed to be multiple of 8.
+      numElements = numElements / 8;
+      result = new Uint8Array(numElements);
     } else {
       errors.throwErr(errors.ERR_VECTOR_FORMAT_NOT_SUPPORTED, vectorFormat);
     }
-    if (flags & constants.TNS_VECTOR_FLAG_NORM)
+
+    // For binary vector, NORM will never be present but space for NORM is reserved to keep
+    // same header lengh across the different vector formats.
+    if (vectorFormat === constants.VECTOR_FORMAT_BINARY || flags & constants.TNS_VECTOR_FLAG_NORM)
       this.skipBytes(8);
 
     // parse data
@@ -100,6 +108,10 @@ class VectorEncoder extends GrowableBuffer {
     // determine some basic information about the vector
     let vectorFormat = constants.VECTOR_FORMAT_FLOAT32;
     let writeFn = this.writeBinaryFloat.bind(this);
+    let numElements = value.length;
+    let vectorVersion = constants.TNS_VECTOR_VERSION_BASE;
+    let flags = constants.TNS_VECTOR_FLAG_NORMSRC
+      | constants.TNS_VECTOR_FLAG_NORM; // NORM is present and reserve space.
 
     if (Array.isArray(value) || value instanceof Float64Array) {
       vectorFormat = constants.VECTOR_FORMAT_FLOAT64;
@@ -107,18 +119,21 @@ class VectorEncoder extends GrowableBuffer {
     } else if (value instanceof Int8Array) {
       vectorFormat = constants.VECTOR_FORMAT_INT8;
       writeFn = this.writeSB1.bind(this);
+    } else if (value.constructor.name === 'Uint8Array') {
+      vectorFormat = constants.VECTOR_FORMAT_BINARY;
+      // The number of dimensions are assumed to be multiple of 8.
+      numElements = numElements * 8;
+      vectorVersion = constants.TNS_VECTOR_VERSION_WITH_BINARY;
+      flags = constants.TNS_VECTOR_FLAG_NORMSRC; // only space is reserved.
+      writeFn = this.writeUInt8.bind(this);
     }
 
-    // Let server generate the norm (TNS_VECTOR_FLAG_NORMSRC)
-    const flags = constants.TNS_VECTOR_FLAG_NORM
-      | constants.TNS_VECTOR_FLAG_NORMSRC;
-
     // write header
     this.writeUInt8(constants.TNS_VECTOR_MAGIC_BYTE);
-    this.writeUInt8(constants.TNS_VECTOR_VERSION);
+    this.writeUInt8(vectorVersion);
     this.writeUInt16BE(flags);
     this.writeUInt8(vectorFormat);
-    this.writeUInt32BE(value.length);
+    this.writeUInt32BE(numElements);
     this.reserveBytes(8);
 
     // write data

package/lib/impl/lob.js

@@ -28,8 +28,9 @@
 
 const ConnectionImpl = require('./connection.js');
 const errors = require('../errors.js');
+const BaseImpl = require('./base.js');
 
-class LobImpl {
+class LobImpl extends BaseImpl {
 
   //---------------------------------------------------------------------------
   // _getConnImpl()
@@ -53,6 +54,15 @@ class LobImpl {
     errors.throwNotImplemented("closing a LOB");
   }
 
+  //---------------------------------------------------------------------------
+  // fileExists()
+  //
+  // Checks if BFILE present or not.
+  //---------------------------------------------------------------------------
+  fileExists() {
+    errors.throwNotImplemented("check if BFILE exists");
+  }
+
   //---------------------------------------------------------------------------
   // getData()
   //
@@ -62,6 +72,15 @@ class LobImpl {
     errors.throwNotImplemented("getting all of the data from a LOB");
   }
 
+  //---------------------------------------------------------------------------
+  // getDirFileName()
+  //
+  // returns directory and filename of LOB (BFILE).
+  //----------------------------------------------------------------------------
+  getDirFileName() {
+    errors.throwNotImplemented("getting directory and filename of LOB(BFILE)");
+  }
+
   //---------------------------------------------------------------------------
   // read()
   //
@@ -71,6 +90,15 @@ class LobImpl {
     errors.throwNotImplemented("reading from a LOB");
   }
 
+  //---------------------------------------------------------------------------
+  // setDirFileName()
+  //
+  // sets directory and filename for LOB (BFILE)
+  //---------------------------------------------------------------------------
+  setDirFileName() {
+    errors.throwNotImplemented("setting directory and filename of LOB(BFILE)");
+  }
+
   //---------------------------------------------------------------------------
   // write()
   //

package/lib/impl/pool.js

@@ -174,6 +174,21 @@ class PoolImpl {
     errors.throwNotImplemented("getting the pool statement cache size");
   }
 
+  //---------------------------------------------------------------------------
+  // _getConnectTraceConfig()
+  //
+  // Returns the necessary connection config used by pool for debug/trace.
+  //---------------------------------------------------------------------------
+  _getConnectTraceConfig() {
+    return {
+      connectString: this._connectString,
+      user: this._user,
+      poolMin: this.getPoolMin(),
+      poolMax: this.getPoolMax(),
+      poolIncrement: this.getPoolIncrement()
+    };
+  }
+
   //---------------------------------------------------------------------------
   // getSodaMetaDataCache()
   //