oracledb 6.10.0 → 7.0.0

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

@@ -56,13 +56,13 @@ class ExecuteMessage extends MessageWithData {
   }
 
   //-------------------------------------------------------------------------
-  // writeReExecuteMessage()
+  // writeExecuteMessage()
   //
   // Write the message for a full execute.
   //-------------------------------------------------------------------------
   writeExecuteMessage(buf) {
     let options = 0x0;
-    let dmlOptions = 0;
+    let execFlags = 0;
     let numParams = 0;
     let numIters = 1;
     // Configuring the options field thats send to the server
@@ -70,7 +70,7 @@ class ExecuteMessage extends MessageWithData {
     const params = stmt.bindInfoList;
 
     if (this.noImplicitRelease) {
-      dmlOptions |= constants.TNS_EXEC_OPTION_NO_IMPL_REL;
+      execFlags |= constants.TNS_EXEC_OPTION_NO_IMPL_REL;
     }
 
     if (!stmt.requiresDefine && !this.parseOnly && params) {
@@ -79,7 +79,7 @@ class ExecuteMessage extends MessageWithData {
     if (stmt.requiresDefine) {
       options |= constants.TNS_EXEC_OPTION_DEFINE;
     } else if (!this.parseOnly && stmt.sql) {
-      dmlOptions |= constants.TNS_EXEC_OPTION_IMPLICIT_RESULTSET;
+      execFlags |= constants.TNS_EXEC_OPTION_IMPLICIT_RESULTSET;
       options |= constants.TNS_EXEC_OPTION_EXECUTE;
     }
     if (stmt.cursorId === 0 || stmt.isDdl) {
@@ -111,7 +111,7 @@ class ExecuteMessage extends MessageWithData {
       options |= constants.TNS_EXEC_OPTION_BATCH_ERRORS;
     }
     if (this.arrayDmlRowCounts) {
-      dmlOptions |= constants.TNS_EXEC_OPTION_DML_ROWCOUNTS;
+      execFlags |= constants.TNS_EXEC_OPTION_DML_ROWCOUNTS;
     }
     if (this.options.autoCommit) {
       options |= constants.TNS_EXEC_OPTION_COMMIT;
@@ -213,7 +213,7 @@ class ExecuteMessage extends MessageWithData {
     buf.writeUB4(0);                                 // al8i4[6] SCN (part 2)
     buf.writeUB4((stmt.isQuery) ? 1 : 0);            // al8i4[7] is query
     buf.writeUB4(0);                                 // al8i4[8]
-    buf.writeUB4(dmlOptions);                        // al8i4[9] DML row counts/implicit
+    buf.writeUB4(execFlags);                         // al8i4[9] DML row counts/implicit
     buf.writeUB4(0);                                 // al8i4[10]
     buf.writeUB4(0);                                 // al8i4[11]
     buf.writeUB4(0);                                 // al8i4[12]
@@ -321,7 +321,9 @@ class ExecuteMessage extends MessageWithData {
     // no rows have yet been sent so the header information needs to be sent
     if (this.currentRow === 0) {
       const stmt = this.statement;
-      if (stmt.cursorId !== 0 && !stmt.requiresFullExecute && !this.parseOnly && !stmt.requiresDefine && !stmt.noPrefetch && !stmt.isDdl && !this.batchErrors) {
+      if (stmt.cursorId !== 0 && !stmt.requiresFullExecute && !this.parseOnly
+        && !stmt.requiresDefine && !stmt.noPrefetch && !stmt.isDdl
+        && !this.batchErrors) {
         if (stmt.isQuery && this.options.prefetchRows > 0) {
           this.functionCode = constants.TNS_FUNC_REEXECUTE_AND_FETCH;
         } else {

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -29,7 +29,11 @@
 const AuthMessage = require('./auth.js');
 const CommitMessage = require('./commit.js');
 const DataTypeMessage = require('./dataType.js');
+const DirectPathPrepareMessage = require('./directPathPrepare.js');
+const DirectPathLoadStreamMessage = require('./directPathLoadStream.js');
+const DirectPathOpMessage = require('./directPathOp.js');
 const ExecuteMessage = require('./execute.js');
+const EndPipelineMessage = require('./endPipeline.js');
 const FetchMessage = require('./fetch.js');
 const LobOpMessage = require('./lobOp.js');
 const LogOffMessage = require('./logOff.js');
@@ -46,7 +50,11 @@ module.exports = {
   CommitMessage,
   FastAuthMessage,
   DataTypeMessage,
+  DirectPathPrepareMessage,
+  DirectPathLoadStreamMessage,
+  DirectPathOpMessage,
   ExecuteMessage,
+  EndPipelineMessage,
   FetchMessage,
   LobOpMessage,
   LogOffMessage,

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -63,7 +63,7 @@ class ProtocolMessage extends Message {
     this.serverVersion = buf.readUInt8();
     buf.skipUB1();
     this.serverBanner = buf.readNullTerminatedBytes(48);
-    buf.caps.charSetID = buf.readUInt16LE();
+    buf.caps.charsetId = buf.readUInt16LE();
     this.serverFlags = buf.readUInt8();
     const num_elem = buf.readUInt16LE();
     if (num_elem > 0) {                       // skip elements

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -58,6 +58,7 @@ class MessageWithData extends Message {
     this.parseOnly = false;
     this.resultSetsToSetup = [];
     this.deferredErr = null;
+    this.postProcessDone = false;
   }
 
   /**
@@ -189,145 +190,6 @@ class MessageWithData extends Message {
     this.resultSetsToSetup.push(resultSet);
   }
 
-  processColumnInfo(buf, columnNum) {
-    const dataType = buf.readUInt8();
-    buf.skipUB1(); // flags
-    const precision = buf.readInt8();
-    const scale = buf.readInt8();
-    const maxSize = buf.readUB4();
-    buf.skipUB4();                              // max number of array elements
-    buf.skipUB8();                              // cont flags
-    let oid;
-    let numBytes = buf.readUB4();               // OID
-    if (numBytes > 0) {
-      oid = Buffer.from(buf.readBytesWithLength());
-    }
-    buf.skipUB2();                              // version
-    buf.skipUB2();                              // character set id
-    const csfrm = buf.readUInt8();              // character set form
-    let size = buf.readUB4();
-    if (dataType === constants.TNS_DATA_TYPE_RAW) {
-      size = maxSize;
-    }
-    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_12_2) {
-      buf.skipUB4();                            // oaccolid
-    }
-    const nullable = Boolean(buf.readUInt8());
-    buf.skipUB1();                              // v7 length of name
-    let name;
-    numBytes = buf.readUB4();
-    if (numBytes > 0) {
-      name = buf.readStr(constants.CSFRM_IMPLICIT);
-    }
-    let schema;
-    numBytes = buf.readUB4();
-    if (numBytes > 0) {
-      schema = buf.readStr(constants.CSFRM_IMPLICIT);
-    }
-    numBytes = buf.readUB4();
-    let typeName;
-    if (numBytes > 0) {
-      typeName = buf.readStr(constants.CSFRM_IMPLICIT);
-    }
-    buf.skipUB2();                              // column position
-    const udsFlags = buf.readUB4();             // uds flag
-
-    // build metadata
-    const fetchInfo = {
-      name: name,
-      dbColumnName: name,
-      dbType: types.getTypeByOraTypeNum(dataType, csfrm),
-      nullable: nullable
-    };
-    fetchInfo.isJson = Boolean(udsFlags & constants.TNS_UDS_FLAGS_IS_JSON);
-    fetchInfo.isOson = Boolean(udsFlags & constants.TNS_UDS_FLAGS_IS_OSON);
-    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_1) {
-      numBytes = buf.readUB4();
-      if (numBytes > 0) {
-        fetchInfo.domainSchema = buf.readStr(constants.CSFRM_IMPLICIT);
-      }
-      numBytes = buf.readUB4();
-      if (numBytes > 0) {
-        fetchInfo.domainName = buf.readStr(constants.CSFRM_IMPLICIT);
-      }
-    }
-    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_1_EXT_3) {
-      if (buf.readUB4() > 0) {
-        fetchInfo.annotations = {};
-        buf.skipUB1();
-        const numAnnotations = buf.readUB4();
-        buf.skipUB1();
-        let key, value;
-        for (let i = 0; i < numAnnotations; i++) {
-          buf.skipUB4();
-          value = "";
-          key = buf.readStr(constants.CSFRM_IMPLICIT);
-          numBytes = buf.readUB4();
-          if (numBytes > 0) {
-            value = buf.readStr(constants.CSFRM_IMPLICIT);
-          }
-          fetchInfo.annotations[key] = value;
-          buf.skipUB4();                        // flags
-        }
-        buf.skipUB4();                          // flags
-      }
-    }
-    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_4) {
-      const dimensions = buf.readUB4();
-      const vectorFormat = buf.readUInt8();
-      const vectorFlags = buf.readUInt8();
-      if (fetchInfo.dbType === types.DB_TYPE_VECTOR) {
-        if (!(vectorFlags & constants.VECTOR_META_FLAG_FLEXIBLE_DIM)) {
-          fetchInfo.vectorDimensions = dimensions;
-        }
-        fetchInfo.isSparseVector = Boolean(vectorFlags & constants.VECTOR_META_FLAG_SPARSE);
-        if (vectorFormat !== constants.VECTOR_FORMAT_FLEX) {
-          fetchInfo.vectorFormat = vectorFormat;
-        }
-      }
-    }
-
-    switch (fetchInfo.dbType) {
-      case types.DB_TYPE_VARCHAR:
-      case types.DB_TYPE_NVARCHAR:
-      case types.DB_TYPE_CHAR:
-      case types.DB_TYPE_NCHAR:
-      case types.DB_TYPE_RAW:
-        fetchInfo.byteSize = size;
-        break;
-      case types.DB_TYPE_NUMBER:
-        fetchInfo.precision = precision;
-        break;
-      case types.DB_TYPE_TIMESTAMP:
-      case types.DB_TYPE_TIMESTAMP_TZ:
-      case types.DB_TYPE_TIMESTAMP_LTZ:
-        fetchInfo.precision = scale;
-        break;
-      case types.DB_TYPE_OBJECT:
-        fetchInfo.dbTypeClass = this.connection._getDbObjectType(schema,
-          typeName, undefined, oid);
-        if (fetchInfo.dbTypeClass.partial) {
-          this.connection._partialDbObjectTypes.push(fetchInfo.dbTypeClass);
-        }
-        if (fetchInfo.dbTypeClass.isXmlType) {
-          fetchInfo.dbType = types.DB_TYPE_XMLTYPE;
-        }
-        break;
-      default:
-        break;
-    }
-    if (fetchInfo.dbType === types.DB_TYPE_NUMBER) {
-      fetchInfo.scale = scale;
-    }
-    return {
-      fetchInfo: fetchInfo,
-      type: fetchInfo.dbType,
-      maxSize: maxSize,
-      columnNum: columnNum,
-      values: new Array(this.options.fetchArraySize)
-    };
-  }
-
   processRowHeader(buf) {
     buf.skipUB1();                              // flags
     buf.skipUB2();                              // num requests
@@ -607,10 +469,16 @@ class MessageWithData extends Message {
   }
 
   async postProcess() {
+    if (this.postProcessDone) {
+      return;
+    }
+
     if (this.deferredErr) {
       throw this.deferredErr;
     }
 
+    this.postProcessDone = true;
+
     if (this.outVariables) {
       for (const variable of this.outVariables) {
         if (variable.isArray) {

package/lib/thin/protocol/packet.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -35,8 +35,6 @@ const vector = require('../../impl/datahandlers/vector.js');
 const errors = require("../../errors.js");
 
 const TNS_BASE64_ALPHABET_ARRAY = Buffer.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", 'utf8');
-const FAST_AUTH_END_OF_RPC_VALUE = 0x800;
-const FAST_AUTH_END_OF_RPC_OFFSET = 0x8;
 const MSG_TYPE_OFFSET = 11;
 
 /**
@@ -161,7 +159,7 @@ class ReadPacket extends BaseBuffer {
       return this.readBytes(numBytes);
     }
     this.chunkedBytesBuf.startChunkedRead();
-    while (true) { // eslint-disable-line
+    while (true) {
       const numBytesInChunk = this.readUB4();
       if (numBytesInChunk === 0) {
         break;
@@ -293,6 +291,51 @@ class ReadPacket extends BaseBuffer {
     this.packetNum = packet.num;
   }
 
+  /**
+   * It is used in pipeline mode to ignore reading packets
+   * if client detects a protocol error.
+   */
+  resetPackets() {
+    this.savedPackets = [];
+    this.savedPacketPos = 0;
+    this.savedPos = 0;
+  }
+
+  /**
+   * Discards the remaining responses after the pipeline has
+   * encountered an exception in ABORT_ON_ERROR mode
+   */
+  async discardPipelineResponses(num) {
+    while (num > 0) {
+      await this.waitForPackets(true);
+      num--;
+    }
+    this.resetPackets();
+  }
+
+  _isEndOfResponse(packet) {
+    // In pipeline mode, when a DML operation fails due to invalid RETURNING
+    // binds, we may receive a partial response followed by a break packet
+    // before the full response arrives. Such break packets are ignored.
+    //
+    // In non-pipeline mode, return true if the packet is not a data packet.
+    if (packet.type !== constants.TNS_PACKET_TYPE_DATA) {
+      return !this.nsi.pipelineEnabled;
+    }
+
+    // End-of-response marker
+    if (packet.buf.readUInt16BE(8) &
+    constants.TNS_DATA_FLAGS_END_OF_RESPONSE) {
+      return true;
+    }
+
+    // Single-byte 1D packet
+    return (
+      packet.buf.length === MSG_TYPE_OFFSET &&
+      packet.buf[MSG_TYPE_OFFSET - 1] === constants.TNS_MSG_TYPE_END_OF_REQUEST
+    );
+  }
+
   /**
    * Read packets from network.
    * If checkRequestBoundary is passed as true, it
@@ -308,21 +351,24 @@ class ReadPacket extends BaseBuffer {
       this.savedPackets.push(packet);
     }
     if (checkRequestBoundary && this.nsi.endOfRequestSupport) {
-      while (packet.type === constants.TNS_PACKET_TYPE_DATA) {
-        // End Marker
-        if ((packet.buf.readUInt16BE(8) &
-            constants.TNS_DATA_FLAGS_END_OF_REQUEST)) {
-          break;
+      while (!this._isEndOfResponse(packet)) {
+        if (
+          packet.type !== constants.TNS_PACKET_TYPE_DATA &&
+          this.nsi.isBreak
+        ) {
+          // For pipeline Mode only, we issue a dummy reset to the sqlnet layer
+          // to set state, `this.isBreak = this.isReset = false;`
+          await this.nsi.reset();
+
+          this.resetPackets();
         }
 
-        // Single Byte 1D packet
-        if (packet.buf.length === MSG_TYPE_OFFSET &&
-            packet.buf[MSG_TYPE_OFFSET - 1] ===
-            constants.TNS_MSG_TYPE_END_OF_REQUEST) {
-          break;
-        }
+        // Read new packet.
         packet = await this.nsi.recvPacket();
-        this.savedPackets.push(packet);
+
+        if (!this.nsi.isBreak) {
+          this.savedPackets.push(packet);
+        }
       }
     }
     this.startPacket(this.savedPackets[this.savedPacketPos++]);
@@ -447,7 +493,7 @@ class ReadPacket extends BaseBuffer {
     if (numBytes !== constants.TNS_LONG_LENGTH_INDICATOR) {
       this.skipBytes(numBytes);
     } else {
-      while (true) { // eslint-disable-line
+      while (true) {
         const tempNumBytes = this.readUB4();
         if (tempNumBytes === 0)
           break;
@@ -491,6 +537,33 @@ class WritePacket extends BaseBuffer {
     this.packetType = constants.TNS_PACKET_TYPE_DATA;
     this.caps = caps;
     this.nsi = nsi;
+    this._dataFlags = 0;
+    this.tokenNum = 0;
+  }
+
+  _asBuffer(input) {
+    if (Buffer.isBuffer(input)) {
+      return input;
+    }
+    if (typeof input === 'string') {
+      return Buffer.from(input);
+    }
+    errors.throwErr(errors.ERR_INTERNAL, 'Expected Buffer or string');
+  }
+
+  // Writes a 32-bit length, writeUB4 followed by the field if present.
+  // For Null input, We just write length as 0.
+  _writeBytesWithTwoLengths(input) {
+    if (input == null) {
+      this.writeUB4(0);
+      return;
+    }
+    const buf = this._asBuffer(input);
+    const length = buf.length;
+    this.writeUB4(length);
+    if (length > 0) {
+      this.writeBytesWithLength(buf);
+    }
   }
 
   /**
@@ -518,37 +591,48 @@ class WritePacket extends BaseBuffer {
     this.writeUInt8(this.packetType);
     this.writeUInt8(0);
     this.writeUInt16BE(0);
+    let flags = this._dataFlags;
     let buf = this.buf.subarray(0, size);
     if (!finalPacket) {
       buf = Buffer.from(buf);
       this.startPacket();
     } else {
-      // Write End of RPC bit in last packet used only for fastAuth Message.
-      this.buf.writeUInt16BE(FAST_AUTH_END_OF_RPC_VALUE,
-        FAST_AUTH_END_OF_RPC_OFFSET);
+      if (this.nsi.pipelineEnabled) {
+        // For pipeline mode, next operation would start writing
+        // into this.buf. Hence create a copy so that it wont
+        // overwrite the contents given to stream.write().
+        buf = Buffer.from(buf);
+      }
+      // Write End of RPC bit in last packet used only for fastAuth Message
+      // and in pipeline mode.
+      flags |= constants.TNS_DATA_FLAGS_END_OF_REQUEST;
     }
     if (!this.nsi.ntAdapter) {
       errors.throwErr(errors.ERR_INVALID_CONNECTION);
     }
+    if (this.packetType === constants.TNS_PACKET_TYPE_DATA) {
+      buf.writeUInt16BE(flags, constants.TNS_DATA_FLAGS_OFFSET);
+    }
     this.nsi.sendPacket(buf);
   }
 
   /**
    * Starts a packet.
    */
-  startPacket(dataFlags = 0) {
+  startPacket() {
     this.pos = constants.PACKET_HEADER_SIZE;
     if (this.packetType === constants.TNS_PACKET_TYPE_DATA) {
-      this.writeUInt16BE(dataFlags);
+      this.writeUInt16BE(this._dataFlags);
     }
   }
 
   /**
    * Starts a database request.
    */
-  startRequest(packetType, dataFlags = 0) {
+  startRequest(packetType) {
     this.packetType = packetType;
-    this.startPacket(dataFlags);
+    this._dataFlags = 0;
+    this.startPacket();
   }
 
   /**
@@ -572,6 +656,13 @@ class WritePacket extends BaseBuffer {
     this.writeUB4(flags);
   }
 
+  writeStrKeywordValuePair(key, valueBytes, flags = 0, text) {
+    this.writeUB4(flags);
+    this._writeBytesWithTwoLengths(key);
+    this._writeBytesWithTwoLengths(text);
+    this._writeBytesWithTwoLengths(valueBytes);
+  }
+
   /**
    * Encodes a JavaScript object into OSON and then writes it (QLocator
    * followed by data) to the buffer.

package/lib/thin/protocol/protocol.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -69,7 +69,7 @@ class Protocol {
   async _decodeMessage(message) {
     message.preProcess();
     await this.readBuf.waitForPackets(true);
-    while (true) {     // eslint-disable-line
+    while (true) {
       if (this.nsi.isBreak) {
         await this.resetMessage();
         delete this.readBuf.savedPackets;
@@ -89,7 +89,31 @@ class Protocol {
         throw (err);
       }
     }
-    await message.postProcess();
+  }
+
+  async _processPipelineMessage(messageObj, connImpl, continueOnError) {
+    let opProcessed = false;
+    const { message } = messageObj;
+    await this.readBuf.waitForPackets(true);
+    try {
+      message.preProcess();
+      message.decode(this.readBuf);
+      opProcessed = true;
+      this._checkAndRaiseException(message);
+    } catch (err) {
+      if (!opProcessed && !this.connInProgress &&
+          err.code !== errors.ERR_CONNECTION_CLOSED_CODE) {
+        this.readBuf.resetPackets();
+      }
+      if (messageObj.statement)
+        connImpl._returnStatement(messageObj.statement);
+      if (!continueOnError) {
+        err.opProcessed = opProcessed;
+        throw (err);
+      }
+      messageObj.pipelineResultImpl.error = err;
+    }
+    return opProcessed;
   }
 
   /**
@@ -112,6 +136,59 @@ class Protocol {
     this.writeBuf.endRequest();
   }
 
+  _raiseException(message) {
+    let err = new Error(message.errorInfo.message);
+    err.offset = message.errorInfo.pos;
+    err.errorNum = message.errorInfo.num;
+    err.isRecoverable = message.errorInfo.isRecoverable;
+    err = errors.transformErr(err);
+    if (err.code === errors.ERR_CONNECTION_CLOSED_CODE) {
+      this.nsi.disconnect();
+    }
+    throw err;
+  }
+
+  _checkAndRaiseException(message) {
+    if (message.errorOccurred) {
+      this._raiseException(message);
+    }
+  }
+  /**
+   * Called when all messages for the pipeline have been sent to the
+   * database. An end pipeline message is sent to the database and then
+   * the responses to all of the messages are processed.
+   */
+  async endPipeline(messagesForPipeline, endMessage, connImpl,
+    continueOnError) {
+    await this._encodeMessage(endMessage);
+
+    // required for cleanup of response packets
+    let numResponsesToDiscard = messagesForPipeline.length + 1;
+    try {
+      for (const messageObj of messagesForPipeline) {
+        const opProcessed = await this._processPipelineMessage(
+          messageObj, connImpl, continueOnError);
+        if (opProcessed)
+          numResponsesToDiscard--;
+      }
+
+      // Process the final message
+      await this.readBuf.waitForPackets(true);
+      endMessage.process(this.readBuf);
+      this._checkAndRaiseException(endMessage);
+      numResponsesToDiscard = 0;
+
+    } catch (err) {
+
+      // If an operation response was already consumed before failure, account
+      // for it before discarding the remaining pipeline responses.
+      if (err.opProcessed)
+        numResponsesToDiscard--;
+      await this.readBuf.discardPipelineResponses(numResponsesToDiscard);
+      throw (err);
+    }
+  }
+
   async _recoverFromError(caughtErr, message) {
     /*
      * We have NJS error(protocol related) detected during packet write/read
@@ -119,11 +196,16 @@ class Protocol {
      * response as ORA-1013 from the server.
      */
     try {
-      this.breakMessage();
-      this._breakInProgress = false;
-      await this.resetMessage();
-      await this.readBuf.waitForPackets();
-      message.decode(this.readBuf);
+      if (message.isPipeline) {
+        // We just cleanup all pending response packets
+        this.readBuf.resetPackets();
+      } else {
+        this.breakMessage();
+        this._breakInProgress = false;
+        await this.resetMessage();
+        await this.readBuf.waitForPackets();
+        message.decode(this.readBuf);
+      }
     } catch (err) { // Recovery failed
       this.nsi.disconnect();
       const newErr = errors.getErr(errors.ERR_CONNECTION_CLOSED);
@@ -134,6 +216,18 @@ class Protocol {
     }
   }
 
+  async _processCallStatus(message) {
+    if (message.flushOutBinds) {
+      await this.flushOutBindMessage(message);
+    }
+    this.txnInProgress = Boolean(message.callStatus &
+      constants.TNS_EOCS_FLAGS_TXN_IN_PROGRESS);
+    // processes the call status flags returned by the server.
+    if (message.callStatus & constants.TNS_EOCS_FLAGS_SESS_RELEASE) {
+      message.connection.statementCache.clearCursors();
+    }
+  }
+
   /**
    *
    * @param {object} message The RPC dynamic structure specific to the RPC
@@ -159,6 +253,11 @@ class Protocol {
       if (traceEnabled) {
         traceContext.operation = `oracledb.${message.constructor.name}`;
         traceInstance.onBeginRoundTrip(traceContext);
+        if (traceContext.userContext?.traceParent) {
+          // The traceParent is set from instrumentation module.
+          message.connection.appContext('CLIENTCONTEXT',
+            [{ ora$opentelem$tracectx: traceContext.userContext.traceParent }]);
+        }
       }
       await this._encodeMessage(message);
       if (message.messageType !== constants.TNS_MSG_TYPE_ONEWAY_FN) {
@@ -184,14 +283,7 @@ class Protocol {
         traceInstance.onEndRoundTrip(traceContext);
       }
     }
-    if (message.flushOutBinds) {
-      await this.flushOutBindMessage(message);
-    }
-    this.txnInProgress = Boolean(message.callStatus & constants.TNS_EOCS_FLAGS_TXN_IN_PROGRESS);
-    // processes the call status flags returned by the server.
-    if (message.callStatus & constants.TNS_EOCS_FLAGS_SESS_RELEASE) {
-      message.connection.statementCache.clearCursors();
-    }
+    await this._processCallStatus(message);
 
     if (message.errorOccurred) {
       if (callTimeoutExpired) {
@@ -201,16 +293,9 @@ class Protocol {
         message.errorOccurred = false;
         return await this._processMessage(message);
       }
-      let err = new Error(message.errorInfo.message);
-      err.offset = message.errorInfo.pos;
-      err.errorNum = message.errorInfo.num;
-      err.isRecoverable = message.errorInfo.isRecoverable;
-      err = errors.transformErr(err);
-      if (err.code === errors.ERR_CONNECTION_CLOSED_CODE) {
-        this.nsi.disconnect();
-      }
-      throw err;
+      this._raiseException(message);
     }
+    await message.postProcess();
   }
 
   async flushOutBindMessage(message) {