oracledb 6.5.1 → 6.7.0

package/lib/thin/lob.js

@@ -31,6 +31,7 @@ const LobImpl = require('../impl/lob.js');
 const constants = require('./protocol/constants.js');
 const LobOpMessage = require('./protocol/messages/lobOp.js');
 const errors = require('../errors.js');
+const types = require('../types.js');
 
 class ThinLobImpl extends LobImpl {
 
@@ -54,15 +55,31 @@ class ThinLobImpl extends LobImpl {
     await this.conn._protocol._processMessage(message);
     if (options.operation === constants.TNS_LOB_OP_READ) {
       return (message.data) ? message.data : null;
+    } else if (
+      options.operation === constants.TNS_LOB_OP_FILE_EXISTS ||
+      options.operation === constants.TNS_LOB_OP_FILE_ISOPEN
+    ) {
+      return message.boolFlag;
     } else {
       return message.amount;
     }
   }
 
+  //---------------------------------------------------------------------------
+  // getChunkSize()
+  //
+  // Internal method for returning the chunk size of the LOB.
+  //---------------------------------------------------------------------------
   getChunkSize() {
     return this._chunkSize;
   }
 
+  //---------------------------------------------------------------------------
+  // _getChunkSizeAsync()
+  //
+  // Internal method for returning the chunk size of the LOB fetched from
+  // the database.
+  //---------------------------------------------------------------------------
   async _getChunkSizeAsync() {
     this.checkConn();
     const options = {
@@ -73,29 +90,76 @@ class ThinLobImpl extends LobImpl {
     this._chunkSize = this._pieceSize = await this._sendMessage(options);
   }
 
+  //---------------------------------------------------------------------------
+  // getLength()
+  //
+  // Internal method for returning the length of a LOB.
+  //---------------------------------------------------------------------------
   getLength() {
     return this._length;
   }
 
+  //---------------------------------------------------------------------------
+  // getPieceSize()
+  //
+  // Internal method returning the size to use for each piece that is
+  // transferred when reading from the LOB.
+  //---------------------------------------------------------------------------
   getPieceSize() {
     return this._pieceSize;
   }
 
+  //---------------------------------------------------------------------------
+  // setPieceSize()
+  //
+  // Internal method to set the pieceSize for LOBs.
+  //---------------------------------------------------------------------------
   setPieceSize(value) {
     this._pieceSize = value;
   }
 
+  //---------------------------------------------------------------------------
+  // getType()
+  //
+  // Internal method returning the datatype of LOBs.
+  //---------------------------------------------------------------------------
   getType() {
     return this.dbType;
   }
 
+  //---------------------------------------------------------------------------
+  // getData()
+  //
+  // Internal method returning the data obtained from the database.
+  //---------------------------------------------------------------------------
   async getData(offset = 1, len = this._length) {
+    let shouldClose = false;
     if (!len) {
       len = this._length;
     }
-    return await this.read(offset, len);
+    if (this.dbType === types.DB_TYPE_BFILE) {
+      if (!await this.isFileOpen()) {
+        shouldClose = true;
+        await this.openFile();
+      }
+    }
+    let data;
+    // if read fails and BFILE was opened by application, we close it.
+    try {
+      data = await this.read(offset, len);
+    } finally {
+      if (shouldClose) {
+        await this.closeFile();
+      }
+    }
+    return data;
   }
 
+  //---------------------------------------------------------------------------
+  // read()
+  //
+  // Internal method for reading a portion (or all) of the data in the LOB.
+  //---------------------------------------------------------------------------
   async read(offset, length) {
     this.checkConn();
     const options = {
@@ -108,6 +172,11 @@ class ThinLobImpl extends LobImpl {
     return await this._sendMessage(options);
   }
 
+  //---------------------------------------------------------------------------
+  // write()
+  //
+  // Internal method for writing data to the LOB object.
+  //---------------------------------------------------------------------------
   async write(offset, data) {
     this.checkConn();
     const options = {
@@ -120,6 +189,11 @@ class ThinLobImpl extends LobImpl {
     this._length += data.length;
   }
 
+  //---------------------------------------------------------------------------
+  // getCsfrm()
+  //
+  // Return the character set encoding used by the LOB.
+  //---------------------------------------------------------------------------
   getCsfrm() {
     if (this.dbType._csfrm !== constants.CSFRM_NCHAR) {
       if (this._locator[constants.TNS_LOB_LOC_OFFSET_FLAG_3] &
@@ -155,11 +229,60 @@ class ThinLobImpl extends LobImpl {
     await this._getChunkSizeAsync();
   }
 
+  //---------------------------------------------------------------------------
+  // fileExists()
+  //
+  // Internal method for returning whether the file referenced by a BFILE
+  // exists.
+  //---------------------------------------------------------------------------
+  async fileExists() {
+    this.checkConn();
+    const options = {
+      operation: constants.TNS_LOB_OP_FILE_EXISTS,
+      sourceLobImpl: this,
+    };
+    return await this._sendMessage(options);
+  }
+
+  //---------------------------------------------------------------------------
+  // getDirFileName()
+  //
+  // Internal method for returning the directory alias and name of the file
+  // referenced by a BFILE
+  //---------------------------------------------------------------------------
+  getDirFileName() {
+    const dirNameOffset = constants.TNS_LOB_LOC_FIXED_OFFSET + 2;
+    const dirNameLen = this._locator.readUInt16BE(
+      constants.TNS_LOB_LOC_FIXED_OFFSET
+    );
+    const fileNameOffset = constants.TNS_LOB_LOC_FIXED_OFFSET + dirNameLen + 4;
+    const fileNameLen = this._locator.readUInt16BE(
+      dirNameOffset + dirNameLen
+    );
+    const dirName = this._locator.slice(
+      dirNameOffset, dirNameOffset + dirNameLen
+    ).toString();
+    const fileName = this._locator.slice(
+      fileNameOffset, fileNameOffset + fileNameLen
+    ).toString();
+    return { dirName: dirName, fileName: fileName };
+  }
+
+  //---------------------------------------------------------------------------
+  // checkConn()
+  //
+  // Internal method to check the connection.
+  //---------------------------------------------------------------------------
   checkConn() {
     if (!this.conn.nscon.connected)
       errors.throwErr(errors.ERR_INVALID_CONNECTION);
   }
 
+  //---------------------------------------------------------------------------
+  // close()
+  //
+  // Internal method to close the LOBs using piggyback mechanism.
+  //---------------------------------------------------------------------------
   close() {
     this.checkConn();
     if (this._isTempLob) {
@@ -169,6 +292,25 @@ class ThinLobImpl extends LobImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // closeFile()
+  //
+  // Internal method to close the opened file for BFILE LOBs.
+  //---------------------------------------------------------------------------
+  async closeFile() {
+    this.checkConn();
+    const options = {
+      operation: constants.TNS_LOB_OP_FILE_CLOSE,
+      sourceLobImpl: this,
+    };
+    await this._sendMessage(options);
+  }
+
+  //---------------------------------------------------------------------------
+  // init()
+  //
+  // Internal method to initialize LOBs.
+  //---------------------------------------------------------------------------
   init(conn, locator, dbType, len, chunkSize) {
     this.dirtyLength = false;
     this.conn = conn;
@@ -184,6 +326,56 @@ class ThinLobImpl extends LobImpl {
     this._pieceSize = chunkSize;
   }
 
+  //---------------------------------------------------------------------------
+  // isFileOpen()
+  //
+  // Internal method to check if the file is already open.
+  //---------------------------------------------------------------------------
+  async isFileOpen() {
+    const options = {
+      operation: constants.TNS_LOB_OP_FILE_ISOPEN,
+      sourceLobImpl: this
+    };
+    await this._sendMessage(options);
+  }
+
+  //---------------------------------------------------------------------------
+  // openFile()
+  //
+  // Internal method for opening file (BFILE).
+  //---------------------------------------------------------------------------
+  async openFile() {
+    this.checkConn();
+    const options =  {
+      operation: constants.TNS_LOB_OP_FILE_OPEN,
+      sourceLobImpl: this,
+      amount: constants.TNS_LOB_OPEN_READ_ONLY,
+      sendAmount: true
+    };
+    return await this._sendMessage(options);
+  }
+
+  //---------------------------------------------------------------------------
+  // setDirFileName()
+  //
+  // Internal method for setting the directory alias and name of the file
+  // referenced by a BFILE
+  //---------------------------------------------------------------------------
+  setDirFileName(dirObject) {
+    const dirNameLen = Buffer.byteLength(dirObject.dirName);
+    const dirNameOffset = constants.TNS_LOB_LOC_FIXED_OFFSET + 2;
+    const fileNameOffset = dirNameOffset + dirNameLen + 2;
+    const fileNameLen = Buffer.byteLength(dirObject.fileName);
+    const newLocLen = fileNameOffset + fileNameLen;
+    const newLocator = Buffer.allocUnsafe(newLocLen);
+    this._locator.copy(newLocator, 0, 0, constants.TNS_LOB_LOC_FIXED_OFFSET + 1);
+    newLocator.writeUInt16BE(dirNameLen, constants.TNS_LOB_LOC_FIXED_OFFSET);
+    newLocator.write(dirObject.dirName, dirNameOffset);
+    newLocator.writeInt16BE(fileNameLen, dirNameOffset + dirNameLen);
+    newLocator.write(dirObject.fileName, fileNameOffset);
+    this._locator = newLocator;
+  }
+
 }
 
 module.exports = ThinLobImpl;

package/lib/thin/pool.js

@@ -44,6 +44,9 @@ class ThinPoolImpl extends PoolImpl {
     if (!params.homogeneous) {
       errors.throwErr(errors.ERR_NOT_IMPLEMENTED, 'Heterogeneous Pooling');
     }
+    if (!params.connectString) {
+      errors.throwErr(errors.ERR_EMPTY_CONNECT_STRING);
+    }
     thinUtil.checkCredentials(params);
 
     this._availableObjects = [];
@@ -64,6 +67,7 @@ class ThinPoolImpl extends PoolImpl {
     this._usedConnectionList = new Set();
     this._password = params.password;
     this._walletPassword = params.walletPassword;
+    this._walletContent = params.walletContent;
     this._obfuscatedPassword = [];
     this._obfuscatedWalletPassword = [];
     this._token = params.token;
@@ -88,6 +92,13 @@ class ThinPoolImpl extends PoolImpl {
       this._obfuscatedWalletPassword = obj.obfuscatedValue;
       this._userConfig.walletPassword = null;
     }
+    // wallet content obfuscation
+    if (this._walletContent !== undefined) {
+      const obj = protocolUtil.setObfuscatedValue(this._walletContent);
+      this._walletContent = obj.value;
+      this._obfuscatedWalletContent = obj.obfuscatedValue;
+      this._userConfig.walletConent = null;
+    }
     // token obfuscation
     if (this._token !== undefined) {
       const obj = protocolUtil.setObfuscatedValue(this._token);
@@ -172,6 +183,13 @@ class ThinPoolImpl extends PoolImpl {
           this._obfuscatedWalletPassword);
     }
 
+    // deobfuscate wallet content
+    if (clonedAttrs.walletContent === null) {
+      clonedAttrs.walletContent =
+            protocolUtil.getDeobfuscatedValue(this._walletContent,
+              this._obfuscatedWalletContent);
+    }
+
     // deobfuscate token and private key
     // check for token expiry
     if (clonedAttrs.token === null) {

package/lib/thin/protocol/capabilities.js

@@ -118,6 +118,8 @@ class Capabilities {
       constants.TNS_CCAP_CTB_IMPLICIT_POOL;
     this.compileCaps[constants.TNS_CCAP_TTC5] =
       constants.TNS_CCAP_VECTOR_SUPPORT;
+    this.compileCaps[constants.TNS_CCAP_VECTOR_FEATURES] =
+      constants.TNS_CCAP_VECTOR_FEATURE_BINARY;
   }
 
   initRuntimeCaps() {

package/lib/thin/protocol/constants.js

@@ -492,12 +492,17 @@ module.exports = {
   TNS_LOB_OP_CLOSE: 0x10000,
   TNS_LOB_OP_IS_OPEN: 0x11000,
   TNS_LOB_OP_ARRAY: 0x80000,
+  TNS_LOB_OP_FILE_OPEN: 0x0100,
+  TNS_LOB_OP_FILE_CLOSE: 0x0200,
+  TNS_LOB_OP_FILE_ISOPEN: 0x0400,
+  TNS_LOB_OP_FILE_EXISTS: 0x0800,
 
   // LOB locator constants
   TNS_LOB_LOC_OFFSET_FLAG_1: 4,
   TNS_LOB_LOC_OFFSET_FLAG_3: 6,
   TNS_LOB_LOC_OFFSET_FLAG_4: 7,
   TNS_LOB_QLOCATOR_VERSION: 4,
+  TNS_LOB_LOC_FIXED_OFFSET: 16,
 
   // LOB locator flags (byte 1)
   TNS_LOB_LOC_FLAGS_BLOB: 0x01,
@@ -513,6 +518,7 @@ module.exports = {
 
   // other LOB constants
   TNS_LOB_OPEN_READ_WRITE: 2,
+  TNS_LOB_OPEN_READ_ONLY: 11,
   TNS_LOB_PREFETCH_FLAG: 0x2000000,
 
   // base JSON constants
@@ -548,6 +554,8 @@ module.exports = {
   TNS_FUNC_SESSION_RELEASE: 163,
   TNS_FUNC_SESSION_STATE: 176, // piggyback fn
   TNS_FUNC_CANCEL_ALL: 120, // piggyback fn
+  TNS_FUNC_TPC_TXN_SWITCH: 103,
+  TNS_FUNC_TPC_TXN_CHANGE_STATE: 104,
 
   // character sets and encodings
   TNS_CHARSET_UTF8: 873,
@@ -578,7 +586,8 @@ module.exports = {
   TNS_CCAP_TTC4: 40,
   TNS_CCAP_LOB2: 42,
   TNS_CCAP_TTC5: 44,
-  TNS_CCAP_MAX: 51,
+  TNS_CCAP_VECTOR_FEATURES: 52,
+  TNS_CCAP_MAX: 53,
 
   // compile time capability values
   TNS_CCAP_SQL_VERSION_MAX: 6,
@@ -634,6 +643,7 @@ module.exports = {
   TNS_CCAP_LOB2_2GB_PREFETCH: 0x04,
   TNS_CCAP_CTB_IMPLICIT_POOL: 0x08,
   TNS_CCAP_VECTOR_SUPPORT: 0x08,
+  TNS_CCAP_VECTOR_FEATURE_BINARY: 0x01,
 
   // runtime capability indices
   TNS_RCAP_COMPAT: 0,
@@ -660,6 +670,24 @@ module.exports = {
   TNS_EOCS_FLAGS_TXN_IN_PROGRESS: 0x00000002,
   TNS_EOCS_FLAGS_SESS_RELEASE: 0x00008000,
 
+  // transaction switching op codes
+  TNS_TPC_TXN_START: 0x01,
+  TNS_TPC_TXN_DETACH: 0x02,
+
+  // transaction change state op codes
+  TNS_TPC_TXN_COMMIT: 0x01,
+  TNS_TPC_TXN_ABORT: 0x02,
+  TNS_TPC_TXN_PREPARE: 0x03,
+  TNS_TPC_TXN_FORGET: 0x04,
+
+  // transaction states
+  TNS_TPC_TXN_STATE_PREPARE: 0,
+  TNS_TPC_TXN_STATE_REQUIRES_COMMIT: 1,
+  TNS_TPC_TXN_STATE_COMMITTED: 2,
+  TNS_TPC_TXN_STATE_ABORTED: 3,
+  TNS_TPC_TXN_STATE_READ_ONLY: 4,
+  TNS_TPC_TXN_STATE_FORGOTTEN: 5,
+
   // other constants
   TNS_ESCAPE_CHAR: 253,
   TNS_LONG_LENGTH_INDICATOR: dataHandlerConstants.TNS_LONG_LENGTH_INDICATOR,

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

@@ -102,6 +102,11 @@ class AuthMessage extends Message {
     }
     this.serviceName = this.conn.serviceName;
     this.remoteAddress = this.conn.remoteAddress;
+    this.driverName = config.driverName;
+    this.machine = config.machine;
+    this.osUser = config.osUser;
+    this.program = config.program;
+    this.terminal = config.terminal;
     this.setAuthMode(config);
   }
 
@@ -181,11 +186,11 @@ class AuthMessage extends Message {
       if (this.userByteLen > 0) {
         buf.writeBytesWithLength(Buffer.from(this.username));
       }
-      buf.writeKeyValue("AUTH_TERMINAL", cInfo.terminal);
-      buf.writeKeyValue("AUTH_PROGRAM_NM", cInfo.program);
-      buf.writeKeyValue("AUTH_MACHINE", cInfo.hostName);
+      buf.writeKeyValue("AUTH_TERMINAL", this.terminal ?? cInfo.terminal);
+      buf.writeKeyValue("AUTH_PROGRAM_NM", this.program ?? cInfo.program);
+      buf.writeKeyValue("AUTH_MACHINE", this.machine ?? cInfo.hostName);
       buf.writeKeyValue("AUTH_PID", cInfo.pid);
-      buf.writeKeyValue("AUTH_SID", cInfo.userName);
+      buf.writeKeyValue("AUTH_SID", this.osUser ?? cInfo.userName);
     } else {
       let numPairs = 0;
 
@@ -253,7 +258,8 @@ class AuthMessage extends Message {
       }
       if (!this.changePassword) {
         buf.writeKeyValue("SESSION_CLIENT_CHARSET", "873");
-        buf.writeKeyValue("SESSION_CLIENT_DRIVER_NAME", constants.DRIVER_NAME);
+        buf.writeKeyValue("SESSION_CLIENT_DRIVER_NAME",
+          this.driverName ?? constants.DRIVER_NAME);
         buf.writeKeyValue("SESSION_CLIENT_VERSION",
           constants.CLIENT_VERSION.toString());
         buf.writeKeyValue("AUTH_ALTER_SESSION", this.getAlterTimezoneStatement(), 1);
@@ -321,7 +327,7 @@ class AuthMessage extends Message {
       let portUpdateNum;
 
       this.conn.dbDomain = this.sessionData['AUTH_SC_DB_DOMAIN'];
-      this.conn.dbName = this.sessionData['AUTH_SC_DBUNIQUE_NAME'];
+      this.conn.dbName = this.sessionData['AUTH_DBNAME'];
       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'];

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

@@ -296,6 +296,9 @@ class Message {
       this._writeCurrentSchemaPiggyback(buf);
     }
     if (this.connection.statementCache._cursorsToClose.size > 0 && !this.connection._drcpEstablishSession) {
+      // skip closing cursors when '_drcpEstablishSession = true' Since we don't know whether the same session
+      // is in use. We can not send the information across until after the session information has been returned
+      // (on the first round trip).
       this.writeCloseCursorsPiggyBack(buf);
     }
     if (

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

@@ -38,6 +38,8 @@ const ProtocolMessage = require('./protocol.js');
 const RollbackMessage = require('./rollback.js');
 const SessionReleaseMessage = require('./sessionRelease.js');
 const FastAuthMessage = require('./fastAuth.js');
+const TransactionChangeStateMessage = require('./transactionChangeState.js');
+const TransactionSwitchMessage = require('./transactionSwitch.js');
 
 module.exports = {
   AuthMessage,
@@ -51,5 +53,7 @@ module.exports = {
   PingMessage,
   ProtocolMessage,
   RollbackMessage,
-  SessionReleaseMessage
+  SessionReleaseMessage,
+  TransactionChangeStateMessage,
+  TransactionSwitchMessage
 };

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

@@ -90,8 +90,13 @@ class LobOpMessage extends Message {
       buf.writeUInt8(0);
     }
     buf.writeUInt8(0);
-    if (this.operation === constants.TNS_LOB_OP_CREATE_TEMP
-        || this.operation === constants.TNS_LOB_OP_IS_OPEN) {
+    const operations = [
+      constants.TNS_LOB_OP_CREATE_TEMP,
+      constants.TNS_LOB_OP_IS_OPEN,
+      constants.TNS_LOB_OP_FILE_EXISTS,
+      constants.TNS_LOB_OP_FILE_ISOPEN,
+    ];
+    if (operations.includes(this.operation)) {
       buf.writeUInt8(1);
     } else {
       buf.writeUInt8(0);
@@ -152,7 +157,10 @@ class LobOpMessage extends Message {
       const oraTypeNum = this.sourceLobImpl.dbType._oraTypeNum;
       let data = buf.readBytesWithLength();
       if (data !== null) {
-        if (oraTypeNum === constants.TNS_DATA_TYPE_BLOB) {
+        if (
+          oraTypeNum === constants.TNS_DATA_TYPE_BLOB ||
+          oraTypeNum === constants.TNS_DATA_TYPE_BFILE
+        ) {
           data = Buffer.from(data);
         } else if (this.sourceLobImpl.getCsfrm() === constants.CSFRM_NCHAR) {
           data = Buffer.from(data).swap16().toString('utf16le');
@@ -189,8 +197,12 @@ class LobOpMessage extends Message {
     } else if (this.sendAmount) {
       this.amount = buf.readSB8();
     }
-    if (this.operation === constants.TNS_LOB_OP_IS_OPEN) {
-      temp8 = buf.readUB1();
+    if (
+      this.operation === constants.TNS_LOB_OP_IS_OPEN
+      || this.operation === constants.TNS_LOB_OP_FILE_EXISTS
+      || this.operation === constants.TNS_LOB_OP_FILE_ISOPEN
+    ) {
+      temp8 = buf.readUInt8();
       this.boolFlag = temp8 > 0;
     }
   }

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

@@ -45,6 +45,7 @@ class SessionReleaseMessage extends Message {
   }
 
   encode(buf) {
+    this.writePiggybacks(buf);
     this.writeFunctionHeader(buf);
     buf.writeUInt8(0); // pointer (tag name)
     buf.writeUInt8(0); // tag name length

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

@@ -0,0 +1,99 @@
+// Copyright (c) 2024, Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
+
+'use strict';
+
+const Message = require("./base.js");
+const constants = require("../constants.js");
+
+/**
+ * Used for two-phase commit (TPC) transaction change state: commit, rollback,
+ * forget, etc.
+ *
+ * @class TransactionChangeStateMessage
+ * @extends {Message}
+ */
+class TransactionChangeStateMessage extends Message {
+
+  constructor(connImpl) {
+    super(connImpl);
+    this.functionCode = constants.TNS_FUNC_TPC_TXN_CHANGE_STATE;
+  }
+
+  processReturnParameter(buf) {
+    // process the parameters returned by the datatabase
+    this.state = buf.readUB4();
+  }
+
+  encode(buf) {
+    // writes the message to the database
+    // acquire data to send to the server
+    let xidBytes;
+    if (this.xid) {
+      xidBytes = Buffer.alloc(128);
+      this.xid.globalTransactionId.copy(xidBytes);
+      this.xid.branchQualifier.copy(xidBytes,
+        this.xid.globalTransactionId.length);
+    }
+
+    this.writeFunctionHeader(buf);
+    buf.writeUB4(this.operation);
+    if (this.context) {
+      buf.writeUInt8(1);
+      buf.writeUB4(this.context.length);
+    } else {
+      buf.writeUInt8(0);
+      buf.writeUB4(0);
+    }
+
+    if (this.xid) {
+      buf.writeUB4(this.xid.formatId);
+      buf.writeUB4(this.xid.globalTransactionId.length);
+      buf.writeUB4(this.xid.branchQualifier.length);
+      buf.writeUInt8(1);
+      buf.writeUB4(xidBytes.length);
+    } else {
+      buf.writeUB4(0);
+      buf.writeUB4(0);
+      buf.writeUB4(0);
+      buf.writeUInt8(0);
+      buf.writeUB4(0);
+    }
+    buf.writeUB4(0);
+    buf.writeUB4(this.state);
+    buf.writeUInt8(1);
+    buf.writeUB4(this.flags);
+
+    if (this.context) {
+      buf.writeBytes(this.context);
+    }
+    if (this.xid) {
+      buf.writeBytes(xidBytes);
+    }
+  }
+}
+
+module.exports = TransactionChangeStateMessage;