oracledb 5.5.0 → 6.0.1

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

@@ -0,0 +1,312 @@
+// Copyright (c) 2022, 2023, 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 MessageWithData = require("./withData.js");
+const constants = require("../constants.js");
+const errors = require("../../../errors.js");
+
+/**
+ *
+ * Executes OALL8 RPC function
+ *
+ * @class ExecuteMessage
+ * @extends {MessageWithData}
+ */
+class ExecuteMessage extends MessageWithData {
+  /**
+   *
+   * @param {object} statement
+   * @param {object} options
+   */
+  constructor(connection, statement, options, resultSet) {
+    super(connection, statement, options);
+    if (!resultSet && statement.isQuery) {
+      resultSet = connection._createResultSet(options, statement);
+    }
+    this.resultSet = resultSet;
+    this.functionCode = constants.TNS_FUNC_EXECUTE;
+    this.bindParams = undefined;
+    this.currentRow = 0;
+  }
+
+  //-------------------------------------------------------------------------
+  // writeReExecuteMessage()
+  //
+  // Write the message for a full execute.
+  //-------------------------------------------------------------------------
+  writeExecuteMessage(buf) {
+    let options = 0x0;
+    let dmlOptions = 0;
+    let numParams = 0;
+    let numIters = 1;
+    // Configuring the options field thats send to the server
+    let stmt = this.statement;
+    let params = stmt.bindInfoList;
+
+    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;
+      options |= constants.TNS_EXEC_OPTION_EXECUTE;
+    }
+    if (stmt.cursorId == 0 || stmt.isDdl) {
+      options |= constants.TNS_EXEC_OPTION_PARSE;
+    }
+    if (stmt.isQuery) {
+      if (this.parseOnly) {
+        options |= constants.TNS_EXEC_OPTION_DESCRIBE;
+      } else {
+        if (this.options.prefetchRows > 0) {
+          options |= constants.TNS_EXEC_OPTION_FETCH;
+        }
+        if (stmt.cursorId === 0 || stmt.requiresDefine) {
+          numIters = this.options.prefetchRows;
+        } else {
+          numIters = this.options.fetchArraySize;
+        }
+      }
+    }
+    if (!stmt.isPlSql && !this.parseOnly) {
+      options |= constants.TNS_EXEC_OPTION_NOT_PLSQL;
+    } else if (stmt.isPlSql && numParams > 0) {
+      options |= constants.TNS_EXEC_OPTION_PLSQL_BIND;
+    }
+    if (numParams > 0) {
+      options |= constants.TNS_EXEC_OPTION_BIND;
+    }
+    if (this.batchErrors) {
+      options |= constants.TNS_EXEC_OPTION_BATCH_ERRORS;
+    }
+    if (this.arrayDmlRowCounts) {
+      dmlOptions = constants.TNS_EXEC_OPTION_DML_ROWCOUNTS;
+    }
+    if (this.options.autoCommit) {
+      options |= constants.TNS_EXEC_OPTION_COMMIT;
+    }
+    this.writePiggybacks(buf);
+    this.writeFunctionHeader(buf);
+    buf.writeUB4(options);                           // execute options
+    buf.writeUB4(stmt.cursorId);                     // cursor id
+    if (stmt.cursorId === 0 || stmt.isDdl) {
+      buf.writeUInt8(1);                             // pointer (cursor id)
+      buf.writeUB4(stmt.sqlLength);
+    } else {
+      buf.writeUInt8(0);                             // pointer (cursor id)
+      buf.writeUB4(0);
+    }
+    buf.writeUInt8(1);                               // pointer (vector)
+    buf.writeUB4(13);                                // al8i4 array length
+    buf.writeUInt8(0);                               // pointer (al8o4)
+    buf.writeUInt8(0);                               // pointer (al8o4l)
+    buf.writeUInt8(0);                               // prefetc buffer size
+    buf.writeUB4(numIters);                          // prefetch num rows
+    buf.writeUB4(constants.TNS_MAX_LONG_LENGTH);     // maximum long size
+    if (numParams === 0) {
+      buf.writeUInt8(0);                             // pointer (binds)
+      buf.writeUB4(0);                               // number of binds
+    } else {
+      buf.writeUInt8(1);                             // pointer (binds)
+      buf.writeUB4(numParams);                       // number of binds
+    }
+    buf.writeUInt8(0);                               // pointer (al8pp)
+    buf.writeUInt8(0);                               // pointer (al8txn)
+    buf.writeUInt8(0);                               // pointer (al8txl)
+    buf.writeUInt8(0);                               // pointer (al8kv)
+    buf.writeUInt8(0);                               // pointer (al8kvl)
+    if (stmt.requiresDefine) {
+      buf.writeUInt8(1);                             // pointer (al8doac)
+      buf.writeUB4(this.statement.queryVars.length);     // number of defines
+    } else {
+      buf.writeUInt8(0);
+      buf.writeUB4(0);
+    }
+    buf.writeUB4(0);                                 // registration id
+    buf.writeUInt8(0);                               // pointer (al8objlist)
+    buf.writeUInt8(1);                               // pointer (al8objlen)
+    buf.writeUInt8(0);                               // pointer (al8blv)
+    buf.writeUB4(0);                                 // al8blv
+    buf.writeUInt8(0);                               // pointer (al8dnam)
+    buf.writeUB4(0);                                 // al8dnaml
+    buf.writeUB4(0);                                 // al8regid_msb
+    if (this.arrayDmlRowCounts) {
+      buf.writeUInt8(1);                             // pointer (al8pidmlrc)
+      buf.writeUB4(this.numExecs);                   // al8pidmlrcbl
+      buf.writeUInt8(1);                             // pointer (al8pidmlrcl)
+    } else {
+      buf.writeUInt8(0);                             // pointer (al8pidmlrc)
+      buf.writeUB4(0);                               // al8pidmlrcbl
+      buf.writeUInt8(0);                             // pointer (al8pidmlrcl)
+    }
+    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_12_2) {
+      buf.writeUInt8(0);                             // pointer (al8sqlsig)
+      buf.writeUB4(0);                               // SQL signature length
+      buf.writeUInt8(0);                             // pointer (SQL ID)
+      buf.writeUB4(0);                               // allocated size of SQL ID
+      buf.writeUInt8(0);                             // pointer (length of SQL ID)
+      if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_12_2_EXT1) {
+        buf.writeUInt8(0);                           // pointer (chunk ids)
+        buf.writeUB4(0);                             // number of chunk ids
+      }
+    }
+    if (stmt.cursorId === 0 || stmt.isDdl) {
+      if (stmt.sql) {
+        buf.writeBytesWithLength(stmt.sqlBytes);
+        buf.writeUB4(1);                             // al8i4[0] parse
+      } else {
+        errors.throwErr(errors.ERR_INVALID_REF_CURSOR);
+      }
+    } else {
+      buf.writeUB4(0);                               // al8i4[0] parse
+    }
+    if (stmt.isQuery) {
+      if (stmt.cursorId === 0) {
+        buf.writeUB4(0);                             // al8i4[1] execution count
+      } else {
+        buf.writeUB4(numIters);
+      }
+    } else {
+      buf.writeUB4(this.numExecs);                   // al8i4[1] execution count
+    }
+    buf.writeUB4(0);                                 // al8i4[2]
+    buf.writeUB4(0);                                 // al8i4[3]
+    buf.writeUB4(0);                                 // al8i4[4]
+    buf.writeUB4(0);                                 // al8i4[5] SCN (part 1)
+    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(0);                                 // al8i4[10]
+    buf.writeUB4(0);                                 // al8i4[11]
+    buf.writeUB4(0);                                 // al8i4[12]
+
+    /*
+     * write column metadata and bind params
+     */
+    if (stmt.requiresDefine) {
+      this.writeColumnMetadata(buf, this.statement.queryVars);
+    } else if (numParams > 0) {
+      return this.processBindParams(buf, params);
+    }
+  }
+
+  //-------------------------------------------------------------------------
+  // writeReExecuteMessage()
+  //
+  // Write the message header for a re-execute and return the bind parameters.
+  //-------------------------------------------------------------------------
+  writeReExecuteMessage(buf) {
+    let stmt = this.statement;
+    let params = stmt.bindInfoList;
+    let execFlag1 = 0, execFlag2 = 0, numIters;
+    if (params !== undefined) {
+      if (!stmt.isQuery) {
+        this.outVariables = [];
+        params.forEach(info => {
+          if (info.bindDir !== constants.TNS_BIND_DIR_INPUT) {
+            this.outVariables.push(info.bindVar);
+          }
+        });
+      }
+
+      let tmpparams = [];
+      params.forEach(info => {
+        if (info.bindDir !== constants.TNS_BIND_DIR_OUTPUT && !info.isReturnBind) {
+          tmpparams.push(info);
+        }
+      });
+      params = tmpparams;
+    }
+
+    if (this.functionCode === constants.TNS_FUNC_REEXECUTE_AND_FETCH) {
+      execFlag1 |= constants.TNS_EXEC_OPTION_EXECUTE;
+      numIters = this.options.prefetchRows;
+    } else {
+      if (this.options.autoCommit) {
+        execFlag2 |= constants.TNS_EXEC_OPTION_COMMIT_REEXECUTE;
+      }
+      numIters = this.numExecs;
+    }
+    this.writePiggybacks(buf);
+    this.writeFunctionHeader(buf);
+    buf.writeUB4(stmt.cursorId);
+    buf.writeUB4(numIters);
+    buf.writeUB4(execFlag1);
+    buf.writeUB4(execFlag2);
+    return params;
+  }
+
+  //-------------------------------------------------------------------------
+  // encode()
+  //
+  // Write the execute message to the buffer. Two types of execute messages
+  // are possible: one for a full execute and the second, simpler message,
+  // for when an existing cursor is being re-executed.
+  //-------------------------------------------------------------------------
+  encode(buf) {
+
+    // no rows have yet been sent so the header information needs to be sent
+    if (this.currentRow === 0) {
+      let stmt = this.statement;
+      if (stmt.cursorId !== 0 && !stmt.requiresFullExecute && !this.parseOnly && !stmt.requiresDefine && !stmt.isDdl && !this.batchErrors) {
+        if (stmt.isQuery && !stmt.requiresDefine && this.options.prefetchRows > 0) {
+          this.functionCode = constants.TNS_FUNC_REEXECUTE_AND_FETCH;
+        } else {
+          this.functionCode = constants.TNS_FUNC_REEXECUTE;
+        }
+        this.bindParams = this.writeReExecuteMessage(buf);
+      } else {
+        this.functionCode = constants.TNS_FUNC_EXECUTE;
+        this.bindParams = this.writeExecuteMessage(buf);
+      }
+    }
+
+    // if any bind parameters need to be sent, do that
+    // after each row is sent, check to see whether a pause should be performed
+    if (this.bindParams && this.bindParams.length > 0) {
+      const adapter = buf.nsi.ntAdapter;
+      while (this.currentRow < this.numExecs) {
+        buf.writeUInt8(constants.TNS_MSG_TYPE_ROW_DATA);
+        this.writeBindParamsRow(buf, this.bindParams, this.currentRow);
+        this.currentRow++;
+        if (this.currentRow < this.numExecs && adapter.shouldPauseWrite())
+          return true;
+      }
+    }
+
+    // reset state in case message is resent
+    this.currentRow = 0;
+    this.bindParams = undefined;
+
+  }
+
+}
+
+module.exports = ExecuteMessage;

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

@@ -0,0 +1,60 @@
+// Copyright (c) 2022, 2023, 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 constants = require("../constants.js");
+const MessageWithData = require("./withData.js");
+
+/**
+ * Executes OFETCH RPC
+ *
+ * @class FetchMessage
+ * @extends {MessageWithData}
+ */
+class FetchMessage extends MessageWithData {
+
+  constructor(connection, statement, options, resultSet) {
+    super(connection, statement, options);
+    this.resultSet = resultSet;
+    this.functionCode = constants.TNS_FUNC_FETCH;
+  }
+
+  //-------------------------------------------------------------------------
+  // encode()
+  //
+  // Write the cursor ID and the number of rows to be fetched in the
+  // Fetch Message RPC
+  //-------------------------------------------------------------------------
+  encode(buf) {
+    this.writeFunctionHeader(buf);
+    buf.writeUB4(this.statement.cursorId);
+    buf.writeUB4(this.options.fetchArraySize);
+  }
+
+}
+
+module.exports = FetchMessage;

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

@@ -0,0 +1,53 @@
+// Copyright (c) 2023, 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 AuthMessage = require('./auth.js');
+const CommitMessage = require('./commit.js');
+const DataTypeMessage = require('./dataType.js');
+const ExecuteMessage = require('./execute.js');
+const FetchMessage = require('./fetch.js');
+const LobOpMessage = require('./lobOp.js');
+const LogOffMessage = require('./logOff.js');
+const PingMessage = require('./ping.js');
+const ProtocolMessage = require('./protocol.js');
+const RollbackMessage = require('./rollback.js');
+const SessionReleaseMessage = require('./sessionRelease.js');
+
+module.exports = {
+  AuthMessage,
+  CommitMessage,
+  DataTypeMessage,
+  ExecuteMessage,
+  FetchMessage,
+  LobOpMessage,
+  LogOffMessage,
+  PingMessage,
+  ProtocolMessage,
+  RollbackMessage,
+  SessionReleaseMessage
+};

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

