oracledb 6.6.0 → 6.7.1

package/lib/thin/connection.js

@@ -169,12 +169,27 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   async _execute(statement, numIters, binds, options, executeManyFlag) {
 
+    // Throw error if executeMany is not called on a DML statement or PL/SQL
+    if (executeManyFlag && statement.isQuery) {
+      errors.throwErr(errors.ERR_EXECMANY_NOT_ALLOWED_ON_QUERIES);
+    }
     // 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);
+    const numStmtBinds = statement.bindInfoList.length;
+    const numUserBinds = binds.length;
+    if (numStmtBinds !== numUserBinds) {
+      if (!binds[0]?.name) {
+        // positional bind mismatch or zero binds
+        errors.throwErr(errors.ERR_WRONG_NUMBER_OF_BINDS, numStmtBinds, numUserBinds);
+      }
+
+      // named bind mismatch
+      // Find the number of distinct named bind placeholders and see
+      // if they match the bind values
+      const numDistinctStmtBinds = statement.bindInfoDict.size;
+      if (numDistinctStmtBinds !== numUserBinds)
+        errors.throwErr(errors.ERR_WRONG_NUMBER_OF_BINDS, numStmtBinds, numUserBinds);
     }
+
     for (let i = 0; i < binds.length; i++) {
       await this._bind(statement, binds[i], i + 1);
     }
@@ -404,6 +419,79 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // _populateRowTypeInfo()
+  //
+  // Get column and datatype information in case of %ROWTYPE handling.
+  //---------------------------------------------------------------------------
+  async _populateRowTypeInfo(info, options, result) {
+    const getColumnsSQL = `
+      SELECT
+        column_name,
+        data_type,
+        data_type_owner,
+        case
+          when data_type in
+            ('CHAR', 'NCHAR', 'VARCHAR2', 'NVARCHAR2', 'RAW')
+          then data_length
+          else 0
+        end,
+        nvl(data_precision, 0),
+        nvl(data_scale, 0)
+      from all_tab_cols
+      where owner = :owner
+        and table_name = :name
+        and hidden_column != 'YES'
+      order by column_id`;
+
+    const bindVal = [
+      {
+        name: "owner",
+        type: types.DB_TYPE_VARCHAR,
+        maxSize: 128,
+        dir: constants.BIND_IN,
+        values: [result.outBinds.schema],
+      },
+      {
+        name: "name",
+        type: types.DB_TYPE_VARCHAR,
+        maxSize: 128,
+        dir: constants.BIND_IN,
+        values: [info.name.substring(0, info.name.length - 8)]
+      }
+    ];
+    const val = await this.execute(
+      getColumnsSQL, 1, bindVal, options, false
+    );
+    try {
+      const attrRows = await val.resultSet._getAllRows();
+      info.attributes = [];
+      for (const row of attrRows) {
+        const metaData = {
+          name: row[0],
+          dataType: row[1],
+          dataTypeOwner: row[2],
+          maxSize: row[3],
+          dataPrecision: row[4],
+          dataScale: row[5],
+        };
+        if (!metaData.dataTypeOwner) {
+          const startPos = row[1].indexOf('(');
+          const endPos = row[1].indexOf(')');
+          if (endPos > startPos) {
+            metaData.dataType = metaData.dataType.substring(0, startPos) +
+              metaData.dataType.substring(
+                endPos + 1, metaData.dataType.length
+              );
+          }
+        }
+        this._addAttr(info.attributes, metaData);
+      }
+    } finally {
+      val.resultSet.close();
+    }
+  }
+
   //---------------------------------------------------------------------------
   // _populateDbObjectTypeInfo()
   //
@@ -449,26 +537,6 @@ class ThinConnectionImpl extends ConnectionImpl {
           end if;
       end;`;
 
-    // get column and datatype information in case of %ROWTYPE handling.
-    const getColumnsSQL = `
-      SELECT
-        column_name,
-        data_type,
-        data_type_owner,
-        case
-          when data_type in
-            ('CHAR', 'NCHAR', 'VARCHAR2', 'NVARCHAR2', 'RAW')
-          then data_length
-          else 0
-        end,
-        nvl(data_precision, 0),
-        nvl(data_scale, 0)
-      from all_tab_cols
-      where owner = :owner
-        and table_name = :name
-        and hidden_column != 'YES'
-      order by column_id`;
-
     const binds = [
       {
         name: "full_name",
@@ -540,78 +608,42 @@ class ThinConnectionImpl extends ConnectionImpl {
       errors.throwErr(errors.ERR_INVALID_OBJECT_TYPE_NAME, name);
     }
 
-    // check cache; if already present, nothing more to do!
-    const info = this._getDbObjectType(result.outBinds.schema,
-      result.outBinds.name, result.outBinds.package_name, result.outBinds.oid);
-    if (!info.partial)
-      return info;
-
-    // process TDS and attributes cursor
-    if (info.name.endsWith('%ROWTYPE')) {
-      const bindVal = [
-        {
-          name: "owner",
-          type: types.DB_TYPE_VARCHAR,
-          maxSize: 128,
-          dir: constants.BIND_IN,
-          values: [result.outBinds.schema],
-        },
-        {
-          name: "name",
-          type: types.DB_TYPE_VARCHAR,
-          maxSize: 128,
-          dir: constants.BIND_IN,
-          values: [info.name.substring(0, info.name.length - 8)]
-        }
-      ];
-      const val = await this.execute(
-        getColumnsSQL, 1, bindVal, options, false
-      );
-      const attrRows = await val.resultSet._getAllRows();
-      info.attributes = [];
-      for (const row of attrRows) {
-        const metaData = {
-          name: row[0],
-          dataType: row[1],
-          dataTypeOwner: row[2],
-          maxSize: row[3],
-          dataPrecision: row[4],
-          dataScale: row[5],
-        };
-        if (!metaData.dataTypeOwner) {
-          const startPos = row[1].indexOf('(');
-          const endPos = row[1].indexOf(')');
-          if (endPos > startPos) {
-            metaData.dataType = metaData.dataType.substring(0, startPos) +
-              metaData.dataType.substring(
-                endPos + 1, metaData.dataType.length
-              );
-          }
-        }
-        this._addAttr(info.attributes, metaData);
+    try {
+      // check cache; if already present, nothing more to do!
+      const info = this._getDbObjectType(result.outBinds.schema,
+        result.outBinds.name, result.outBinds.package_name, result.outBinds.oid);
+      if (!info.partial) {
+        return info;
       }
-    } else {
-      info.version = result.outBinds.version;
-      const attrRows = await result.outBinds.attrs_rc._getAllRows();
-      if (attrRows.length > 0) {
+
+      // process TDS and attributes cursor
+      if (info.name.endsWith('%ROWTYPE')) {
+        await this._populateRowTypeInfo(info, options, result);
+      } else {
+        info.version = result.outBinds.version;
+        const attrRows = await result.outBinds.attrs_rc._getAllRows();
+        if (attrRows.length > 0) {
         // Its an object not a collection.
-        info.attributes = [];
-        for (const row of attrRows) {
-          const metaData = {
-            name: row[1],
-            dataType: row[3],
-            dataTypeOwner: row[4],
-            packageName: row[5],
-            oid: row[6]
-          };
-          this._addAttr(info.attributes, metaData);
-        }
+          info.attributes = [];
+          for (const row of attrRows) {
+            const metaData = {
+              name: row[1],
+              dataType: row[3],
+              dataTypeOwner: row[4],
+              packageName: row[5],
+              oid: row[6]
+            };
+            this._addAttr(info.attributes, metaData);
+          }
 
+        }
+        await this._parseTDS(result.outBinds.tds, info);
       }
-      await this._parseTDS(result.outBinds.tds, info);
+      info.partial = false;
+      return info;
+    } finally {
+      result.outBinds.attrs_rc.close();
     }
-    info.partial = false;
-    return info;
 
   }
 
@@ -797,8 +829,14 @@ class ThinConnectionImpl extends ConnectionImpl {
           await this._protocol._processMessage(authMessage);
         }
       } else {
+        // When Fast Auth is explicitly disabled on servers > 23ai,
+        // we dont rely on message type TNS_MSG_TYPE_END_OF_REQUEST too
+        // for protocolMessage and dataTypeMessage.
+        const endOfRequestSupport = this.nscon.endOfRequestSupport;
+        this.nscon.endOfRequestSupport = false;
         await this._protocol._processMessage(protocolMessage);
         await this._protocol._processMessage(dataTypeMessage);
+        this.nscon.endOfRequestSupport = endOfRequestSupport;
         await this._protocol._processMessage(authMessage);
       }
       if (!params.token) { // non-token Authentication
@@ -1239,6 +1277,27 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.dbDomain;
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database host name associated with the connection.
+  //---------------------------------------------------------------------------
+  getHostName() {
+    return this.nscon.ntAdapter.hostName;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database port number associated with the connection.
+  //---------------------------------------------------------------------------
+  getPort() {
+    return this.nscon.ntAdapter.port;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the protocol associated with the connection.
+  //---------------------------------------------------------------------------
+  getProtocol() {
+    return (this.nscon.ntAdapter.secure) ? 'TCPS' : 'TCP';
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database name associated with the connection.
   //---------------------------------------------------------------------------

package/lib/thin/dbObject.js

@@ -179,7 +179,8 @@ class ThinDbObjectImpl extends DbObjectImpl {
   //---------------------------------------------------------------------------
   _ensureAssocKeys() {
     if (!this.unpackedAssocKeys) {
-      this.unpackedAssocKeys = [...this.unpackedAssocArray.keys()].sort();
+      // Associative arrays indexed by integer are only supported now
+      this.unpackedAssocKeys = [...this.unpackedAssocArray.keys()].sort((x, y) => x - y);
     }
   }
 
@@ -546,6 +547,9 @@ class ThinDbObjectImpl extends DbObjectImpl {
   // getNextIndex()
   //
   // Returns the next index in a collection.
+  // For associative arrays indexed by integers, if the passed-in index
+  // parameter is not present, it will return the next higher index found
+  // in the associative array.
   //---------------------------------------------------------------------------
   getNextIndex(index) {
     this._ensureUnpacked();
@@ -566,6 +570,9 @@ class ThinDbObjectImpl extends DbObjectImpl {
   // getPrevIndex()
   //
   // Returns the previous index in a collection.
+  // For associative arrays indexed by integers, if the passed-in index
+  // parameter is not present, it will return the next lower index found
+  // in the associative array.
   //---------------------------------------------------------------------------
   getPrevIndex(index) {
     this._ensureUnpacked();
@@ -575,9 +582,11 @@ class ThinDbObjectImpl extends DbObjectImpl {
       }
     } else if (this.unpackedAssocArray) {
       this._ensureAssocKeys();
-      for (const key of this.unpackedAssocKeys.reverse()) {
-        if (key < index)
-          return key;
+      let prev;
+      for (const key of this.unpackedAssocKeys) {
+        if (key >= index)
+          return prev;
+        prev = key;
       }
     }
   }

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 = [];

package/lib/thin/protocol/constants.js

@@ -48,7 +48,7 @@ module.exports = {
   PURITY_NEW: constants.PURITY_NEW,
   PURITY_SELF: constants.PURITY_SELF,
   SYSASM: constants.SYSASM,
-  SYSBKP: constants.SYSBKP,
+  SYSBKP: constants.SYSBACKUP,
   SYSDBA: constants.SYSDBA,
   SYSDG: constants.SYSDG,
   SYSKM: constants.SYSKM,

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/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/withData.js

@@ -67,7 +67,6 @@ class MessageWithData extends Message {
     if (messageType === constants.TNS_MSG_TYPE_DESCRIBE_INFO) {
       buf.skipBytesChunked();
       const prevQueryVars = this.statement.queryVars;
-      this.statement.queryVars = [];
       this.statement.numQueryVars = 0;
       this.statement.bufferRowCount = 0;
       this.statement.bufferRowIndex = 0;
@@ -512,9 +511,7 @@ class MessageWithData extends Message {
       const bvalue = buf.readUB4();
       if (bvalue > 0) { // Non Null data in column
         colValue = new ThinLobImpl();
-        if (oraTypeNum === constants.TNS_DATA_TYPE_BFILE) {
-          buf.skipUB4();
-        } else {
+        if (oraTypeNum !== constants.TNS_DATA_TYPE_BFILE) {
           length = buf.readUB8();
           chunkSize = buf.readUB4();
         }
@@ -633,7 +630,6 @@ class MessageWithData extends Message {
         if (variable.type === types.DB_TYPE_CLOB ||
             variable.type === types.DB_TYPE_NCLOB ||
             variable.type === types.DB_TYPE_BLOB ||
-            variable.type === types.DB_TYPE_BFILE ||
             variable.type === types.DB_TYPE_JSON ||
             variable.type === types.DB_TYPE_VECTOR) {
           if (variable.type !== variable.fetchInfo.fetchType) {
@@ -702,7 +698,7 @@ class MessageWithData extends Message {
       // conversion requested if maxSize is not multiplied by the
       // bufferSizeFactor
       if (variable.type._csfrm === constants.CSFRM_NCHAR) {
-        maxSize *= variable.type._bufferSizeFactor;
+        maxSize = Math.min(maxSize * variable.type._bufferSizeFactor, constants.TNS_MAX_LONG_LENGTH);
       }
       if ([constants.TNS_DATA_TYPE_ROWID, constants.TNS_DATA_TYPE_UROWID].includes(oraTypeNum)) {
         oraTypeNum = constants.TNS_DATA_TYPE_VARCHAR;
@@ -715,8 +711,7 @@ class MessageWithData extends Message {
       let contFlag = 0;
       if (variable.type === types.DB_TYPE_BLOB ||
           variable.type === types.DB_TYPE_CLOB ||
-          variable.type === types.DB_TYPE_NCLOB ||
-          variable.type === types.DB_TYPE_BFILE) {
+          variable.type === types.DB_TYPE_NCLOB) {
         contFlag = constants.TNS_LOB_PREFETCH_FLAG;
       } else if (variable.type === types.DB_TYPE_JSON) {
         contFlag = constants.TNS_LOB_PREFETCH_FLAG;
@@ -731,11 +726,9 @@ class MessageWithData extends Message {
       // expects that and complains if any other value is sent!
       buf.writeUInt8(0);
       buf.writeUInt8(0);
-      if (maxSize > buf.caps.maxStringSize) {
-        buf.writeUB4(constants.TNS_MAX_LONG_LENGTH);
-      } else {
-        buf.writeUB4(maxSize);
-      }
+
+      // Write the max buffer size
+      buf.writeUB4(maxSize);
 
       if (variable.isArray) {
         buf.writeUB4(variable.maxArraySize);

package/lib/thin/protocol/protocol.js

@@ -31,6 +31,7 @@ const Capabilities = require("./capabilities.js");
 const {WritePacket, ReadPacket} = require("./packet.js");
 const errors = require("../../errors");
 const utils = require("./utils.js");
+const traceHandler = require('../../traceHandler.js');
 
 /**
  * Handles protocol details.
@@ -141,6 +142,13 @@ class Protocol {
   async _processMessage(message) {
     let callTimer;
     let callTimeoutExpired = false;
+    let traceInstance, traceContext;
+    const traceEnabled = traceHandler.isEnabled();
+
+    if (traceEnabled) {
+      traceContext = { additionalConfig: {} };
+      traceInstance = traceHandler.getTraceInstance();
+    }
     try {
       if (this.callTimeout > 0) {
         callTimer = setTimeout(() => {
@@ -148,6 +156,10 @@ class Protocol {
           this.breakMessage();
         }, this.callTimeout);
       }
+      if (traceEnabled) {
+        traceContext.operation = `oracledb.${message.constructor.name}`;
+        traceInstance.onBeginRoundTrip(traceContext);
+      }
       await this._encodeMessage(message);
       if (message.messageType !== constants.TNS_MSG_TYPE_ONEWAY_FN) {
         await this._decodeMessage(message);
@@ -157,9 +169,20 @@ class Protocol {
           err.code !== errors.ERR_CONNECTION_CLOSED_CODE) {
         await this._recoverFromError(err, message);
       }
+      if (traceEnabled) {
+        traceContext.error = err;
+      }
       throw err;
     } finally {
       clearTimeout(callTimer);
+      if (traceEnabled) {
+        traceContext.callLevelConfig = message.connection._callLevelTraceData;
+        traceContext.connectLevelConfig = message.connection._getConnectTraceConfig();
+        if (message.callStatus & constants.TNS_EOCS_FLAGS_SESS_RELEASE) {
+          traceContext.additionalConfig.implicitRelease = true;
+        }
+        traceInstance.onEndRoundTrip(traceContext);
+      }
     }
     if (message.flushOutBinds) {
       await this.flushOutBindMessage(message);

package/lib/thin/sqlnet/connStrategy.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -29,6 +29,7 @@
 const { NavAddress, NavAddressList, NavDescription, NavDescriptionList } = require("./navNodes.js");
 const { createNVPair } = require("./nvStrToNvPair.js");
 const errors = require("../../errors.js");
+const constants = require("./constants.js");
 
 /**
  * Class that holds all possible attributes under Description
@@ -89,6 +90,7 @@ class ConnStrategy {
     this.descriptionList.push(this.currentDescription);
     this.currentDescription = null;
   }
+
   /**
   * Execute the Connection Options from the array.  When a refuse packet is received from
   * server this method is called again and the next connect option is tried.
@@ -114,6 +116,8 @@ class ConnStrategy {
       if (config != null) {
         if ((delay == 0 || delay == undefined) && config.retryDelay > 0) {
           delay = config.retryDelay * 1000;
+        } else if (!delay) {
+          delay = constants.DEFAULT_RETRY_DELAY; // 1 sec default
         }
       }
       for (let i = this.lastRetryCounter; i <= this.retryCount; ++i) {
@@ -145,8 +149,8 @@ class ConnStrategy {
   }
   // sleep time expects milliseconds
 
-
 }
+
 function sleep(time) {
   return new Promise((resolve) => setTimeout(resolve, time));
 }
@@ -157,7 +161,7 @@ function sleep(time) {
  * @param {string} str - input description string
  * @returns {object} - returns a connection strategy object.
  */
-async function createNode(str) {
+async function createNode(str, userConfig) {
   let nvpair;
   if (typeof str === 'string')
     nvpair = createNVPair(str);
@@ -185,6 +189,11 @@ async function createNode(str) {
   }
   navobj.initFromNVPair(nvpair);
   const cs = new ConnStrategy();
+  cs.driverName = userConfig.driverName;
+  cs.machine = userConfig.machine;
+  cs.terminal = userConfig.terminal;
+  cs.osUser = userConfig.osUser;
+  cs.program = userConfig.program;
   await navobj.navigate(cs);
   return cs;
 }

package/lib/thin/sqlnet/constants.js

@@ -187,6 +187,8 @@ module.exports =  {
   DISABLE_OOB_STR: 'DISABLE_OOB', // disable OOB parameter
   EXPIRE_TIME: 'EXPIRE_TIME', // expire Time
   PEM_WALLET_FILE_NAME: 'ewallet.pem',
+  DEFAULT_TRANSPORT_CONNECT_TIMEOUT: 20000, //default transport connect timeout
+  DEFAULT_RETRY_DELAY: 1000, //default retry delay
 
   /* Get/Set options */
   NT_MOREDATA: 1, // More Data in Transport available