oracledb 6.5.1 → 6.7.0

package/lib/thin/connection.js

@@ -60,7 +60,13 @@ class ThinConnectionImpl extends ConnectionImpl {
   async close() {
     try {
       if (this._protocol.txnInProgress) {
-        await this.rollback();
+        if (this.tpcContext) {
+          const message = this.createTpcRollbackMessage();
+          await this._protocol._processMessage(message);
+        } else {
+          await this.rollback();
+        }
+        this.tpcContext = null;
       }
       if (this._drcpEnabled) {
         await this._sessRelease();
@@ -163,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);
     }
@@ -385,6 +406,9 @@ class ThinConnectionImpl extends ConnectionImpl {
       info.elementType = this._parseTDSAttr(buf, info.elementTypeInfo);
       if (info.elementType === types.DB_TYPE_OBJECT) {
         await this._getElementTypeObj(info);
+        if (info.elementTypeClass.isXmlType) {
+          info.elementType = types.DB_TYPE_XMLTYPE;
+        }
       }
     } else {
       if (info.attributes) { // skip for XML type as it has no attributes.
@@ -395,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()
   //
@@ -439,6 +536,7 @@ class ThinConnectionImpl extends ConnectionImpl {
               end;
           end if;
       end;`;
+
     const binds = [
       {
         name: "full_name",
@@ -510,37 +608,74 @@ 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;
+    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;
+      }
 
-    // process TDS and attributes cursor
-    info.version = result.outBinds.version;
-    const attrRows = await result.outBinds.attrs_rc.getRows(1000, {});
-    if (attrRows.length > 0) {
-      // Its an object not a collection.
-      info.attributes = [];
-      for (const row of attrRows) {
-        const attr = { name: row[1] };
-        if (row[4]) {
-          attr.type = types.DB_TYPE_OBJECT;
-          attr.typeClass = this._getDbObjectType(row[4], row[3], row[5], row[6]);
-          if (attr.typeClass.partial) {
-            this._partialDbObjectTypes.push(attr.typeClass);
+      // 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);
           }
-        } else {
-          attr.type = types.getTypeByColumnTypeName(row[3]);
+
         }
-        info.attributes.push(attr);
+        await this._parseTDS(result.outBinds.tds, info);
       }
+      info.partial = false;
+      return info;
+    } finally {
+      result.outBinds.attrs_rc.close();
     }
 
-    await this._parseTDS(result.outBinds.tds, info);
-    info.partial = false;
-    return info;
+  }
 
+  //---------------------------------------------------------------------------
+  // _addAttr()
+  //
+  // Populates "attributes" object present in "attrList".
+  //---------------------------------------------------------------------------
+  _addAttr(attributes, attrInfo) {
+    const attr = { name: attrInfo.name };
+    if (attrInfo.dataTypeOwner) {
+      attr.type = types.DB_TYPE_OBJECT;
+      attr.typeClass = this._getDbObjectType(
+        attrInfo.dataTypeOwner,
+        attrInfo.dataType,
+        attrInfo.packageName,
+        attrInfo.oid
+      );
+
+      if (attr.typeClass.isXmlType) {
+        attr.type = types.DB_TYPE_XMLTYPE;
+      }
+      if (attr.typeClass.partial) {
+        this._partialDbObjectTypes.push(attr.typeClass);
+      }
+    } else {
+      attr.type = types.getTypeByColumnTypeName(attrInfo.dataType);
+      attr.maxSize = attrInfo.maxSize;
+      attr.precision = attrInfo.dataPrecision;
+      attr.scale = attrInfo.dataScale;
+    }
+    attributes.push(attr);
   }
 
   //---------------------------------------------------------------------------
@@ -633,6 +768,7 @@ class ThinConnectionImpl extends ConnectionImpl {
     this.serviceName = '';
     this.remoteAddress = '';
     this.comboKey = null; // used in changePassword API
+    this.tpcContext = null;
 
     this.nscon = new nsi();
     finalizationRegistry.register(this, this.nscon);
@@ -693,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
@@ -948,6 +1090,14 @@ class ThinConnectionImpl extends ConnectionImpl {
     this._dbOp = dbOp;
   }
 
+  setExternalName(value) {
+    this.externalName = value;
+  }
+
+  setInternalName(value) {
+    this.internalName = value;
+  }
+
   setClientInfo(clientInfo) {
     this._clientInfoModified = true;
     this._clientInfo = clientInfo;
@@ -986,6 +1136,102 @@ class ThinConnectionImpl extends ConnectionImpl {
     return lobImpl;
   }
 
+  // Check the state returned by the tpcCommit() call.
+  checkTpcCommitState(state, onePhase) {
+    if ((onePhase && state !== constants.TNS_TPC_TXN_STATE_READ_ONLY
+      && state !== constants.TNS_TPC_TXN_STATE_COMMITTED) ||
+      (!onePhase && state !== constants.TNS_TPC_TXN_STATE_FORGOTTEN)) {
+      errors.throwErr(errors.ERR_UNKNOWN_TRANSACTION_STATE, state);
+    }
+  }
+
+  // Creates a two-phase commit message suitable for committing a transaction.
+  createTpcCommitMessage(xid, onePhase) {
+    const message = new messages.TransactionChangeStateMessage(this);
+    message.operation = constants.TNS_TPC_TXN_COMMIT;
+    message.state = (onePhase == 0) ? constants.TNS_TPC_TXN_STATE_COMMITTED :
+      constants.TNS_TPC_TXN_STATE_READ_ONLY;
+    message.xid = xid;
+    message.context = this.tpcContext;
+    return message;
+  }
+
+  // Creates a two-phase commit rollback message suitable for use in both
+  // the close() method and explicitly by the user.
+  createTpcRollbackMessage(xid = null) {
+    const message = new messages.TransactionChangeStateMessage(this);
+    message.operation = constants.TNS_TPC_TXN_ABORT;
+    message.state = constants.TNS_TPC_TXN_STATE_ABORTED;
+    message.xid = xid;
+    message.context = this.tpcContext;
+    return message;
+  }
+
+  //---------------------------------------------------------------------------
+  // tpcBegin()
+  //---------------------------------------------------------------------------
+  async tpcBegin(xid, flags, timeout) {
+    const message = new messages.TransactionSwitchMessage(this);
+    message.operation = constants.TNS_TPC_TXN_START;
+    message.xid = xid;
+    message.flags = flags;
+    message.timeout = timeout;
+    await this._protocol._processMessage(message);
+    this.tpcContext = message.context;
+  }
+
+  //---------------------------------------------------------------------------
+  // tpcCommit()
+  //---------------------------------------------------------------------------
+  async tpcCommit(xid, onePhase) {
+    const message = this.createTpcCommitMessage(xid, onePhase);
+    await this._protocol._processMessage(message);
+    this.checkTpcCommitState(message.state, onePhase);
+  }
+
+  //---------------------------------------------------------------------------
+  // tpcEnd()
+  //---------------------------------------------------------------------------
+  async tpcEnd(xid, flags) {
+    const message = new messages.TransactionSwitchMessage(this);
+    message.operation = constants.TNS_TPC_TXN_DETACH;
+    message.xid = xid;
+    message.context = this.tpcContext;
+    message.flags = flags;
+    await this._protocol._processMessage(message);
+    this.tpcContext = null;
+  }
+
+  //---------------------------------------------------------------------------
+  // tpcPrepare()
+  //---------------------------------------------------------------------------
+  async tpcPrepare(xid) {
+    const message = new messages.TransactionChangeStateMessage(this);
+    message.operation = constants.TNS_TPC_TXN_PREPARE;
+    message.xid = xid;
+    message.context = this.tpcContext;
+    await this._protocol._processMessage(message);
+    if (message.state === constants.TNS_TPC_TXN_STATE_REQUIRES_COMMIT) {
+      return true;
+    } else if (message.state === constants.TNS_TPC_TXN_STATE_READ_ONLY) {
+      return false;
+    }
+
+    errors.throwErr(errors.ERR_UNKNOWN_TRANSACTION_STATE, message.state);
+  }
+
+  //---------------------------------------------------------------------------
+  // tpcRollback()
+  //---------------------------------------------------------------------------
+  async tpcRollback(xid) {
+    const message = this.createTpcRollbackMessage(xid);
+    await this._protocol._processMessage(message);
+    if (message.state !== constants.TNS_TPC_TXN_STATE_ABORTED) {
+      errors.throwErr(errors.ERR_UNKNOWN_TRANSACTION_STATE, message.state);
+    }
+  }
+
+
   //---------------------------------------------------------------------------
   // Returns the statement cache size for the statement cache maintained by
   // the connection object
@@ -1009,6 +1255,10 @@ class ThinConnectionImpl extends ConnectionImpl {
     return '';
   }
 
+  getExternalName() {
+    return this.externalName;
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database instance name associated with the connection.
   //---------------------------------------------------------------------------
@@ -1016,6 +1266,10 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.instanceName;
   }
 
+  getInternalName() {
+    return this.internalName;
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database domain name associated with the connection.
   //---------------------------------------------------------------------------
@@ -1023,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

@@ -397,10 +397,14 @@ class ThinDbObjectImpl extends DbObjectImpl {
       case types.DB_TYPE_BOOLEAN:
         return buf.readBool();
       case types.DB_TYPE_OBJECT:
+      case types.DB_TYPE_XMLTYPE:
         isNull = buf.getIsAtomicNull();
         if (isNull)
           return null;
         obj = new ThinDbObjectImpl(typeClass);
+        if (obj._objType.isXmlType) {
+          return readXML(obj._objType._connection, buf.readBytesWithLength());
+        }
         if (obj._objType.isCollection || this._objType.isCollection) {
           obj.packedData = Buffer.from(buf.readBytesWithLength());
         } else {