oracledb 6.9.0 → 7.0.0

package/lib/thin/connection.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -42,6 +42,7 @@ const types = require('../types.js');
 const errors = require("../errors.js");
 const messages = require('./protocol/messages');
 const StatementCache = require('./statementCache.js');
+const { ThinQueueImpl } = require('./aq.js');
 
 const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
   heldValue.disconnect();
@@ -52,6 +53,29 @@ class TDSBuffer extends BaseBuffer {
 
 class ThinConnectionImpl extends ConnectionImpl {
 
+  static _createNamespace(nameSpaceName) {
+    return {
+      nameSpaceName,
+      keyValues: [],
+      pendingClear: false
+    };
+  }
+
+  static _mergeKeyValues(namespace, keyValues) {
+    const mergedKeyValues = namespace.keyValues.slice();
+    for (const entry of keyValues) {
+      const entryKey = Object.keys(entry)[0];
+      const existingIndex = mergedKeyValues.findIndex((existingEntry) =>
+        Object.prototype.hasOwnProperty.call(existingEntry, entryKey));
+      if (existingIndex !== -1) {
+        mergedKeyValues.splice(existingIndex, 1);
+      }
+      mergedKeyValues.push(entry);
+    }
+    namespace.keyValues = mergedKeyValues;
+    namespace.pendingClear = false;
+  }
+
   /**
    * Terminates the connection
    *
@@ -59,6 +83,7 @@ class ThinConnectionImpl extends ConnectionImpl {
    */
   async close() {
     try {
+      this.clearEndUserSecurityContext();
       if (this._protocol.txnInProgress) {
         if (this.tpcContext) {
           const message = this.createTpcRollbackMessage();
@@ -81,7 +106,7 @@ class ThinConnectionImpl extends ConnectionImpl {
         }
         this.nscon.disconnect();
       }
-    } catch (err) {
+    } catch {
       // immediate close of open socket on failure
       // exception won't be thrown to user
       this.nscon.disconnect(sqlNetConstants.NSFIMM);
@@ -165,12 +190,8 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
   }
 
-  //---------------------------------------------------------------------------
-  // _execute()
-  //
-  // Calls the RPC that executes a SQL statement and returns the results.
-  //---------------------------------------------------------------------------
-  async _execute(statement, numIters, binds, options, executeManyFlag) {
+  async _getExecuteMessage(statement, numIters, binds, options,
+    executeManyFlag, internalTempLobs = []) {
 
     // Throw error if executeMany is not called on a DML statement or PL/SQL
     if (executeManyFlag && statement.isQuery) {
@@ -194,7 +215,7 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     for (let i = 0; i < binds.length; i++) {
-      await this._bind(statement, binds[i], i + 1);
+      await this._bind(statement, binds[i], i + 1, internalTempLobs);
     }
     if (statement.isPlSql && (options.batchErrors || options.dmlRowCounts)) {
       errors.throwErr(errors.ERR_EXEC_MODE_ONLY_FOR_DML);
@@ -205,6 +226,18 @@ class ThinConnectionImpl extends ConnectionImpl {
     message.numExecs = numIters;
     message.arrayDmlRowCounts = options.dmlRowCounts;
     message.batchErrors = options.batchErrors;
+    return message;
+  }
+
+  //---------------------------------------------------------------------------
+  // _execute()
+  //
+  // Calls the RPC that executes a SQL statement and returns the results.
+  //---------------------------------------------------------------------------
+  async _execute(statement, numIters, binds, options, executeManyFlag, internalTempLobs = []) {
+
+    const message = await this._getExecuteMessage(statement, numIters, binds,
+      options, executeManyFlag, internalTempLobs);
 
     // if a PL/SQL statement requires a full execute, perform only a single
     // iteration in order to allow the determination of input/output binds
@@ -226,14 +259,124 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     // if a define is required, send an additional request to the database
-    if (statement.requiresDefine && statement.sql) {
-      statement.requiresFullExecute = true;
-      await this._protocol._processMessage(message);
-      statement.requiresFullExecute = false;
-      statement.requiresDefine = false;
-    }
+    await this._handleDefines(statement, message);
 
     // process results
+    return this._processExecuteResult(statement, numIters, options,
+      executeManyFlag, message);
+  }
+
+  //---------------------------------------------------------------------------
+  // _sendMessagesForPipeline()
+  //
+  // Sends the messages for the pipeline to the database for processing.
+  // This is async function only because of await adapter.pauseWrite()
+  // which is used to slow down writing to network socket.
+  //---------------------------------------------------------------------------
+  async _sendMessagesForPipeline(messages, continueOnError) {
+    for (const messageObj of messages) {
+      if (messageObj.pipelineResultImpl.error)
+        continue;
+      const message = messageObj.message;
+      const opType = messageObj.pipelineResultImpl.op.opType;
+      try {
+        if (['execute', 'executeMany', 'fetchOne', 'fetchMany',
+          'fetchAll'].includes(opType)) {
+          const statement = messageObj.statement;
+          if (statement.isPlSql && (statement.cursorId === 0 ||
+            statement.requiresFullExecute)) {
+            message.numExecs = 1;
+            message.noImplicitRelease = true;
+            await this._protocol._encodeMessage(message);
+            message.requiresSingleExecute = true;
+          } else if (message.numExecs > 0) {
+            await this._protocol._encodeMessage(message);
+          }
+        } else if (opType === 'commit')
+          await this._protocol._encodeMessage(message);
+      } catch (err) {
+        this._returnStatement(messageObj.statement);
+        if (!continueOnError) {
+          throw (err);
+        }
+        messageObj.pipelineResultImpl.error = err;
+      }
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // _createMessagesForPipelineOp()
+  //
+  // Creates a single message for a pipeline operation.
+  //---------------------------------------------------------------------------
+  async _createMessagesForPipelineOp(conn, operation) {
+    const opType = operation.opType;
+    if (opType === 'commit') {
+      errors.assert(conn._impl, errors.ERR_INVALID_CONNECTION);
+      return { message: new messages.CommitMessage(this) };
+    }
+
+    let processedArgs;
+    switch (opType) {
+      case 'execute':
+        processedArgs = await conn._processExecuteArgs(operation.statement,
+          operation.parameters, operation.options);
+        break;
+      case 'executeMany':
+        processedArgs = await conn._processExecuteManyArgs(operation.statement,
+          operation.parameters, operation.options);
+        break;
+      case 'fetchOne':
+      case 'fetchMany':
+      case 'fetchAll': {
+        const options = {
+          ...operation.options,
+          fetchTypeHandler: conn._createFetchTypeHandler(operation.fetchLobs)
+        };
+        processedArgs = await conn._processExecuteArgs(operation.statement,
+          operation.parameters, options);
+        break;
+      }
+      default:
+        errors.throwErr(errors.ERR_PIPELINE_OPERATION_NOT_SUPPORTED, opType);
+    }
+
+    const {sql, numIters, binds, options, executeManyFlag} = processedArgs;
+    return await this._prepareForExecute(sql, numIters, binds, options,
+      executeManyFlag);
+  }
+
+  //---------------------------------------------------------------------------
+  // _createMessagesForPipeline()
+  //
+  // Creates a list of messages for the pipeline and returns them after they
+  // have been submitted to the database for processing.
+  //---------------------------------------------------------------------------
+  async _createMessagesForPipeline(conn, resultsImpl, continueOnError) {
+    const messagesForPipeline = [];
+    let tokenNum = 1;
+    for (const resultImpl of resultsImpl) {
+      let messageObj;
+      try {
+        messageObj = await this._createMessagesForPipelineOp(conn,
+          resultImpl.op);
+      } catch (err) {
+        if (!continueOnError)
+          throw (err);
+        resultImpl.error = err;
+        continue;
+      }
+      messageObj.message.pipelineMessage = true;
+      messageObj.pipelineResultImpl = resultImpl;
+      messageObj.message.tokenNum = tokenNum;
+      tokenNum++;
+      messagesForPipeline.push(messageObj);
+    }
+    return messagesForPipeline;
+  }
+
+  _processExecuteResult(statement, numIters, options, executeManyFlag,
+    message) {
     const result = {};
     if (message.warning) {
       result.warning = message.warning;
@@ -283,6 +426,164 @@ class ThinConnectionImpl extends ConnectionImpl {
     return result;
   }
 
+  //---------------------------------------------------------------------------
+  // _completePipelineOp()
+  //
+  // Completes a particular pipeline operation.
+  //---------------------------------------------------------------------------
+  async _completePipelineOp(messageObj, conn) {
+    const message = messageObj.message;
+    const opType = messageObj.pipelineResultImpl.op.opType;
+
+    // Post-processing of pipeline message happen once after reading response
+    // of all the operations is completed in the first phase.
+    await message.postProcess();
+    await this._protocol._processCallStatus(message);
+
+    if (opType === 'commit')
+      return;
+
+    if (['execute', 'executeMany', 'fetchOne', 'fetchMany',
+      'fetchAll'].includes(opType)) {
+      const statement = messageObj.statement;
+      const numIters = messageObj.numIters;
+      const options = messageObj.options;
+      const executeManyFlag = messageObj.executeManyFlag;
+      try {
+
+        // for PL/SQL blocks that required a single execute, perform any
+        // remaining executes now
+        if (message.requiresSingleExecute) {
+          statement.requiresFullExecute = false;
+          message.numExecs = numIters - 1;
+          message.offset = 1;
+          message.noImplicitRelease = false;
+          if (message.numExecs > 0) {
+            await this._protocol._processMessage(message);
+            statement.requiresFullExecute = false;
+          }
+          message.requiresSingleExecute = false;
+        } else {
+          statement.requiresFullExecute = false;
+        }
+
+        // resend the message if that is required (for operations that fetch
+        // LOBS, for example)
+        await this._handleDefines(statement, message);
+
+        // process results
+        messageObj.resultTemp = this._processExecuteResult(statement, numIters,
+          options, executeManyFlag, message);
+      } catch (err) {
+        this._returnStatement(messageObj.statement);
+        throw (err);
+      } finally {
+        for (const lob of messageObj.internalTempLobs) {
+          this._tempLobsToClose.push(lob._locator);
+          this._tempLobsTotalSize += lob._locator.length;
+        }
+      }
+      if (opType === 'executeMany')
+        await conn._transformExecuteManyResult(messageObj.resultTemp,
+          messageObj.options);
+      else if (opType === 'execute') {
+        await conn._handleFetchForExecuteInPipeline(messageObj.resultTemp, messageObj.options);
+      }
+
+      if (['fetchOne', 'fetchMany', 'fetchAll'].includes(opType)) {
+        // fetch rows
+        await conn._transformExecuteResult(messageObj.resultTemp,
+          messageObj.options, messageObj.pipelineResultImpl.op);
+      }
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // _completePipelineOps()
+  //
+  // Completes any pipeline operations that have not actually completed.
+  // This could be due to the fact that LOBs were fetched or a fetch all
+  // operation has more rows to fetch.
+  //---------------------------------------------------------------------------
+  async _completePipelineOps(messagesForPipeline, conn, continueOnError) {
+    for (const messageObj of messagesForPipeline) {
+      const resultImpl = messageObj.pipelineResultImpl;
+      if (resultImpl.error)
+        continue;
+      try {
+        await this._completePipelineOp(messageObj, conn);
+        if (!messageObj.pipelineResultImpl.error) {
+          messageObj.pipelineResultImpl.result = messageObj.resultTemp;
+        }
+      } catch (err) {
+        this._returnStatement(messageObj.statement);
+        if (!continueOnError) {
+          throw (err);
+        }
+        messageObj.pipelineResultImpl.error = err;
+      }
+    }
+  }
+
+  // Returns whether the connection supports pipelining. Currently this is
+  // only supported with Oracle Database 23ai and later.
+  supportsPipelining() {
+    return this.nscon.pipeliningSupport;
+  }
+
+  //---------------------------------------------------------------------------
+  // runPipelineWithPipelining()
+  //
+  // Run the pipeline with pipelining when the database supports it.
+  //---------------------------------------------------------------------------
+  async runPipelineWithPipelining(conn, resultsImpl, continueOnError) {
+    this.pipelineMode = continueOnError ?
+      constants.TNS_PIPELINE_MODE_CONTINUE_ON_ERROR :
+      constants.TNS_PIPELINE_MODE_ABORT_ON_ERROR;
+    this.nscon.pipelineEnabled = true;
+
+    // Create all pipeline messages
+    const messagesForPipeline = await this._createMessagesForPipeline(conn,
+      resultsImpl, continueOnError);
+    try {
+      this._protocol.readBuf.resetPackets();
+
+      // Encode all messages
+      await this._sendMessagesForPipeline(messagesForPipeline,
+        continueOnError);
+
+      // endPipeline message
+      const endMessage = new messages.EndPipelineMessage(this);
+
+      // Decode responses for all operation messages, then process the final
+      // end-pipeline response and cleanup any remaining response packets.
+      await this._protocol.endPipeline(messagesForPipeline,
+        endMessage, this, continueOnError);
+
+      // Complete post processing of results (and deferred operations in
+      // non-pipeline mode)
+      await this._completePipelineOps(messagesForPipeline, conn,
+        continueOnError);
+
+      return conn._buildPipelineResults(resultsImpl);
+    } finally {
+      this.pipelineMode = 0;
+      this.nscon.pipelineEnabled = false;
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // runPipelineWithoutPipelining()
+  //
+  // Run the pipeline without pipelining when the database doesn't support
+  // pipelining. Call timeouts are disabled for consistency with when
+  // run with pipelining.
+  //---------------------------------------------------------------------------
+  async runPipelineWithoutPipelining(conn, resultsImpl, continueOnError) {
+    return await conn._runPipelineWithoutPipelining(resultsImpl,
+      continueOnError);
+  }
+
   //---------------------------------------------------------------------------
   // _parseTDSAttr()
   //
@@ -781,6 +1082,42 @@ class ThinConnectionImpl extends ConnectionImpl {
     return (this._pool) ? true : false;
   }
 
+  _postConnect(authMessage) {
+    let releaseNum;
+    let updateNum;
+    let portReleaseNum;
+    let portUpdateNum;
+
+    this.dbDomain = authMessage.sessionData['AUTH_SC_DB_DOMAIN'];
+    this.dbName = authMessage.sessionData['AUTH_SC_DBUNIQUE_NAME'];
+    this.dbUniqueName = authMessage.sessionData['AUTH_SC_REAL_DBUNIQUE_NAME'];
+    this.maxOpenCursors = Number(authMessage.sessionData['AUTH_MAX_OPEN_CURSORS'] || 0);
+    this.serviceName = authMessage.sessionData['AUTH_SC_SERVICE_NAME'];
+    this.instanceName = authMessage.sessionData['AUTH_INSTANCENAME'];
+    this.maxIdentifierLength = Number(authMessage.sessionData['AUTH_MAX_IDEN_LENGTH'] || 30);
+    const fullVersionNum = Number(authMessage.sessionData['AUTH_VERSION_NO']);
+    const versionNum = (fullVersionNum >> 24) & 0xFF;
+    this.warning = authMessage.warning;
+    if (this._protocol.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_18_1_EXT_1) {
+      releaseNum = (fullVersionNum >> 16) & 0xFF;
+      updateNum = (fullVersionNum >> 12) & 0x0F;
+      portReleaseNum = (fullVersionNum >> 4) & 0xFF;
+      portUpdateNum = fullVersionNum & 0x0F;
+    } else {
+      releaseNum = (fullVersionNum >> 20) & 0x0F;
+      updateNum = (fullVersionNum >> 12) & 0xFF;
+      portReleaseNum = (fullVersionNum >> 8) & 0x0F;
+      portUpdateNum = fullVersionNum & 0xFF;
+    }
+    this.serverVersionString = versionNum + '.' + releaseNum + '.' + updateNum + '.' + portReleaseNum + '.' + portUpdateNum;
+    this.serverVersion = versionNum * 100000000 + releaseNum * 1000000 + updateNum * 10000 + portReleaseNum * 100 + portUpdateNum * 1;
+
+    // Set pdbName only from Oracle Database version 12.2 onwards.
+    if (this.serverVersion >= 1202000000) {
+      this.pdbName = authMessage.sessionData.AUTH_DBNAME;
+    }
+  }
+
   /**
    *
    * @param {object} params  Configuration of the connection
@@ -822,51 +1159,52 @@ class ThinConnectionImpl extends ConnectionImpl {
     this.comboKey = null; // used in changePassword API
     this.tpcContext = null;
     this._sessionlessData = null;
+    this._nameSpaceMap = new Map();
 
     this.nscon = new nsi();
     finalizationRegistry.register(this, this.nscon);
     await this.nscon.connect(params);
 
-    let serverType;
-    if (this.isPooled()) {
-      serverType = params._connInfo[0];
-      this.serviceName = params._connInfo[2];
-      this.purity = params._connInfo[3] | constants.PURITY_DEFAULT;
-      this.sid = params._connInfo[4];
-    } else {
-      serverType = this.nscon.getOption(sqlNetConstants.SERVERTYPE);
-      this.serviceName = this.nscon.getOption(sqlNetConstants.SVCNAME);
-      this.sid = this.nscon.getOption(sqlNetConstants.SID);
-      this.purity = this.nscon.getOption(sqlNetConstants.PURITY) | constants.PURITY_DEFAULT;
-    }
-    if (serverType) {
-      this._drcpEnabled = serverType.toLowerCase() === 'pooled';
-    }
-    this.remoteAddress = this.nscon.getOption(sqlNetConstants.REMOTEADDR);
-    this.connectionClass = params.connectionClass;
-
-    /*
-     * if drcp is used, use purity = NEW as the default purity for
-     * standalone connections and purity = SELF for connections that belong
-     * to a pool
-     */
-    if (this.purity === constants.PURITY_DEFAULT && this._drcpEnabled) {
+    try {
+      let serverType;
       if (this.isPooled()) {
-        this.purity = constants.PURITY_SELF;
+        serverType = params._connInfo[0];
+        this.serviceName = params._connInfo[2];
+        this.purity = params._connInfo[3] | constants.PURITY_DEFAULT;
+        this.sid = params._connInfo[4];
       } else {
-        this.purity = constants.PURITY_NEW;
+        serverType = this.nscon.getOption(sqlNetConstants.SERVERTYPE);
+        this.serviceName = this.nscon.getOption(sqlNetConstants.SVCNAME);
+        this.sid = this.nscon.getOption(sqlNetConstants.SID);
+        this.purity = this.nscon.getOption(sqlNetConstants.PURITY) | constants.PURITY_DEFAULT;
+      }
+      if (serverType) {
+        this._drcpEnabled = serverType.toLowerCase() === 'pooled';
+      }
+      this.remoteAddress = this.nscon.getOption(sqlNetConstants.REMOTEADDR);
+      this.connectionClass = params.connectionClass;
+
+      /*
+       * if drcp is used, use purity = NEW as the default purity for
+       * standalone connections and purity = SELF for connections that belong
+       * to a pool
+       */
+      if (this.purity === constants.PURITY_DEFAULT && this._drcpEnabled) {
+        if (this.isPooled()) {
+          this.purity = constants.PURITY_SELF;
+        } else {
+          this.purity = constants.PURITY_NEW;
+        }
       }
-    }
 
-    this._protocol = new Protocol(this);
+      this._protocol = new Protocol(this);
 
-    // check if the protocol version supported by the database is high
-    // enough; if not, reject the connection immediately
-    if (this._protocol.caps.protocolVersion < constants.TNS_VERSION_MIN_ACCEPTED) {
-      errors.throwErr(errors.ERR_SERVER_VERSION_NOT_SUPPORTED);
-    }
+      // check if the protocol version supported by the database is high
+      // enough; if not, reject the connection immediately
+      if (this._protocol.caps.protocolVersion < constants.TNS_VERSION_MIN_ACCEPTED) {
+        errors.throwErr(errors.ERR_SERVER_VERSION_NOT_SUPPORTED);
+      }
 
-    try {
       const protocolMessage = new messages.ProtocolMessage(this);
       const dataTypeMessage = new messages.DataTypeMessage(this);
       const authMessage = new messages.AuthMessage(this, params);
@@ -895,6 +1233,7 @@ class ThinConnectionImpl extends ConnectionImpl {
       if (!params.externalAuth) { // non-token Authentication
         await this._protocol._processMessage(authMessage); // OAUTH
       }
+      this._postConnect(authMessage);
     } catch (err) {
       this.nscon.disconnect();
       throw err;
@@ -924,7 +1263,8 @@ class ThinConnectionImpl extends ConnectionImpl {
   // option is true
   //---------------------------------------------------------------------------
   _prepare(sql, options) {
-    const statement = this._getStatement(sql, options.keepInStmtCache);
+    const forceNew = Boolean(options.fetchTypeMap);
+    const statement = this._getStatement(sql, options.keepInStmtCache, forceNew);
     statement.bufferRowIndex = 0;
     statement.bufferRowCount = 0;
     statement.lastRowIndex = 0;
@@ -935,7 +1275,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   // Binds the values by user to the statement object
   //---------------------------------------------------------------------------
-  async _bind(stmt, variable, pos = 0) {
+  async _bind(stmt, variable, pos = 0, internalTempLobs = []) {
     const bindInfoDict = stmt.bindInfoDict;
     const bindInfoList = stmt.bindInfoList;
 
@@ -946,6 +1286,8 @@ class ThinConnectionImpl extends ConnectionImpl {
      * the user expects to get it
      */
     if (stmt.isPlSql && variable.maxSize > 32767) {
+      if (this.pipelineMode)
+        errors.throwErr(errors.ERR_PIPELINE_LARGE_BUFFERS_NOT_SUPPORTED);
       if (variable.type === types.DB_TYPE_RAW ||
           variable.type === types.DB_TYPE_LONG_RAW) {
         variable.type = types.DB_TYPE_BLOB;
@@ -977,6 +1319,7 @@ class ThinConnectionImpl extends ConnectionImpl {
           if (val && val.length > 0) {
             const lobImpl = new ThinLobImpl();
             await lobImpl.create(this, variable.type);
+            internalTempLobs.push(lobImpl);
             await lobImpl.write(1, val);
             variable.values[index] = lobImpl;
           } else {
@@ -1064,6 +1407,15 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
   }
 
+  async _handleDefines(statement, message) {
+    if (statement.requiresDefine && statement.sql) {
+      statement.requiresFullExecute = true;
+      await this._protocol._processMessage(message);
+      statement.requiresDefine = false;
+      statement.requiresFullExecute = false;
+    }
+  }
+
   //---------------------------------------------------------------------------
   // execute()
   //
@@ -1071,15 +1423,31 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   async execute(sql, numIters, binds, options, executeManyFlag) {
     const statement = this._prepare(sql, options);
+    const internalTempLobs = [];
     try {
       return await this._execute(statement, numIters, binds, options,
-        executeManyFlag);
+        executeManyFlag, internalTempLobs);
     } catch (err) {
       this._returnStatement(statement);
       throw err;
+    } finally {
+      // Add to freelist which will be sent in piggyback fashion
+      for (const lob of internalTempLobs) {
+        this._tempLobsToClose.push(lob._locator);
+        this._tempLobsTotalSize += lob._locator.length;
+      }
     }
   }
 
+  async _prepareForExecute(sql, numIters, binds, options, executeManyFlag) {
+    const statement = this._prepare(sql, options);
+    const internalTempLobs = [];
+    const message = await this._getExecuteMessage(statement, numIters, binds,
+      options, executeManyFlag, internalTempLobs);
+    return {statement, numIters, options, executeManyFlag, internalTempLobs,
+      message};
+  }
+
   //---------------------------------------------------------------------------
   // Get the statement object from the statement cache for the SQL if it exists
   // else prepare a new statement object for the SQL. If a statement is already
@@ -1089,9 +1457,9 @@ class ThinConnectionImpl extends ConnectionImpl {
   // cache) since it is unknown at this point whether the original session or a
   // new session is going to be used.
   //---------------------------------------------------------------------------
-  _getStatement(sql, cacheStatement = false) {
+  _getStatement(sql, cacheStatement = false, forceNew = false) {
     return this.statementCache.getStatement(sql, cacheStatement,
-      this._drcpEstablishSession);
+      forceNew || this._drcpEstablishSession);
   }
 
   //---------------------------------------------------------------------------
@@ -1415,6 +1783,20 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.dbName;
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the name of a container associated with the connection.
+  //---------------------------------------------------------------------------
+  getPdbName() {
+    return this.pdbName;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database unique name associated with the connection.
+  //---------------------------------------------------------------------------
+  getDbUniqueName() {
+    return this.dbUniqueName;
+  }
+
   //---------------------------------------------------------------------------
   // Returns maximum number of cursors that can be opened in one session.
   //---------------------------------------------------------------------------
@@ -1450,5 +1832,87 @@ class ThinConnectionImpl extends ConnectionImpl {
   getWarning() {
     return this.warning;
   }
+
+  //---------------------------------------------------------------------------
+  // getQueue()
+  //
+  // Returns a queue for use with advanced queuing.
+  //---------------------------------------------------------------------------
+  getQueue(name, payloadTypeClass, payloadType) {
+    return new ThinQueueImpl(this, name, payloadTypeClass, payloadType);
+  }
+
+  // Queue key/value pairs to be sent to the server.
+  // If the namespace already has pending entries, merge and replace by key.
+  appContext(namespaceName, keyValues) {
+    const existingNamespace = this._nameSpaceMap.get(namespaceName);
+
+    // If namespace doesn't exist or was cleared, just initialize it
+    if (!existingNamespace || existingNamespace.pendingClear) {
+      const ns = existingNamespace || ThinConnectionImpl._createNamespace(namespaceName);
+      ns.pendingClear = false;
+      ns.keyValues = keyValues;
+      this._nameSpaceMap.set(namespaceName, ns);
+      return;
+    }
+
+    ThinConnectionImpl._mergeKeyValues(existingNamespace, keyValues);
+  }
+
+  // This will clear all context on the server.
+  // If the nameSpaceName exists , it updates else creates a new entry with clear flag set.
+  clearAppContext(namespaceName) {
+    const ns = ThinConnectionImpl._createNamespace(namespaceName);
+    ns.pendingClear = true;
+    this._nameSpaceMap.set(namespaceName, ns);
+  }
+
+  //---------------------------------------------------------------------------
+  // directPathLoad()
+  //   Implements direct path loading into a table.
+  //---------------------------------------------------------------------------
+  async directPathLoad(schemaName, tableName, columnNames, data) {
+    const prepareMessage = new messages.DirectPathPrepareMessage(this);
+    prepareMessage.schemaName = schemaName;
+    prepareMessage.tableName = tableName;
+    prepareMessage.columnNames = columnNames;
+    await this._protocol._processMessage(prepareMessage);
+
+    const opMessage = new messages.DirectPathOpMessage(this);
+    opMessage.prepare(prepareMessage.cursorId, constants.TNS_DP_OP_ABORT);
+
+    try {
+      const loadMessage = new messages.DirectPathLoadStreamMessage(this);
+      loadMessage.prepare(prepareMessage.cursorId, data, prepareMessage.columnMetadata);
+      await this._protocol._processMessage(loadMessage);
+      opMessage.opCode = constants.TNS_DP_OP_FINISH;
+    } finally {
+      await this._protocol._processMessage(opMessage);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // setEndUserSecurityContext()
+  //
+  // Set the End Security Context.
+  //---------------------------------------------------------------------------
+  setEndUserSecurityContext(context) {
+    if (!this._protocol.caps.supportsEndUserSecurityContext) {
+      errors.throwErr(errors.ERR_UNSUPPORTED_DEEP_DATA_SECURITY_FEATURE);
+    }
+
+    if (this.securityContext && this.securityContext !== context) {
+      this.securityContext.clearEncodedPayload();
+    }
+    this.securityContext = context;
+  }
+
+  clearEndUserSecurityContext() {
+    if (this.securityContext) {
+      this.securityContext.clearEncodedPayload();
+    }
+    this.securityContext = null;
+  }
+
 }
 module.exports = ThinConnectionImpl;