oracledb 6.3.0 → 6.5.0

package/lib/thin/pool.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -53,6 +53,7 @@ class ThinPoolImpl extends PoolImpl {
     this._poolIncrement = params.poolIncrement;
     this._poolTimeout = params.poolTimeout;
     this._poolPingInterval = params.poolPingInterval;
+    this._poolPingTimeout = params.poolPingTimeout;
     this._stmtCacheSize = params.stmtCacheSize;
 
     // The user Config filterd from common layer is cached except
@@ -104,6 +105,7 @@ class ThinPoolImpl extends PoolImpl {
     this._accessTokenFn = params.accessTokenFn;
     this._accessTokenConfig = params.accessTokenConfig;
     this._isDRCPEnabled = false;
+    this._implicitPool = null;
     this.eventEmitter = new EventEmitter();
     // listener to remove dead or idle connections
     this.eventEmitter.on('_removePoolConnection', async (connImpl) => {
@@ -318,6 +320,13 @@ class ThinPoolImpl extends PoolImpl {
     return this._poolPingInterval;
   }
 
+  //---------------------------------------------------------------------------
+  // returns the pool ping Timeout (milliseconds)
+  //---------------------------------------------------------------------------
+  getPoolPingTimeout() {
+    return this._poolPingTimeout;
+  }
+
   //---------------------------------------------------------------------------
   // returns the pool timeout
   //---------------------------------------------------------------------------
@@ -363,13 +372,13 @@ class ThinPoolImpl extends PoolImpl {
   _scanIdleConnection() {
     while ((this._usedConnectionList.size + this._freeConnectionList.length) >
         this._poolMin && this._freeConnectionList.length > 0) {
-      const conn = this._freeConnectionList[this._freeConnectionList.length - 1];
+      const conn = this._freeConnectionList[0];
       if (Date.now() - conn._lastTimeUsed < this._poolTimeout * 1000) {
         break;
       }
 
       this.eventEmitter.emit('_removePoolConnection', conn);
-      this._freeConnectionList.pop();
+      this._freeConnectionList.shift();
     }
 
     this._schedulerJob = null;
@@ -377,11 +386,11 @@ class ThinPoolImpl extends PoolImpl {
   }
 
   //---------------------------------------------------------------------------
-  // _getNumConns()
+  // _getNumConnsToCreate()
   //
   // get number of connections need to be created
   //---------------------------------------------------------------------------
-  _getNumConns() {
+  _getNumConnsToCreate() {
     const usedConns = this._freeConnectionList.length + this._usedConnectionList.size;
     // less connections in the pool than poolMin? restore to poolMin
     if (usedConns < this._poolMin) {
@@ -407,11 +416,19 @@ class ThinPoolImpl extends PoolImpl {
 
     // continue until a close request is received
     while (!this._poolCloseWaiter) {
-      // get count for connections to be created
-      const numConns = this._getNumConns();
+      // eliminate connections that exceed the poolMax (this should only happen
+      // after a reconfiguration has taken place where the maximum number of
+      // connections is reduced)
+      let numToDestroy = this._poolMax - this.getConnectionsOpen();
+      while (numToDestroy > 0 && this._freeConnectionList.length > 0) {
+        const connToBeRemoved = this._freeConnectionList.shift();
+        this.eventEmitter.emit('_removePoolConnection', connToBeRemoved);
+        numToDestroy--;
+      }
 
+      const numToCreate = this._getNumConnsToCreate();
       // connection creation is going on serially and not concurrently
-      for (let i = 0; i < numConns; i++) {
+      for (let i = 0; i < numToCreate; i++) {
         try {
           // get deobfuscated value
           const config = await this._getConnAttrs();
@@ -495,11 +512,21 @@ class ThinPoolImpl extends PoolImpl {
           requiresPing = true;
       }
       if (requiresPing) {
+        let pingTimer;
         try {
+          if (this._poolPingTimeout) {
+            pingTimer = setTimeout(() => {
+              // force disconnect causes ping task to unblock
+              // and return.
+              conn.nscon.forceDisconnect();
+            }, this._poolPingTimeout);
+          }
           await conn.ping();
         } catch {
-          this.eventEmitter.emit('_removePoolConnection', conn);
+          conn.nscon.forceDisconnect();
           continue;
+        } finally {
+          clearTimeout(pingTimer);
         }
       }
 
@@ -546,8 +573,14 @@ class ThinPoolImpl extends PoolImpl {
     if (conn.nscon.connected) {
       conn._lastTimeUsed = Date.now();
       conn._newSession = false;
-      this._freeConnectionList.push(conn);
+      if ((this._freeConnectionList.length + this._usedConnectionList.size)
+        < this._poolMax) {
+        this._freeConnectionList.push(conn);
+      } else {
+        this.eventEmitter.emit('_removePoolConnection', conn);
+      }
     }
+
     this._setScheduler();
   }
 
@@ -560,6 +593,47 @@ class ThinPoolImpl extends PoolImpl {
     this._userConfig.connectionClass = crypto.randomBytes(16).toString('base64');
     this._userConfig.connectionClass = "NJS:" + this._userConfig.connectionClass;
   }
+
+  //---------------------------------------------------------------------------
+  // reconfigure()
+  //
+  // Reconfigures the pool with new parameters
+  //---------------------------------------------------------------------------
+  reconfigure(params) {
+    if (params.poolIncrement !== undefined) {
+      this._poolIncrement = params.poolIncrement;
+    }
+
+    if (params.poolTimeout !== undefined &&
+      this._poolTimeout !== params.poolTimeout) {
+      this._poolTimeout = params.poolTimeout;
+      // clear scheduled job
+      if (this._schedulerJob) {
+        clearTimeout(this._schedulerJob);
+        this._schedulerJob = null;
+      }
+    }
+
+    if (params.poolPingInterval !== undefined) {
+      this._poolPingInterval = params.poolPingInterval;
+    }
+
+    if (params.stmtCacheSize !== undefined) {
+      this._stmtCacheSize = params.stmtCacheSize;
+    }
+
+    if (params.poolMax !== undefined) {
+      this._poolMax = params.poolMax;
+    }
+
+    if (params.poolMin !== undefined) {
+      this._poolMin = params.poolMin;
+    }
+
+    if (this.bgWaiter) {
+      this.bgWaiter();
+    }
+  }
 }
 
 module.exports = ThinPoolImpl;

package/lib/thin/protocol/capabilities.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -36,25 +36,32 @@ const errors = require('../../errors');
  */
 class Capabilities {
 
-  constructor(protocolVersion) {
-    this.protocolVersion = protocolVersion;
+  constructor(nscon) {
+    this.protocolVersion = nscon.sAtts.version;
     this.ttcFieldVersion = constants.TNS_CCAP_FIELD_VERSION_MAX;
     this.supports12cLogon = true;
     this.supportsOob = false;
     this.nCharsetId = constants.TNS_CHARSET_UTF16;
     this.compileCaps = Buffer.alloc(constants.TNS_CCAP_MAX);
     this.runtimeCaps = Buffer.alloc(constants.TNS_RCAP_MAX);
-    this.initCompileCaps();
+    this.initCompileCaps(nscon);
     this.initRuntimeCaps();
     this.maxStringSize = 0;
   }
 
-  adjustForServerCompileCaps(serverCaps) {
+  adjustForServerCompileCaps(serverCaps, nscon) {
     if (serverCaps[constants.TNS_CCAP_FIELD_VERSION] < this.ttcFieldVersion) {
       this.ttcFieldVersion = serverCaps[constants.TNS_CCAP_FIELD_VERSION];
       this.compileCaps[constants.TNS_CCAP_FIELD_VERSION] =
         this.ttcFieldVersion;
     }
+    if ((this.ttcFieldVersion < constants.TNS_CCAP_FIELD_VERSION_23_4
+      && nscon.endOfRequestSupport)) {
+      // endOfRequestSupport used only from 23.4 onwards and not for 23.3
+      this.compileCaps[constants.TNS_CCAP_TTC4]
+        ^= constants.TNS_CCAP_END_OF_REQUEST;
+      nscon.endOfRequestSupport = false;
+    }
   }
 
   adjustForServerRuntimeCaps(serverCaps) {
@@ -65,7 +72,7 @@ class Capabilities {
     }
   }
 
-  initCompileCaps() {
+  initCompileCaps(nscon) {
     this.compileCaps[constants.TNS_CCAP_SQL_VERSION] =
       constants.TNS_CCAP_SQL_VERSION_MAX;
     this.compileCaps[constants.TNS_CCAP_LOGON_TYPES] =
@@ -104,6 +111,13 @@ class Capabilities {
       constants.TNS_CCAP_CLIENT_FN_MAX;
     this.compileCaps[constants.TNS_CCAP_TTC4] =
       constants.TNS_CCAP_INBAND_NOTIFICATION;
+    if (nscon.endOfRequestSupport) {
+      this.compileCaps[constants.TNS_CCAP_TTC4] |= constants.TNS_CCAP_END_OF_REQUEST;
+    }
+    this.compileCaps[constants.TNS_CCAP_CTB_FEATURE_BACKPORT] =
+      constants.TNS_CCAP_CTB_IMPLICIT_POOL;
+    this.compileCaps[constants.TNS_CCAP_TTC5] =
+      constants.TNS_CCAP_VECTOR_SUPPORT;
   }
 
   initRuntimeCaps() {

package/lib/thin/protocol/constants.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.js');
+const dataHandlerConstants = require('../../impl/datahandlers/constants.js');
 
 module.exports = {
 
@@ -198,6 +199,7 @@ module.exports = {
   TNS_DATA_TYPE_UD12: 124 + 256,
   TNS_DATA_TYPE_AL8: 125 + 256,
   TNS_DATA_TYPE_LFOP: 126 + 256,
+  TNS_DATA_TYPE_VECTOR: 127,
   TNS_DATA_TYPE_FCRT: 127 + 256,
   TNS_DATA_TYPE_DNY: 128 + 256,
   TNS_DATA_TYPE_OPR: 129 + 256,
@@ -431,7 +433,8 @@ module.exports = {
   TNS_MSG_TYPE_ONEWAY_FN: 26,
   TNS_MSG_TYPE_IMPLICIT_RESULTSET: 27,
   TNS_MSG_TYPE_RENEGOTIATE: 28,
-  TNS_MSG_TYPE_COOKIE: 30,
+  TNS_MSG_TYPE_END_OF_REQUEST: 29,
+  TNS_MSG_TYPE_FAST_AUTH: 34,
 
   // parameter keyword numbers,
   TNS_KEYWORD_NUM_CURRENT_SCHEMA: 168,
@@ -462,6 +465,7 @@ module.exports = {
   TNS_EXEC_OPTION_DESCRIBE: 0x20000,
   TNS_EXEC_OPTION_NO_COMPRESSED_FETCH: 0x40000,
   TNS_EXEC_OPTION_BATCH_ERRORS: 0x80000,
+  TNS_EXEC_OPTION_NO_IMPL_REL: 0x200000,
 
   // server side piggyback op codes
   TNS_SERVER_PIGGYBACK_QUERY_CACHE_INVALIDATION: 1,
@@ -513,42 +517,6 @@ module.exports = {
 
   // base JSON constants
   TNS_JSON_MAX_LENGTH: 32 * 1024 * 1024,
-  TNS_JSON_MAGIC_BYTE_1: 0xff,
-  TNS_JSON_MAGIC_BYTE_2: 0x4a,       // 'J'
-  TNS_JSON_MAGIC_BYTE_3: 0x5a,       // 'Z'
-  TNS_JSON_VERSION: 1,
-  TNS_JSON_FLAG_HASH_ID_UINT8: 0x0100,
-  TNS_JSON_FLAG_HASH_ID_UINT16: 0x0200,
-  TNS_JSON_FLAG_NUM_FNAMES_UINT16: 0x0400,
-  TNS_JSON_FLAG_FNAMES_SEG_UINT32: 0x0800,
-  TNS_JSON_FLAG_TINY_NODES_STAT: 0x2000,
-  TNS_JSON_FLAG_TREE_SEG_UINT32: 0x1000,
-  TNS_JSON_FLAG_REL_OFFSET_MODE: 0x01,
-  TNS_JSON_FLAG_INLINE_LEAF: 0x02,
-  TNS_JSON_FLAG_LEN_IN_PCODE: 0x04,
-  TNS_JSON_FLAG_NUM_FNAMES_UINT32: 0x08,
-  TNS_JSON_FLAG_IS_SCALAR: 0x10,
-
-  // JSON data types
-  TNS_JSON_TYPE_NULL: 0x30,
-  TNS_JSON_TYPE_TRUE: 0x31,
-  TNS_JSON_TYPE_FALSE: 0x32,
-  TNS_JSON_TYPE_STRING_LENGTH_UINT8: 0x33,
-  TNS_JSON_TYPE_NUMBER_LENGTH_UINT8: 0x34,
-  TNS_JSON_TYPE_BINARY_DOUBLE: 0x36,
-  TNS_JSON_TYPE_STRING_LENGTH_UINT16: 0x37,
-  TNS_JSON_TYPE_STRING_LENGTH_UINT32: 0x38,
-  TNS_JSON_TYPE_TIMESTAMP: 0x39,
-  TNS_JSON_TYPE_BINARY_LENGTH_UINT16: 0x3a,
-  TNS_JSON_TYPE_BINARY_LENGTH_UINT32: 0x3b,
-  TNS_JSON_TYPE_DATE: 0x3c,
-  TNS_JSON_TYPE_INTERVAL_YM: 0x3d,
-  TNS_JSON_TYPE_INTERVAL_DS: 0x3e,
-  TNS_JSON_TYPE_TIMESTAMP_TZ: 0x7c,
-  TNS_JSON_TYPE_TIMESTAMP7: 0x7d,
-  TNS_JSON_TYPE_BINARY_FLOAT: 0x7f,
-  TNS_JSON_TYPE_OBJECT: 0x84,
-  TNS_JSON_TYPE_ARRAY: 0xc0,
 
   // end-to-end metrics
   TNS_END_TO_END_ACTION: 0x0010,
@@ -592,6 +560,7 @@ module.exports = {
   // compile time capability indices
   TNS_CCAP_SQL_VERSION: 0,
   TNS_CCAP_LOGON_TYPES: 4,
+  TNS_CCAP_CTB_FEATURE_BACKPORT: 5,
   TNS_CCAP_FIELD_VERSION: 7,
   TNS_CCAP_SERVER_DEFINE_CONV: 8,
   TNS_CCAP_TTC1: 15,
@@ -608,7 +577,8 @@ module.exports = {
   TNS_CCAP_TTC3: 37,
   TNS_CCAP_TTC4: 40,
   TNS_CCAP_LOB2: 42,
-  TNS_CCAP_MAX: 45,
+  TNS_CCAP_TTC5: 44,
+  TNS_CCAP_MAX: 51,
 
   // compile time capability values
   TNS_CCAP_SQL_VERSION_MAX: 6,
@@ -630,7 +600,8 @@ module.exports = {
   TNS_CCAP_FIELD_VERSION_23_1_EXT_4: 21,
   TNS_CCAP_FIELD_VERSION_23_1_EXT_5: 22,
   TNS_CCAP_FIELD_VERSION_23_1_EXT_6: 23,
-  TNS_CCAP_FIELD_VERSION_MAX: 23,
+  TNS_CCAP_FIELD_VERSION_23_4: 24,
+  TNS_CCAP_FIELD_VERSION_MAX: 24,
   TNS_CCAP_O5LOGON: 8,
   TNS_CCAP_O5LOGON_NP: 2,
   TNS_CCAP_O7LOGON: 32,
@@ -657,9 +628,12 @@ module.exports = {
   TNS_CCAP_DRCP: 0x10,
   TNS_CCAP_ZLNP: 0x04,
   TNS_CCAP_INBAND_NOTIFICATION: 0x04,
+  TNS_CCAP_END_OF_REQUEST: 0x20,
   TNS_CCAP_CLIENT_FN_MAX: 12,
   TNS_CCAP_LOB2_QUASI: 0x01,
   TNS_CCAP_LOB2_2GB_PREFETCH: 0x04,
+  TNS_CCAP_CTB_IMPLICIT_POOL: 0x08,
+  TNS_CCAP_VECTOR_SUPPORT: 0x08,
 
   // runtime capability indices
   TNS_RCAP_COMPAT: 0,
@@ -680,28 +654,24 @@ module.exports = {
 
   // UDS flags
   TNS_UDS_FLAGS_IS_JSON: 0x00000100,
+  TNS_UDS_FLAGS_IS_OSON: 0x00000800,
+
+  // end of call status flags
+  TNS_EOCS_FLAGS_TXN_IN_PROGRESS: 0x00000002,
+  TNS_EOCS_FLAGS_SESS_RELEASE: 0x00008000,
 
   // other constants
-  TNS_MAX_SHORT_LENGTH: 252,
   TNS_ESCAPE_CHAR: 253,
-  TNS_LONG_LENGTH_INDICATOR: 254,
-  TNS_NULL_LENGTH_INDICATOR: 255,
+  TNS_LONG_LENGTH_INDICATOR: dataHandlerConstants.TNS_LONG_LENGTH_INDICATOR,
+  TNS_NULL_LENGTH_INDICATOR: dataHandlerConstants.TNS_NULL_LENGTH_INDICATOR,
   TNS_MAX_ROWID_LENGTH: 18,
-  TNS_DURATION_MID: 0x80000000,
-  TNS_DURATION_OFFSET: 60,
   TNS_DURATION_SESSION: 10,
   TNS_MAX_LONG_LENGTH: 0x7fffffff,
   TNS_SDU: 8192,
   TNS_TDU: 65535,
-  TNS_TXN_IN_PROGRESS: 0x00000002,
   TNS_MAX_CONNECT_DATA: 230,
-  TNS_CHUNK_SIZE: 32767,
   TNS_MAX_UROWID_LENGTH: 3950,
-  TNS_HAS_REGION_ID: 0x80,
-
-  // timezone offsets
-  TZ_HOUR_OFFSET: 20,
-  TZ_MINUTE_OFFSET: 60,
+  TNS_SERVER_CONVERTS_CHARS: 0x01, // server does charset conversion
 
   // drcp release mode
   DRCP_DEAUTHENTICATE: 0x00000002,
@@ -742,6 +712,10 @@ module.exports = {
   TNS_OBJ_TDS_TYPE_BLOB: 30,
   TNS_OBJ_TDS_TYPE_TIMESTAMP_LTZ: 33,
   TNS_OBJ_TDS_TYPE_BINARY_FLOAT: 37,
+  TNS_OBJ_TDS_TYPE_START_EMBED_ADT: 39,
+  TNS_OBJ_TDS_TYPE_END_EMBED_ADT: 40,
+  TNS_OBJ_TDS_TYPE_SUBTYPE_MARKER: 43,
+  TNS_OBJ_TDS_TYPE_EMBED_ADT_INFO: 44,
   TNS_OBJ_TDS_TYPE_BINARY_DOUBLE: 45,
 
   // xml type constants
@@ -760,13 +734,19 @@ module.exports = {
   // warnings
   TNS_WARN_COMPILATION_CREATE: 0x20,
 
+  // vector constants
+  TNS_VECTOR_MAX_LENGTH: 1048576,
+  VECTOR_FORMAT_FLEX: 0,
+  VECTOR_META_FLAG_FLEXIBLE_DIM: 1,
+
   // other constants
   PACKET_HEADER_SIZE: 8,
   NUMBER_AS_TEXT_CHARS: 172,
-  NUMBER_MAX_DIGITS: 40,
-  BUFFER_CHUNK_SIZE: 65536,
   CHUNKED_BYTES_CHUNK_SIZE: 65536,
 
+  // Network Header flags for Data packet
+  TNS_DATA_FLAGS_END_OF_REQUEST: 0x2000,
+
   TNS_BASE64_ALPHABET_ARRAY: Buffer.from('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'),
   TNS_EXTENT_OID: Buffer.from('00000000000000000000000000010001', 'hex')
 };

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

@@ -181,7 +181,7 @@ class AuthMessage extends Message {
       if (this.userByteLen > 0) {
         buf.writeBytesWithLength(Buffer.from(this.username));
       }
-      buf.writeKeyValue("AUTH_TERMINAL", "unknown");
+      buf.writeKeyValue("AUTH_TERMINAL", cInfo.terminal);
       buf.writeKeyValue("AUTH_PROGRAM_NM", cInfo.program);
       buf.writeKeyValue("AUTH_MACHINE", cInfo.hostName);
       buf.writeKeyValue("AUTH_PID", cInfo.pid);
@@ -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.
 
 //-----------------------------------------------------------------------------
 //
@@ -42,10 +42,9 @@ class Message {
     this.functionCode = 0;
     this.callStatus = 0;
     this.flushOutBinds = false;
+    this.endOfResponse = false;
     this.endToEndSeqNum = 0;
     this.errorOccurred = false;
-    this.flushOutBinds = false;
-    this.processedError = false;
     this.warning = undefined;
   }
 
@@ -90,11 +89,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 +106,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 +128,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);
@@ -154,7 +160,7 @@ class Message {
        */
       this.errorInfo.message = this.errorInfo.message.trim();
     }
-    this.processedError = true;
+    this.endOfResponse = !this.connection.nscon.endOfRequestSupport;
   }
 
   processReturnParameter() { }
@@ -171,22 +177,18 @@ class Message {
     }
   }
 
-  hasMoreData(buf) {
-    return buf.numBytesLeft() > 0 && !this.flushOutBinds;
-  }
-
   decode(buf) {
     this.process(buf);
   }
 
   process(buf) {
+    this.endOfResponse = false;
     this.flushOutBinds = false;
-    this.processedError = false;
     do {
       this.savePoint(buf);
       const messageType = buf.readUInt8();
       this.processMessage(buf, messageType);
-    } while (this.hasMoreData(buf));
+    } while (!this.endOfResponse);
   }
 
   savePoint(buf) {
@@ -201,10 +203,13 @@ class Message {
     } else if (messageType === constants.TNS_MSG_TYPE_STATUS) {
       this.callStatus = buf.readUB4();
       this.endToEndSeqNum = buf.readUB2();
+      this.endOfResponse = !this.connection.nscon.endOfRequestSupport;
     } else if (messageType === constants.TNS_MSG_TYPE_PARAMETER) {
       this.processReturnParameter(buf);
     } else if (messageType === constants.TNS_MSG_TYPE_SERVER_SIDE_PIGGYBACK) {
       this.processServerSidePiggyBack(buf);
+    } else if (messageType === constants.TNS_MSG_TYPE_END_OF_REQUEST) {
+      this.endOfResponse = true;
     } else {
       errors.throwErr(errors.ERR_UNEXPECTED_MESSAGE_TYPE, messageType, buf.pos, buf.packetNum);
     }
@@ -275,7 +280,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.clearCursors();
         }
       }
       this.connection._drcpEstablishSession = false;
@@ -290,7 +295,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 +324,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.
 
 //-----------------------------------------------------------------------------
 //
@@ -48,6 +48,7 @@ class DataTypeMessage extends Message {
         if (convDataType !== 0)
           buf.skipBytes(4);
       }
+      this.endOfResponse = !this.connection.nscon.endOfRequestSupport;
     } else {
       super.processMessage(buf, messageType);
     }
@@ -392,7 +393,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/execute.js

@@ -68,13 +68,17 @@ class ExecuteMessage extends MessageWithData {
     const stmt = this.statement;
     const params = stmt.bindInfoList;
 
+    if (this.noImplicitRelease) {
+      dmlOptions |= constants.TNS_EXEC_OPTION_NO_IMPL_REL;
+    }
+
     if (!stmt.requiresDefine && !this.parseOnly && params) {
       numParams = params.length;
     }
     if (stmt.requiresDefine) {
       options |= constants.TNS_EXEC_OPTION_DEFINE;
     } else if (!this.parseOnly && stmt.sql) {
-      dmlOptions = constants.TNS_EXEC_OPTION_IMPLICIT_RESULTSET;
+      dmlOptions |= constants.TNS_EXEC_OPTION_IMPLICIT_RESULTSET;
       options |= constants.TNS_EXEC_OPTION_EXECUTE;
     }
     if (stmt.cursorId === 0 || stmt.isDdl) {