@@ -0,0 +1,201 @@
+// Copyright (c) 2022, 2023, 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 { Buffer } = require('buffer');
+const constants = require('../constants.js');
+const Message = require('./base.js');
+
+/**
+ * Abstracts all LOB operations.
+ *
+ * @class LobOpMessage
+ * @extends {Message}
+ */
+class LobOpMessage extends Message {
+
+  constructor(connImpl, options) {
+    super(connImpl);
+    /*
+     * source LOB locator. Reading data from it.
+     */
+    this.sourceLobImpl = options.sourceLobImpl || null;
+    this.operation = options.operation;
+    /*
+     * Destination LOB locator. For copy, append operations,...
+     */
+    this.destLobImpl = options.destLobImpl || null;
+    /*
+     * Offset from where sourceLob operation to start
+     */
+    this.sourceOffset = options.sourceOffset || 0;
+    /*
+     * Offset from where destLob operation to start
+     */
+    this.destOffset = options.destOffset || 0;
+    this.boolFlag = false;
+    if (options.data) { // data available For Writes
+      this.data = options.data;
+    }
+    this.functionCode = constants.TNS_FUNC_LOB_OP;
+    this.sendAmount = options.sendAmount;
+    this.amount = options.amount || 0; // LOB length
+  }
+
+  encode(buf) {
+    this.writeFunctionHeader(buf);
+    if (this.sourceLobImpl === null) {
+      buf.writeUInt8(0);
+      buf.writeUB4(0);
+    } else {
+      buf.writeUInt8(1);
+      buf.writeUB4(this.sourceLobImpl._locator.length);
+    }
+    if (this.destLobImpl === null) {
+      buf.writeUInt8(0);
+      buf.writeUB4(0);
+    } else {
+      buf.writeUInt8(1);
+      buf.writeUB4(this.destLobImpl._locator.length);
+    }
+    buf.writeUB4(0);
+    buf.writeUB4(0);
+    if (this.operation === constants.TNS_LOB_OP_CREATE_TEMP) {
+      buf.writeUInt8(1);
+    } else {
+      buf.writeUInt8(0);
+    }
+    buf.writeUInt8(0);
+    if (this.operation === constants.TNS_LOB_OP_CREATE_TEMP
+        || this.operation === constants.TNS_LOB_OP_IS_OPEN) {
+      buf.writeUInt8(1);
+    } else {
+      buf.writeUInt8(0);
+    }
+    buf.writeUB4(this.operation);
+    buf.writeUInt8(0);
+    buf.writeUInt8(0);
+    buf.writeUB8(this.sourceOffset);
+    buf.writeUB8(this.destOffset);
+    if (this.sendAmount) {
+      buf.writeUInt8(1);
+    } else {
+      buf.writeUInt8(0);
+    }
+    for (let i = 0; i < 3; i++) {
+      buf.writeUInt16BE(0);
+    }
+    if (this.sourceLobImpl) {
+      buf.writeBytes(this.sourceLobImpl._locator);
+    }
+    if (this.destLobImpl) {
+      buf.writeBytes(this.destLobImpl._locator);
+    }
+    if (this.operation === constants.TNS_LOB_OP_CREATE_TEMP) {
+      if (this.sourceLobImpl.dbType._csfrm === constants.TNS_CS_NCHAR) {
+        buf.caps.checkNCharsetId();
+        buf.writeUB4(constants.TNS_CHARSET_UTF16);
+      } else {
+        buf.writeUB4(constants.TNS_CHARSET_UTF8);
+      }
+    }
+    if (this.data) {
+      let data;
+      buf.writeUInt8(constants.TNS_MSG_TYPE_LOB_DATA);
+      if (this.sourceLobImpl.dbType._oraTypeNum === constants.TNS_DATA_TYPE_BLOB) {
+        data = this.data;
+      } else if (this.sourceLobImpl.getCsfrm() === constants.TNS_CS_NCHAR) {
+        data = this.data;
+        // TODO: avoid conversion back to string, if possible
+        // this is since bind data is converted to buffer automatically, but if
+        // it exceeds 32K for PL/SQL it must be written as a temporary LOB
+        if (Buffer.isBuffer(this.data)) {
+          data = data.toString();
+        }
+        data = Buffer.from(data, constants.TNS_ENCODING_UTF16).swap16();
+      } else {
+        data = Buffer.from(this.data);
+      }
+      buf.writeBytesWithLength(data);
+    }
+    if (this.sendAmount) {
+      buf.writeUB8(this.amount);
+    }
+  }
+
+  processMessage(buf, messageType) {
+    if (messageType === constants.TNS_MSG_TYPE_LOB_DATA) {
+      const oraTypeNum = this.sourceLobImpl.dbType._oraTypeNum;
+      let data = buf.readBytesWithLength();
+      if (data !== null) {
+        if (oraTypeNum === constants.TNS_DATA_TYPE_BLOB) {
+          data = Buffer.from(data);
+        } else if (this.sourceLobImpl.getCsfrm() === constants.TNS_CS_NCHAR) {
+          data = Buffer.from(data).swap16().toString('utf16le');
+        } else {
+          data = data.toString();
+        }
+      }
+      this.data = data;
+    } else {
+      super.processMessage(buf, messageType);
+    }
+  }
+
+  processReturnParameter(buf) {
+    let lobArray;
+    let locator;
+    let temp16;
+    let numBytes;
+    if (this.sourceLobImpl !== null) {
+      numBytes = this.sourceLobImpl._locator.length;
+      lobArray = buf.readBytes(numBytes);
+      locator = lobArray.slice(0, numBytes);
+      locator.copy(this.sourceLobImpl._locator);
+    }
+    if (this.destLobImpl !== null) {
+      numBytes = this.destLobImpl._locator.length;
+      lobArray = buf.readBytes(numBytes);
+      locator = lobArray.slice(0, numBytes);
+      locator.copy(this.destLobImpl._locator);
+    }
+    if (this.operation === constants.TNS_LOB_OP_CREATE_TEMP) {
+      buf.skipUB2();
+    }
+    if (this.sendAmount) {
+      this.amount = buf.readSB8();
+    }
+    if (this.operation === constants.TNS_LOB_OP_CREATE_TEMP
+      || this.operation === constants.TNS_LOB_OP_IS_OPEN) {
+      temp16 = buf.readUB2();
+      this.boolFlag = temp16 > 0;
+    }
+  }
+
+}
+
+module.exports = LobOpMessage;

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

@@ -0,0 +1,53 @@
+// Copyright (c) 2022, 2023, 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");
+
+/**
+ * Executes Logoff RPC
+ *
+ * @class LogOffMessage
+ * @extends {Message}
+ *
+ */
+class LogOffMessage extends Message {
+
+  constructor(connImpl) {
+    super(connImpl);
+    this.functionCode = constants.TNS_FUNC_LOGOFF;
+  }
+
+  encode(buf) {
+    this.writePiggybacks(buf);
+    this.writeFunctionHeader(buf);
+  }
+
+}
+
+module.exports = LogOffMessage;