oracledb 6.4.0 → 6.5.1

package/lib/impl/datahandlers/vector.js

@@ -54,14 +54,7 @@ class VectorDecoder extends BaseBuffer {
       errors.throwErr(errors.ERR_VECTOR_VERSION_NOT_SUPPORTED, version);
     const flags = this.readUInt16BE();
     const vectorFormat = this.readUInt8();
-    let numElements;
-    if (flags & constants.TNS_VECTOR_FLAG_DIM_UINT8) {
-      numElements = this.readUInt8();
-    } else if (flags & constants.TNS_VECTOR_FLAG_DIM_UINT32) {
-      numElements = this.readUInt32BE();
-    } else {
-      numElements = this.readUInt16BE();
-    }
+    const numElements = this.readUInt32BE();
     let elementSize, result;
     if (vectorFormat === constants.VECTOR_FORMAT_FLOAT32) {
       elementSize = 4;
@@ -117,27 +110,15 @@ class VectorEncoder extends GrowableBuffer {
     }
 
     // Let server generate the norm (TNS_VECTOR_FLAG_NORMSRC)
-    let flags = constants.TNS_VECTOR_FLAG_NORM
+    const flags = constants.TNS_VECTOR_FLAG_NORM
       | constants.TNS_VECTOR_FLAG_NORMSRC;
-    const numElements = value.length;
-    if (numElements < 256) {
-      flags |= constants.TNS_VECTOR_FLAG_DIM_UINT8;
-    } else if (numElements > 65535) {
-      flags |= constants.TNS_VECTOR_FLAG_DIM_UINT32;
-    }
 
     // write header
     this.writeUInt8(constants.TNS_VECTOR_MAGIC_BYTE);
     this.writeUInt8(constants.TNS_VECTOR_VERSION);
     this.writeUInt16BE(flags);
     this.writeUInt8(vectorFormat);
-    if (numElements < 256) {
-      this.writeUInt8(numElements);
-    } else if (numElements < 65536) {
-      this.writeUInt16BE(numElements);
-    } else {
-      this.writeUInt32BE(numElements);
-    }
+    this.writeUInt32BE(value.length);
     this.reserveBytes(8);
 
     // write data

package/lib/oracledb.js

@@ -118,24 +118,6 @@ function _initializeThinDriver() {
   require('./thin');
 }
 
-//---------------------------------------------------------------------------
-// _isPrivilege()
-//
-// Returns a boolean indicating if the supplied value is a valid privilege.
-//---------------------------------------------------------------------------
-function _isPrivilege(value) {
-  return (
-    value === constants.SYSASM ||
-    value === constants.SYSBACKUP ||
-    value === constants.SYSDBA ||
-    value === constants.SYSDG ||
-    value === constants.SYSKM ||
-    value === constants.SYSOPER ||
-    value === constants.SYSPRELIM ||
-    value === constants.SYSRAC
-  );
-}
-
 //-----------------------------------------------------------------------------
 // _verifyOptions()
 //
@@ -322,6 +304,13 @@ async function _verifyOptions(options, inCreatePool) {
     outOptions.connectionIdPrefix = options.connectionIdPrefix;
   }
 
+  // privilege must be one of a set of named constants
+  if (options.privilege !== undefined) {
+    errors.assertParamPropValue(nodbUtil.isPrivilege(options.privilege), 1,
+      "privilege");
+    outOptions.privilege = options.privilege;
+  }
+
   // check pool specific options
   if (inCreatePool) {
 
@@ -435,13 +424,6 @@ async function _verifyOptions(options, inCreatePool) {
       outOptions.newPassword = options.newPassword;
     }
 
-    // privilege must be one of a set of named constants
-    if (options.privilege !== undefined) {
-      errors.assertParamPropValue(_isPrivilege(options.privilege), 1,
-        "privilege");
-      outOptions.privilege = options.privilege;
-    }
-
     // shardingKey must be an array of values
     if (options.shardingKey !== undefined) {
       const value = options.shardingKey;
@@ -832,6 +814,7 @@ module.exports = {
   AqQueue,
   BaseDbObject,
   Connection,
+  JsonId: types.JsonId,
   Lob,
   Pool,
   PoolStatistics,

package/lib/pool.js

@@ -238,6 +238,13 @@ class Pool extends EventEmitter {
       outOptions.superShardingKey = options.superShardingKey;
     }
 
+    // privilege must be one of a set of named constants
+    if (options.privilege !== undefined) {
+      errors.assertParamPropValue(nodbUtil.isPrivilege(options.privilege), 1,
+        "privilege");
+      outOptions.privilege = options.privilege;
+    }
+
     return outOptions;
   }
 
@@ -681,7 +688,7 @@ class Pool extends EventEmitter {
     errors.assertParamPropBool(options, 1, "enableStatistics");
     errors.assertParamPropBool(options, 1, "resetStatistics");
     errors.assertParamPropUnsignedInt(options, 1, "poolMin");
-    errors.assertParamPropUnsignedInt(options, 1, "poolMax");
+    errors.assertParamPropUnsignedIntNonZero(options, 1, "poolMax");
     errors.assertParamPropUnsignedInt(options, 1, "poolMaxPerShard");
     errors.assertParamPropUnsignedInt(options, 1, "poolIncrement");
     errors.assertParamPropInt(options, 1, "poolPingInterval");
@@ -689,6 +696,12 @@ class Pool extends EventEmitter {
     errors.assertParamPropUnsignedInt(options, 1, "stmtCacheSize");
     errors.assertParamPropBool(options, 1, "sodaMetaDataCache");
 
+    // poolMax must be greater than or equal to poolMin
+    if (options.poolMin > options.poolMax) {
+      errors.throwErr(errors.ERR_INVALID_NUMBER_OF_CONNECTIONS, options.poolMax,
+        options.poolMin);
+    }
+
     // reconfiguration can happen only when status is OPEN
     this._checkPoolOpen(false);
 

package/lib/settings.js

@@ -63,6 +63,7 @@ class Settings {
     this.thinDriverInitialized = false;
     this.createFetchTypeMap(this.fetchAsString, this.fetchAsBuffer);
     this.fetchTypeHandler = undefined;
+    this._JsonId = types.JsonId;
   }
 
   //---------------------------------------------------------------------------

package/lib/thin/connection.js

@@ -50,8 +50,6 @@ const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
 class TDSBuffer extends BaseBuffer {
 }
 
-const connectionCookies = new Map();
-
 class ThinConnectionImpl extends ConnectionImpl {
 
   /**
@@ -183,12 +181,20 @@ class ThinConnectionImpl extends ConnectionImpl {
     message.numExecs = numIters;
     message.arrayDmlRowCounts = options.dmlRowCounts;
     message.batchErrors = options.batchErrors;
-    if (statement.isPlSql && statement.requiresFullExecute) {
+
+    // if a PL/SQL statement requires a full execute, perform only a single
+    // iteration in order to allow the determination of input/output binds
+    // to be completed; after that, an execution of the remaining iterations
+    // can be performed.
+    if (statement.isPlSql && (statement.cursorId === 0 ||
+      statement.requiresFullExecute)) {
       message.numExecs = 1;
+      message.noImplicitRelease = true;
       await this._protocol._processMessage(message);
       statement.requiresFullExecute = false;
       message.numExecs = numIters - 1;
       message.offset = 1;
+      message.noImplicitRelease = false;
     }
     if (message.numExecs > 0) {
       await this._protocol._processMessage(message);
@@ -588,26 +594,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     return (this._pool) ? true : false;
   }
 
-  //---------------------------------------------------------------------------
-  // getConnectionCookieByUUID()
-  //
-  // It fetches from map which keeps keyname as UUID+ServiceName.
-  // UUID identifies the CDB instance and ServiceName identifies the
-  // entity within a PDB which uniquely identifies a pdb instance.
-  //---------------------------------------------------------------------------
-  getConnectionCookieByUUID(uuid) {
-    let cookie;
-    if (uuid) {
-      const key = uuid + ((this.serviceName) ? this.serviceName : this.sid);
-      cookie = connectionCookies.get(key);
-      if (!cookie) {
-        cookie = {};
-        connectionCookies.set(key, cookie);
-      }
-    }
-    return cookie;
-  }
-
   /**
    *
    * @param {object} params  Configuration of the connection
@@ -692,37 +678,24 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     try {
-      const cookie = this.getConnectionCookieByUUID(this.nscon.dbUUID);
-      this.nscon.dbUUID = null;
       const protocolMessage = new messages.ProtocolMessage(this);
       const dataTypeMessage = new messages.DataTypeMessage(this);
       const authMessage = new messages.AuthMessage(this, params);
-      let sentCookie = false;
-      if (cookie && cookie.populated) {
-        const cookieMessage = new messages.ConnectionCookieMessage(this);
-        cookieMessage.cookie = cookie;
-        cookieMessage.protocolMessage = protocolMessage;
-        cookieMessage.dataTypeMessage = dataTypeMessage;
-        cookieMessage.authMessage = authMessage;
-        await this._protocol._processMessage(cookieMessage);
-        sentCookie = true;
+      if (this.nscon.supportsFastAuth) {
+        const fastAuthMessage = new messages.FastAuthMessage(this);
+        fastAuthMessage.protocolMessage = protocolMessage;
+        fastAuthMessage.dataTypeMessage = dataTypeMessage;
+        fastAuthMessage.authMessage = authMessage;
+        await this._protocol._processMessage(fastAuthMessage);
+        if (fastAuthMessage.reNegotiate) {
+          // Fast Authentication failed.
+          await this._protocol._processMessage(dataTypeMessage);
+          await this._protocol._processMessage(authMessage);
+        }
       } else {
         await this._protocol._processMessage(protocolMessage);
-      }
-      if (!sentCookie || !cookie.populated) {
         await this._protocol._processMessage(dataTypeMessage);
-        // Does OSESSKEY for non-token Authentication else OAUTH
         await this._protocol._processMessage(authMessage);
-        if (cookie && !cookie.populated) {
-          cookie.protocolVersion = protocolMessage.serverVersion;
-          cookie.serverBanner = protocolMessage.serverBanner;
-          cookie.charsetID = this._protocol.caps.charSetID;
-          cookie.ncharsetID = this._protocol.caps.nCharsetId;
-          cookie.flags = protocolMessage.serverFlags;
-          cookie.compileCaps = Buffer.from(protocolMessage.serverCompileCaps);
-          cookie.runtimeCaps = Buffer.from(protocolMessage.serverRunTimeCaps);
-          cookie.populated = true;
-        }
       }
       if (!params.token) { // non-token Authentication
         await this._protocol._processMessage(authMessage); // OAUTH
@@ -922,10 +895,8 @@ class ThinConnectionImpl extends ConnectionImpl {
   // new session is going to be used.
   //---------------------------------------------------------------------------
   _getStatement(sql, cacheStatement = false) {
-    if (this._drcpEstablishSession) {
-      cacheStatement = false;
-    }
-    return this.statementCache.getStatement(sql, cacheStatement);
+    return this.statementCache.getStatement(sql, cacheStatement,
+      this._drcpEstablishSession);
   }
 
   //---------------------------------------------------------------------------
@@ -1077,7 +1048,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   // Returns boolean based on this._protocol.txnInProgress value.
   //---------------------------------------------------------------------------
   getTransactionInProgress() {
-    return this._protocol.txnInProgress === constants.TNS_TXN_IN_PROGRESS;
+    return this._protocol.txnInProgress;
   }
 
   //---------------------------------------------------------------------------

package/lib/thin/pool.js

@@ -105,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) => {
@@ -385,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) {
@@ -415,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();
@@ -564,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();
   }
 
@@ -578,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

@@ -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,11 @@ 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;
   }

package/lib/thin/protocol/constants.js

@@ -433,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,
@@ -464,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,
@@ -558,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,
@@ -625,9 +628,11 @@ 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
@@ -651,6 +656,10 @@ module.exports = {
   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_ESCAPE_CHAR: 253,
   TNS_LONG_LENGTH_INDICATOR: dataHandlerConstants.TNS_LONG_LENGTH_INDICATOR,
@@ -660,9 +669,9 @@ module.exports = {
   TNS_MAX_LONG_LENGTH: 0x7fffffff,
   TNS_SDU: 8192,
   TNS_TDU: 65535,
-  TNS_TXN_IN_PROGRESS: 0x00000002,
   TNS_MAX_CONNECT_DATA: 230,
   TNS_MAX_UROWID_LENGTH: 3950,
+  TNS_SERVER_CONVERTS_CHARS: 0x01, // server does charset conversion
 
   // drcp release mode
   DRCP_DEAUTHENTICATE: 0x00000002,
@@ -715,6 +724,7 @@ module.exports = {
   TNS_XML_TYPE_FLAG_SKIP_NEXT_4: 0x100000,
 
   // errors
+  TNS_ERR_INCONSISTENT_DATA_TYPES: 932,
   TNS_ERR_VAR_NOT_IN_SELECT_LIST: 1007,
   TNS_ERR_INBAND_MESSAGE: 12573,
   TNS_ERR_INVALID_SERVICE_NAME: 12514,
@@ -735,6 +745,9 @@ module.exports = {
   NUMBER_AS_TEXT_CHARS: 172,
   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);

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

@@ -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;
   }
 
@@ -161,7 +160,7 @@ class Message {
        */
       this.errorInfo.message = this.errorInfo.message.trim();
     }
-    this.processedError = true;
+    this.endOfResponse = !this.connection.nscon.endOfRequestSupport;
   }
 
   processReturnParameter() { }
@@ -178,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) {
@@ -208,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);
     }
@@ -282,7 +280,7 @@ class Message {
       const flags = buf.readUB4();              // session flags
       if (flags & constants.TNS_SESSGET_SESSION_CHANGED) {
         if (this.connection._drcpEstablishSession) {
-          this.connection.statementCache.clearOpenCursors();
+          this.connection.statementCache.clearCursors();
         }
       }
       this.connection._drcpEstablishSession = false;

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

@@ -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);
     }

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) {