oracledb 6.0.2 → 6.1.0

package/lib/thin/connection.js

@@ -32,7 +32,7 @@ const ThinResultSetImpl = require('./resultSet.js');
 const ThinLobImpl  = require("./lob.js");
 const Protocol = require("./protocol/protocol.js");
 const { BaseBuffer } = require('./protocol/buffer.js');
-const {NetworkSession:nsi, getConnectionInfo} = require("./sqlnet/networkSession.js");
+const {NetworkSession:nsi} = require("./sqlnet/networkSession.js");
 const { Statement } = require("./statement");
 const thinUtil = require('./util');
 const sqlNetConstants = require('./sqlnet/constants.js');
@@ -49,6 +49,8 @@ const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
 class TDSBuffer extends BaseBuffer {
 }
 
+const connectionCookies = new Map();
+
 class ThinConnectionImpl extends ConnectionImpl {
 
   /**
@@ -443,10 +445,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     await this._protocol.breakMessage();
   }
 
-  _healthStatus() {
-    return this.nscon.recvInbandNotif();
-  }
-
   isHealthy() {
     try {
       if (this.nscon.recvInbandNotif() === 0)
@@ -461,6 +459,26 @@ class ThinConnectionImpl extends ConnectionImpl {
     return (this._pool) ? true : false;
   }
 
+  //---------------------------------------------------------------------------
+  // getConnectionCookieByUUID()
+  //
+  // It fetches from map which keeps keyname as UUID+ServiceName.
+  // UUID identifies the CDB instance and ServiceName identifies the
+  // entity within a PDB which uniquely identifies a pdb instance.
+  //---------------------------------------------------------------------------
+  getConnectionCookieByUUID(uuid) {
+    let cookie;
+    if (uuid) {
+      const key = uuid + ((this.serviceName) ? this.serviceName : this.sid);
+      cookie = connectionCookies.get(key);
+      if (!cookie) {
+        cookie = {};
+        connectionCookies.set(key, cookie);
+      }
+    }
+    return cookie;
+  }
+
   /**
    *
    * @param {object} params  Configuration of the connection
@@ -499,22 +517,32 @@ class ThinConnectionImpl extends ConnectionImpl {
     this._clientInfoModified = false;
     this._module = "";
     this._moduleModified = false;
+    this._drcpEnabled = false;
     this.serviceName = '';
     this.remoteAddress = '';
-    this.privilege = params.privilege;
     this.comboKey = null; // used in changePassword API
 
     this.nscon = new nsi();
     finalizationRegistry.register(this, this.nscon);
     await this.nscon.connect(params);
 
-    this._connInfo = (this.isPooled()) ? params._connInfo.map((x) => x) :
-      await getConnectionInfo(params);
-    this._drcpEnabled = String(this._connInfo[0]).toLowerCase() === 'pooled';
-    this.serviceName = this._connInfo[2];
-    this.purity = this._connInfo[3] | constants.PURITY_DEFAULT;
+    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.connClass = params.connectionClass;
+    this.connectionClass = params.connectionClass;
 
     /*
      * if drcp is used, use purity = NEW as the default purity for
@@ -538,13 +566,41 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     try {
-      let message = new messages.ProtocolMessage(this);
-      await this._protocol._processMessage(message);
-      message = new messages.DataTypeMessage(this);
-      await this._protocol._processMessage(message);
-      message = new messages.AuthMessage(this, params);
-      await this._protocol._processMessage(message);        // OSESSKEY
-      await this._protocol._processMessage(message);        // OAUTH
+      const cookie = this.getConnectionCookieByUUID(this.nscon.dbUUID);
+      this.nscon.dbUUID = null;
+      const protocolMessage = new messages.ProtocolMessage(this);
+      const dataTypeMessage = new messages.DataTypeMessage(this);
+      const authMessage = new messages.AuthMessage(this, params);
+      let sentCookie = false;
+      if (cookie && cookie.populated) {
+        const cookieMessage = new messages.ConnectionCookieMessage(this);
+        cookieMessage.cookie = cookie;
+        cookieMessage.protocolMessage = protocolMessage;
+        cookieMessage.dataTypeMessage = dataTypeMessage;
+        cookieMessage.authMessage = authMessage;
+        await this._protocol._processMessage(cookieMessage);
+        sentCookie = true;
+      } else {
+        await this._protocol._processMessage(protocolMessage);
+      }
+      if (!sentCookie || !cookie.populated) {
+        await this._protocol._processMessage(dataTypeMessage);
+        // Does OSESSKEY for non-token Authentication else OAUTH
+        await this._protocol._processMessage(authMessage);
+        if (cookie && !cookie.populated) {
+          cookie.protocolVersion = protocolMessage.serverVersion;
+          cookie.serverBanner = protocolMessage.serverBanner;
+          cookie.charsetID = this._protocol.caps.charSetID;
+          cookie.ncharsetID = this._protocol.caps.nCharsetId;
+          cookie.flags = protocolMessage.serverFlags;
+          cookie.compileCaps = Buffer.from(protocolMessage.serverCompileCaps);
+          cookie.runtimeCaps = Buffer.from(protocolMessage.serverRunTimeCaps);
+          cookie.populated = true;
+        }
+      }
+      if (!params.token) { // non-token Authentication
+        await this._protocol._processMessage(authMessage); // OAUTH
+      }
     } catch (err) {
       this.nscon.disconnect();
       throw err;
@@ -614,7 +670,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   // option is true
   //---------------------------------------------------------------------------
   _prepare(sql, options) {
-    let statement = this._getStatement(sql, options.keepInStmtCache);
+    const statement = this._getStatement(sql, options.keepInStmtCache);
     statement.bufferRowIndex = 0;
     statement.bufferRowCount = 0;
     statement.lastRowIndex = 0;
@@ -626,8 +682,8 @@ class ThinConnectionImpl extends ConnectionImpl {
   // Binds the values by user to the statement object
   //---------------------------------------------------------------------------
   async _bind(stmt, variable, pos = 0) {
-    let bindInfoDict = stmt.bindInfoDict;
-    let bindInfoList = stmt.bindInfoList;
+    const bindInfoDict = stmt.bindInfoDict;
+    const bindInfoList = stmt.bindInfoList;
 
     /*
      * For PL/SQL blocks, if the size of a string or bytes object exceeds
@@ -650,8 +706,8 @@ class ThinConnectionImpl extends ConnectionImpl {
         if (val === null) {
           return null;
         }
-        let data = await val.getData();
-        let len = val._length;
+        const data = await val.getData();
+        const len = val._length;
         if (data && len > maxSize) {
           errors.throwErr(errors.ERR_INSUFFICIENT_BUFFER_FOR_BINDS);
         }
@@ -662,7 +718,7 @@ class ThinConnectionImpl extends ConnectionImpl {
     if (variable.type === types.DB_TYPE_CLOB ||
         variable.type === types.DB_TYPE_NCLOB ||
         variable.type === types.DB_TYPE_BLOB) {
-      for (let [index, val] of variable.values.entries()) {
+      for (const [index, val] of variable.values.entries()) {
         if (!(val instanceof ThinLobImpl)) {
           if (val && val.length > 0) {
             const lobImpl = new ThinLobImpl();
@@ -693,7 +749,7 @@ class ThinConnectionImpl extends ConnectionImpl {
         stmt._setVariable(bindInfo, variable);
       });
     } else {
-      let bindInfo = bindInfoList[pos - 1];
+      const bindInfo = bindInfoList[pos - 1];
       stmt._setVariable(bindInfo, variable);
     }
   }
@@ -739,7 +795,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   // Clears the statement cache for the connection
   //---------------------------------------------------------------------------
-  resetStatmentCache() {
+  resetStatementCache() {
     this.statementCache.clear();
     this._cursorsToClose.clear();
   }
@@ -761,9 +817,9 @@ class ThinConnectionImpl extends ConnectionImpl {
   // information for a statment.
   //---------------------------------------------------------------------------
   async getStatementInfo(sql) {
-    let options = {};
-    let result = {};
-    let statement = await this._prepareAndBind(sql, null, options, true);
+    const options = {};
+    const result = {};
+    const statement = await this._prepareAndBind(sql, null, options, true);
     options.connection = this;
     // parse the statement (but not for DDL which doesn't support it)
     if (!statement.isDdl) {
@@ -1038,6 +1094,12 @@ class ThinConnectionImpl extends ConnectionImpl {
     return '';
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database instance name associated with the connection.
+  //---------------------------------------------------------------------------
+  getInstanceName() {
+    return this.instanceName;
+  }
 }
 
 module.exports = ThinConnectionImpl;

package/lib/thin/dbObject.js

@@ -362,10 +362,10 @@ class ThinDbObjectImpl extends DbObjectImpl {
         return buf.readBinaryInteger();
       case types.DB_TYPE_VARCHAR:
       case types.DB_TYPE_CHAR:
-        return buf.readStr(constants.TNS_CS_IMPLICIT);
+        return buf.readStr(constants.CSFRM_IMPLICIT);
       case types.DB_TYPE_NVARCHAR:
       case types.DB_TYPE_NCHAR:
-        return buf.readStr(constants.TNS_CS_NCHAR);
+        return buf.readStr(constants.CSFRM_NCHAR);
       case types.DB_TYPE_RAW:
         return Buffer.from(buf.readBytesWithLength());
       case types.DB_TYPE_BINARY_DOUBLE:

package/lib/thin/lob.js

@@ -121,10 +121,10 @@ class ThinLobImpl extends LobImpl {
   }
 
   getCsfrm() {
-    if (this.dbType._csfrm !== constants.TNS_CS_NCHAR) {
+    if (this.dbType._csfrm !== constants.CSFRM_NCHAR) {
       if (this._locator[constants.TNS_LOB_LOC_OFFSET_FLAG_3] &
           constants.TNS_LOB_LOC_FLAGS_VAR_LENGTH_CHARSET) {
-        return constants.TNS_CS_NCHAR;
+        return constants.CSFRM_NCHAR;
       }
     }
     return this.dbType._csfrm;

package/lib/thin/pool.js

@@ -36,6 +36,7 @@ const thinUtil = require('./util.js');
 const {getConnectionInfo} = require('./sqlnet/networkSession.js');
 const crypto = require('crypto');
 const EventEmitter = require('events');
+const Timers = require('timers');
 
 class ThinPoolImpl extends PoolImpl {
 
@@ -69,30 +70,33 @@ class ThinPoolImpl extends PoolImpl {
     this._privateKey = params.privateKey;
     this._obfuscatedPrivateKey = [];
     this._schedulerJob = null;
+    this._poolCloseWaiter = null;
+    this._pendingRequests = [];
+
     // password obfuscation
     if (this._password !== undefined) {
-      let obj = protocolUtil.setObfuscatedValue(this._password);
+      const obj = protocolUtil.setObfuscatedValue(this._password);
       this._password = obj.value;
       this._obfuscatedPassword = obj.obfuscatedValue;
       this._userConfig.password = null;
     }
     // wallet password obfuscation
     if (this._walletPassword !== undefined) {
-      let obj = protocolUtil.setObfuscatedValue(this._walletPassword);
+      const obj = protocolUtil.setObfuscatedValue(this._walletPassword);
       this._walletPassword = obj.value;
       this._obfuscatedWalletPassword = obj.obfuscatedValue;
       this._userConfig.walletPassword = null;
     }
     // token obfuscation
     if (this._token !== undefined) {
-      let obj = protocolUtil.setObfuscatedValue(this._token);
+      const obj = protocolUtil.setObfuscatedValue(this._token);
       this._token = obj.value;
       this._obfuscatedToken = obj.obfuscatedValue;
       this._userConfig.token = null;
     }
     // privateKey obfuscation
     if (this._privateKey !== undefined) {
-      let obj = protocolUtil.setObfuscatedValue(this._privateKey);
+      const obj = protocolUtil.setObfuscatedValue(this._privateKey);
       this._privateKey = obj.value;
       this._obfuscatedPrivateKey = obj.obfuscatedValue;
       this._userConfig.privateKey = null;
@@ -121,8 +125,9 @@ class ThinPoolImpl extends PoolImpl {
       this._generateConnectionClass();
     }
 
-    // create minimum connections
-    await this._growPool(this._poolMin);
+    // create a background task. It will create minimum connections in the pool
+    // and expand the pool as required.
+    this.bgThreadFunc();
   }
 
   //---------------------------------------------------------------------------
@@ -131,13 +136,13 @@ class ThinPoolImpl extends PoolImpl {
   setAccessToken(params) {
     if (params.token) {
       this._token = params.token;
-      let objToken = protocolUtil.setObfuscatedValue(this._token);
+      const objToken = protocolUtil.setObfuscatedValue(this._token);
       this._token = objToken.value;
       this._obfuscatedToken = objToken.obfuscatedValue;
     }
     if (params.privateKey) {
       this._privateKey = params.privateKey;
-      let objKey = protocolUtil.setObfuscatedValue(this._privateKey);
+      const objKey = protocolUtil.setObfuscatedValue(this._privateKey);
       this._privateKey = objKey.value;
       this._obfuscatedPrivateKey = objKey.obfuscatedValue;
     }
@@ -151,15 +156,21 @@ class ThinPoolImpl extends PoolImpl {
   async _getConnAttrs() {
     let accessToken;
     const clonedAttrs = Object.assign({}, this._userConfig);
+    // deobfuscate password
     if (clonedAttrs.password === null) {
       clonedAttrs.password = protocolUtil.getDeobfuscatedValue(this._password,
         this._obfuscatedPassword);
     }
+
+    // deobfuscate wallet password
     if (clonedAttrs.walletPassword === null) {
       clonedAttrs.walletPassword =
         protocolUtil.getDeobfuscatedValue(this._walletPassword,
           this._obfuscatedWalletPassword);
     }
+
+    // deobfuscate token and private key
+    // check for token expiry
     if (clonedAttrs.token === null) {
       clonedAttrs.token =
         protocolUtil.getDeobfuscatedValue(this._token, this._obfuscatedToken);
@@ -173,7 +184,7 @@ class ThinPoolImpl extends PoolImpl {
               errors.throwErr(errors.ERR_TOKEN_HAS_EXPIRED);
             } else {
               // update pool with OAuth2 token
-              let obj = protocolUtil.setObfuscatedValue(clonedAttrs.token);
+              const obj = protocolUtil.setObfuscatedValue(clonedAttrs.token);
               this._token = obj.value;
               this._obfuscatedToken = obj.obfuscatedValue;
             }
@@ -185,11 +196,11 @@ class ThinPoolImpl extends PoolImpl {
               errors.throwErr(errors.ERR_TOKEN_HAS_EXPIRED);
             } else {
               // update pool with IAM token and private key
-              let objToken = protocolUtil.setObfuscatedValue(clonedAttrs.token);
+              const objToken = protocolUtil.setObfuscatedValue(clonedAttrs.token);
               this._token = objToken.value;
               this._obfuscatedToken = objToken.obfuscatedValue;
 
-              let objKey = protocolUtil.setObfuscatedValue(clonedAttrs.privateKey);
+              const objKey = protocolUtil.setObfuscatedValue(clonedAttrs.privateKey);
               this._privateKey = objKey.value;
               this._obfuscatedPrivateKey = objKey.obfuscatedValue;
             }
@@ -212,9 +223,6 @@ class ThinPoolImpl extends PoolImpl {
   // create new connection and return it
   //---------------------------------------------------------------------------
   async getConnection() {
-    if (settings.connectionClass !== '') {
-      this._userConfig.connectionClass = settings.connectionClass;
-    }
     return await this.acquire();
   }
 
@@ -231,13 +239,34 @@ class ThinPoolImpl extends PoolImpl {
   //---------------------------------------------------------------------------
   // close pool by destroying available connections
   //---------------------------------------------------------------------------
-  async close(obj) {
+  async close() {
+
+    // wait till background task for pool expansion is finished; if it is not
+    // currently running, wake it up!
+    await new Promise((resolve) => {
+      this._poolCloseWaiter = resolve;
+      if (this.bgWaiter) {
+        this.bgWaiter();
+      }
+    });
+
     // clear scheduled job
     if (this._schedulerJob) {
       clearTimeout(this._schedulerJob);
       this._schedulerJob = null;
     }
-    return await this.destroyAllNow(obj);
+
+    // destroy all free connections
+    for (const conn of this._freeConnectionList) {
+      await this._destroy(conn);
+    }
+
+    // destroy all used connections
+    for (const conn of this._usedConnectionList) {
+      await this._destroy(conn);
+    }
+
+    this.eventEmitter.removeAllListeners();
   }
 
   //---------------------------------------------------------------------------
@@ -310,25 +339,6 @@ class ThinPoolImpl extends PoolImpl {
     return this._stmtCacheSize;
   }
 
-  //---------------------------------------------------------------------------
-  // _growPool()
-  //
-  // Grows the pool to include the specified number of connections.
-  //---------------------------------------------------------------------------
-  async _growPool(numConns) {
-    const clonedAttrs = await this._getConnAttrs();
-    while (numConns > 0) {
-      const conn = new ThinConnectionImpl();
-      conn._pool = this;
-      await conn.connect(clonedAttrs);
-      conn._newSession = true;
-      conn._dropSess = false;
-      conn._lastTimeUsed = Date.now();
-      this._freeConnectionList.push(conn);
-      numConns--;
-    }
-  }
-
   //---------------------------------------------------------------------------
   // _setScheduler()
   //
@@ -366,6 +376,94 @@ class ThinPoolImpl extends PoolImpl {
     this._setScheduler();
   }
 
+  //---------------------------------------------------------------------------
+  // _getNumConns()
+  //
+  // get number of connections need to be created
+  //---------------------------------------------------------------------------
+  _getNumConns() {
+    const usedConns = this._freeConnectionList.length + this._usedConnectionList.size;
+    // less connections in the pool than poolMin? restore to poolMin
+    if (usedConns < this._poolMin) {
+      return this._poolMin - usedConns;
+    // connections need to be created? create up to poolIncrement without exceeding poolMax
+    } else if (this._pendingRequests.length > 0) {
+      return Math.min(this._poolIncrement, this._poolMax - usedConns);
+    // no pending requests and we are already at poolMin so nothing to do!
+    } else {
+      return 0;
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // bgThreadFunc()
+  //
+  // method which runs in a background thread and is used to create connections.
+  // When first started, it creates poolMin connections. After that, it creates
+  // poolIncrement connections up to the value of poolMax when needed.
+  // The thread terminates automatically when the pool is closed.
+  //---------------------------------------------------------------------------
+  async bgThreadFunc() {
+
+    // continue until a close request is received
+    while (!this._poolCloseWaiter) {
+      // get count for connections to be created
+      const numConns = this._getNumConns();
+
+      // connection creation is going on serially and not concurrently
+      for (let i = 0; i < numConns; i++) {
+        try {
+          // get deobfuscated value
+          const config = await this._getConnAttrs();
+          const conn = new ThinConnectionImpl();
+          conn._pool = this;
+          await conn.connect(config);
+          conn._newSession = true;
+          conn._dropSess = false;
+          conn._lastTimeUsed = Date.now();
+          this._freeConnectionList.push(conn);
+        } catch (err) {
+          this._bgErr = err;
+        }
+
+        if (this._poolIncrement > 1 && (this._poolMax - this._usedConnectionList.size
+            - this._freeConnectionList.length) > 1) {
+          this._setScheduler();
+        }
+
+        // resolve pending request
+        if (this._pendingRequests.length > 0) {
+          const payload = this._pendingRequests.shift();
+          payload.resolve();
+        }
+
+        // give an opportunity for other "threads" to do their work.
+        await new Promise((resolve) => Timers.setImmediate(resolve));
+
+        // break loop when pool is closing
+        if (this._poolCloseWaiter) {
+          break;
+        }
+      }
+
+      // when pool is closing, break from while loop
+      if (this._poolCloseWaiter) {
+        break;
+      }
+
+      // if no pending requests, wait for pending requests to appear!
+      if (this._pendingRequests.length == 0 || this._bgErr) {
+        await new Promise((resolve) => {
+          this.bgWaiter = resolve;
+        });
+        this.bgWaiter = null;
+      }
+    }
+
+    // notify the closer that the close can actually take place
+    this._poolCloseWaiter();
+  }
+
   //---------------------------------------------------------------------------
   // acquire()
   //
@@ -413,17 +511,28 @@ class ThinPoolImpl extends PoolImpl {
 
     // no free connections exist at this point; if less than poolMin
     // connections exist, grow the pool to poolMin again; otherwise, increase
-    // the pool by poolIncrement up to poolMax
-    if (this._usedConnectionList.size < this._poolMin) {
-      await this._growPool(this._poolMin - this._usedConnectionList.size);
-    } else {
-      const sizeAvailable = this._poolMax - this._usedConnectionList.size;
-      await this._growPool(Math.min(this._poolIncrement, sizeAvailable));
-      if (this._poolIncrement > 1 && sizeAvailable > 1) {
-        this._setScheduler();
+    // the pool by poolIncrement up to poolMax. We are deferring this
+    // to the background thread function!
+    await new Promise((resolve) => {
+      this._pendingRequests.push({resolve: resolve});
+      if (this.bgWaiter) {
+        // this wakes up the function to do some more work
+        this.bgWaiter();
       }
-    }
+    });
+
+    if (this._bgErr) {
+      const err = this._bgErr;
+      this._bgErr = null;
 
+      // if an error has occurred in the background thread we clear it and then,
+      // if there are more pending requests we request the background thread
+      // function to try again.
+      if (this._pendingRequests.length > 0 && this.bgWaiter) {
+        this.bgWaiter();
+      }
+      throw err;
+    }
     // return a connection from the ones that were just built
     const conn = this._freeConnectionList.pop();
     this._usedConnectionList.add(conn);
@@ -441,33 +550,6 @@ class ThinPoolImpl extends PoolImpl {
     this._setScheduler();
   }
 
-  //---------------------------------------------------------------------------
-  // destroyAllNow()
-  //
-  // called during pool close operation and close any available connection
-  // available in connection pool
-  //---------------------------------------------------------------------------
-  async destroyAllNow(obj) {
-    let conn;
-    while (this._freeConnectionList.length !== 0) {
-      conn = this._freeConnectionList.pop();
-      await this._destroy(conn);
-    }
-
-    if (obj.forceClose) {
-      for (const item of this._usedConnectionList) {
-        await this._destroy(item);
-        this._usedConnectionList.delete(item);
-      }
-    }
-
-    if (this._usedConnectionList.size !== 0) {
-      errors.throwErr(errors.ERR_POOL_HAS_BUSY_CONNECTIONS);
-    }
-
-    this.eventEmitter.removeAllListeners();
-  }
-
   //---------------------------------------------------------------------------
   // _generateConnectionClass()
   //

package/lib/thin/protocol/buffer.js

@@ -92,13 +92,13 @@ class BaseBuffer {
       return 0;
     } else if (size & 0x80) {
       if (!signed) {
-        errors.throwErr(errors.ERR_UNEXPECTED_NEGATIVE_INTEGER);
+        errors.throwErr(errors.ERR_UNEXPECTED_NEGATIVE_INTEGER, this.pos, this.packetNum);
       }
       isNegative = true;
       size = size & 0x7f;
     }
     if (size > maxSize) {
-      errors.throwErr(errors.ERR_INTEGER_TOO_LARGE, size, maxSize);
+      errors.throwErr(errors.ERR_INTEGER_TOO_LARGE, size, maxSize, this.pos, this.packetNum);
     }
     if (skip) {
       this.skipBytes(size);
@@ -465,7 +465,7 @@ class BaseBuffer {
     if (!buf) {
       return null;
     }
-    if (csfrm === constants.TNS_CS_IMPLICIT)
+    if (csfrm === constants.CSFRM_IMPLICIT)
       return buf.toString();
 
     // need a copy of the buffer since swap16() changes the buffer in place and
@@ -748,7 +748,7 @@ class BaseBuffer {
     const ptr = this.reserveBytes(length);
     if (type === types.DB_TYPE_DATE || type == types.DB_TYPE_TIMESTAMP) {
       const year = date.getFullYear();
-      ptr[0] = Math.floor(year / 100) + 100;
+      ptr[0] = Math.trunc(year / 100) + 100;
       ptr[1] = year % 100 + 100;
       ptr[2] = date.getMonth() + 1;
       ptr[3] = date.getDate();
@@ -757,7 +757,7 @@ class BaseBuffer {
       ptr[6] = date.getSeconds() + 1;
     } else {
       const year = date.getUTCFullYear();
-      ptr[0] = Math.floor(year / 100) + 100;
+      ptr[0] = Math.trunc(year / 100) + 100;
       ptr[1] = year % 100 + 100;
       ptr[2] = date.getUTCMonth() + 1;
       ptr[3] = date.getUTCDate();
@@ -847,7 +847,7 @@ class BaseBuffer {
     buf[0] = numPairs + 1 + appendSentinel;
     buf[1] = exponentOnWire;
     for (let i = 0, pos = 2; i < value.length; i += 2, pos++) {
-      let base100Digit = Number(value.substring(i, i + 2));
+      const base100Digit = Number(value.substring(i, i + 2));
       if (isNegative) {
         buf[pos] = 101 - base100Digit;
       } else {
@@ -923,6 +923,24 @@ class BaseBuffer {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // writeUB2()
+  //
+  // Writes an unsigned integer (up to 2 bytes in length) in variable length
+  // format to the buffer.
+  //---------------------------------------------------------------------------
+  writeUB2(value) {
+    if (value === 0) {
+      this.writeUInt8(0);
+    } else if (value <= 0xff) {
+      this.writeUInt8(1);
+      this.writeUInt8(value);
+    } else {
+      this.writeUInt8(2);
+      this.writeUInt16BE(value);
+    }
+  }
+
   //---------------------------------------------------------------------------
   // writeUB8()
   //