oracledb 6.0.3 → 6.2.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 {
 
   /**
@@ -57,23 +59,29 @@ class ThinConnectionImpl extends ConnectionImpl {
    * @return {Promise}
    */
   async close() {
-    if (this._protocol.txnInProgress) {
-      await this.rollback();
-    }
-    this._protocol.callTimeout = 0;      // not applicable for close
-    if (this._drcpEnabled) {
-      await this._sessRelease();
-      this._drcpEstablishSession = true;
-    }
+    try {
+      if (this._protocol.txnInProgress) {
+        await this.rollback();
+      }
+      this._protocol.callTimeout = 0;      // not applicable for close
+      if (this._drcpEnabled) {
+        await this._sessRelease();
+        this._drcpEstablishSession = true;
+      }
 
-    if (this._pool && !this._dropSess) {
-      await this._pool.release(this);
-    } else {
-      if (!this._drcpEnabled) {
-        const message = new messages.LogOffMessage(this);
-        await this._protocol._processMessage(message);
+      if (this._pool && !this._dropSess) {
+        await this._pool.release(this);
+      } else {
+        if (!this._drcpEnabled) {
+          const message = new messages.LogOffMessage(this);
+          await this._protocol._processMessage(message);
+        }
+        this.nscon.disconnect();
       }
-      this.nscon.disconnect();
+    } catch (err) {
+      // immediate close of open socket on failure
+      // exception won't be thrown to user
+      this.nscon.disconnect(sqlNetConstants.NSFIMM);
     }
   }
 
@@ -151,6 +159,98 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // _execute()
+  //
+  // Calls the RPC that executes a SQL statement and returns the results.
+  //---------------------------------------------------------------------------
+  async _execute(statement, numIters, binds, options, executeManyFlag) {
+
+    // perform binds
+    const numBinds = statement.bindInfoList.length;
+    const numVars = binds.length;
+    if (numBinds !== numVars && (numVars === 0 || !binds[0].name)) {
+      errors.throwErr(errors.ERR_WRONG_NUMBER_OF_POSITIONAL_BINDS, numBinds, numVars);
+    }
+    for (let i = 0; i < binds.length; i++) {
+      await this._bind(statement, binds[i], i + 1);
+    }
+    if (statement.isPlSql && (options.batchErrors || options.dmlRowCounts)) {
+      errors.throwErr(errors.ERR_EXEC_MODE_ONLY_FOR_DML);
+    }
+
+    // send database request
+    const message = new messages.ExecuteMessage(this, statement, options);
+    message.numExecs = numIters;
+    message.arrayDmlRowCounts = options.dmlRowCounts;
+    message.batchErrors = options.batchErrors;
+    if (statement.isPlSql && statement.requiresFullExecute) {
+      message.numExecs = 1;
+      await this._protocol._processMessage(message);
+      statement.requiresFullExecute = false;
+      message.numExecs = numIters - 1;
+      message.offset = 1;
+    }
+    if (message.numExecs > 0) {
+      await this._protocol._processMessage(message);
+      statement.requiresFullExecute = false;
+    }
+
+    // if a define is required, send an additional request to the database
+    if (statement.requiresDefine && statement.sql) {
+      statement.requiresFullExecute = true;
+      await this._protocol._processMessage(message);
+      statement.requiresFullExecute = false;
+      statement.requiresDefine = false;
+    }
+
+    // process results
+    const result = {};
+    if (statement.numQueryVars > 0) {
+      result.resultSet = message.resultSet;
+    } else {
+      statement.bufferRowIndex = 0;
+      const outBinds = thinUtil.getOutBinds(statement, numIters,
+        executeManyFlag);
+      if (outBinds) {
+        result.outBinds = outBinds;
+      }
+      if (executeManyFlag) {
+        if (!statement.isPlSql) {
+          result.rowsAffected = statement.rowCount;
+          delete statement.rowCount;
+        }
+        if (options.dmlRowCounts) {
+          result.dmlRowCounts = options.dmlRowCounts;
+        }
+        if (options.batchErrors) {
+          result.batchErrors = options.batchErrors;
+        }
+      } else {
+        if (statement.isPlSql && options.implicitResultSet) {
+          result.implicitResults = options.implicitResultSet;
+        }
+        if (statement.lastRowid) {
+          result.lastRowid = statement.lastRowid;
+          delete statement.lastRowid;
+        }
+        if (statement.isPlSql) {
+          if (statement.rowCount) {
+            result.rowsAffected = statement.rowCount;
+          }
+        } else {
+          result.rowsAffected = statement.rowCount || 0;
+        }
+        if (statement.rowCount) {
+          delete statement.rowCount;
+        }
+      }
+      this._returnStatement(statement);
+    }
+
+    return result;
+  }
+
   //---------------------------------------------------------------------------
   // _parseElementType()
   //
@@ -443,10 +543,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     await this._protocol.breakMessage();
   }
 
-  _healthStatus() {
-    return this.nscon.recvInbandNotif();
-  }
-
   isHealthy() {
     try {
       if (this.nscon.recvInbandNotif() === 0)
@@ -461,6 +557,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 +615,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 +664,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 +768,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 +780,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 +804,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 +816,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 +847,7 @@ class ThinConnectionImpl extends ConnectionImpl {
         stmt._setVariable(bindInfo, variable);
       });
     } else {
-      let bindInfo = bindInfoList[pos - 1];
+      const bindInfo = bindInfoList[pos - 1];
       stmt._setVariable(bindInfo, variable);
     }
   }
@@ -716,30 +870,10 @@ class ThinConnectionImpl extends ConnectionImpl {
     return resultSet;
   }
 
-  //---------------------------------------------------------------------------
-  // Prepares the sql given by user and binds the value to the statement object
-  //---------------------------------------------------------------------------
-  async _prepareAndBind(sql, binds, options, isParse = false) {
-    const stmt = this._prepare(sql, options);
-    let position = 0;
-    if (!isParse) {
-      const numBinds = stmt.bindInfoList.length;
-      const numVars = binds.length;
-      if (numBinds !== numVars && (numVars === 0 || !binds[0].name)) {
-        errors.throwErr(errors.ERR_WRONG_NUMBER_OF_POSITIONAL_BINDS, numBinds, numVars);
-      }
-      for (const variable of binds) {
-        await this._bind(stmt, variable, position + 1);
-        position += 1;
-      }
-    }
-    return stmt;
-  }
-
   //---------------------------------------------------------------------------
   // Clears the statement cache for the connection
   //---------------------------------------------------------------------------
-  resetStatmentCache() {
+  resetStatementCache() {
     this.statementCache.clear();
     this._cursorsToClose.clear();
   }
@@ -756,139 +890,46 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   //---------------------------------------------------------------------------
-  // Parses the sql given by User
-  // calls the OAL8 RPC that parses the SQL statement and returns the metadata
-  // information for a statment.
+  // getStatementInfo()
+  //
+  // Parses the SQL statement and returns information about the statement.
   //---------------------------------------------------------------------------
   async getStatementInfo(sql) {
-    let options = {};
-    let result = {};
-    let 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) {
-      const message = new messages.ExecuteMessage(this, statement, options);
-      message.parseOnly = true;
-      await this._protocol._processMessage(message);
-    }
-    if (statement.numQueryVars > 0) {
-      result.metaData = thinUtil.getMetadataMany(statement.queryVars);
-    }
-    result.bindNames = Array.from(statement.bindInfoDict.keys());
-    result.statementType = statement.statementType;
-    return result;
-  }
-
-  //---------------------------------------------------------------------------
-  // Prepares the sql given by the user,
-  // calls the OAL8 RPC that executes a SQL statement and returns the results.
-  //---------------------------------------------------------------------------
-  async execute(sql, numIters, binds, options, executeManyFlag) {
+    const options = {};
     const result = {};
-    if (executeManyFlag) {
-      return await this.executeMany(sql, numIters, binds, options);
-    }
-    const statement = await this._prepareAndBind(sql, binds, options);
-
-    // send the initial request to the database
-    const message = new messages.ExecuteMessage(this, statement, options);
-    message.numExecs = 1;
-    await this._protocol._processMessage(message);
-    statement.requiresFullExecute = false;
-
-    // if a define is required, send an additional request to the database
-    if (statement.requiresDefine && statement.sql) {
-      statement.requiresFullExecute = true;
-      await this._protocol._processMessage(message);
-      statement.requiresFullExecute = false;
-      statement.requiresDefine = false;
-    }
-
-    // process message results
-    if (statement.numQueryVars > 0) {
-      result.resultSet = message.resultSet;
-    } else {
-      statement.bufferRowIndex = 0;
-      const bindVars = thinUtil.getBindVars(statement);
-      const outBinds = thinUtil.getExecuteOutBinds(bindVars);
-      if (outBinds) {
-        result.outBinds = outBinds;
-      }
-      if (statement.isPlSql) {
-        if (options.implicitResultSet) {
-          result.implicitResults = options.implicitResultSet;
-        }
-      }
-      if (statement.lastRowid) {
-        result.lastRowid = statement.lastRowid;
-        delete statement.lastRowid;
-      }
-      if (statement.isPlSql) {
-        if (statement.rowCount) {
-          result.rowsAffected = statement.rowCount;
-        }
-      } else {
-        result.rowsAffected = statement.rowCount || 0;
+    const statement = this._prepare(sql, options);
+    options.connection = this;
+    try {
+      if (!statement.isDdl) {
+        const message = new messages.ExecuteMessage(this, statement, options);
+        message.parseOnly = true;
+        await this._protocol._processMessage(message);
       }
-      if (statement.rowCount) {
-        delete statement.rowCount;
+      if (statement.numQueryVars > 0) {
+        result.metaData = thinUtil.getMetadataMany(statement.queryVars);
       }
+      result.bindNames = Array.from(statement.bindInfoDict.keys());
+      result.statementType = statement.statementType;
+      return result;
+    } finally {
       this._returnStatement(statement);
     }
-
-    return result;
   }
 
   //---------------------------------------------------------------------------
-  // executeMany()
+  // execute()
   //
-  // Prepares the sql given by the user, calls the OAL8 RPC that executes a SQL
-  // statement multiple times and returns the results.
+  // Calls the RPC that executes a SQL statement and returns the results.
   //---------------------------------------------------------------------------
-  async executeMany(sql, numIters, binds, options) {
-    const statement = await this._prepareAndBind(sql, binds, options);
-    if (statement.isPlSql && (options.batchErrors || options.dmlRowCounts)) {
-      errors.throwErr(errors.ERR_EXEC_MODE_ONLY_FOR_DML);
-    }
-
-    // send database request
-    const message = new messages.ExecuteMessage(this, statement, options);
-    message.numExecs = numIters;
-    message.arrayDmlRowCounts = options.dmlRowCounts;
-    message.batchErrors = options.batchErrors;
-    if (statement.isPlSql && statement.requiresFullExecute) {
-      message.numExecs = 1;
-      await this._protocol._processMessage(message);
-      statement.requiresFullExecute = false;
-      message.numExecs = numIters - 1;
-      message.offset = 1;
-    }
-    if (message.numExecs > 0) {
-      await this._protocol._processMessage(message);
-    }
-
-    // process results
-    const returnObj = {};
-    statement.bufferRowIndex = 0;
-    const bindVars = thinUtil.getBindVars(statement);
-    const outBinds = thinUtil.getExecuteManyOutBinds(bindVars, numIters);
-    if (outBinds) {
-      returnObj.outBinds = outBinds;
-    }
-    const rowsAffected = !statement.isPlSql ? statement.rowCount : undefined;
-    if (rowsAffected) {
-      returnObj.rowsAffected = rowsAffected;
-      delete statement.rowCount;
-    }
-    if (options.dmlRowCounts) {
-      returnObj.dmlRowCounts = options.dmlRowCounts;
-    }
-    if (options.batchErrors) {
-      returnObj.batchErrors = options.batchErrors;
+  async execute(sql, numIters, binds, options, executeManyFlag) {
+    const statement = this._prepare(sql, options);
+    try {
+      return await this._execute(statement, numIters, binds, options,
+        executeManyFlag);
+    } catch (err) {
+      this._returnStatement(statement);
+      throw err;
     }
-    this._returnStatement(statement);
-
-    return returnObj;
   }
 
   //---------------------------------------------------------------------------
@@ -1038,6 +1079,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

@@ -367,7 +367,10 @@ class ThinDbObjectImpl extends DbObjectImpl {
       case types.DB_TYPE_NCHAR:
         return buf.readStr(constants.CSFRM_NCHAR);
       case types.DB_TYPE_RAW:
-        return Buffer.from(buf.readBytesWithLength());
+        value = buf.readBytesWithLength();
+        if (value !== null)
+          value = Buffer.from(value);
+        return value;
       case types.DB_TYPE_BINARY_DOUBLE:
         return buf.readBinaryDouble();
       case types.DB_TYPE_BINARY_FLOAT: