oracledb 6.5.0 → 6.6.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();
@@ -385,6 +391,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.
@@ -439,6 +448,27 @@ class ThinConnectionImpl extends ConnectionImpl {
               end;
           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",
@@ -517,32 +547,105 @@ class ThinConnectionImpl extends ConnectionImpl {
       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.
+    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 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);
+        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
+              );
           }
-        } else {
-          attr.type = types.getTypeByColumnTypeName(row[3]);
         }
-        info.attributes.push(attr);
+        this._addAttr(info.attributes, metaData);
       }
-    }
+    } 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);
+        }
 
-    await this._parseTDS(result.outBinds.tds, info);
+      }
+      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);
+  }
+
   //---------------------------------------------------------------------------
   // _populatePartialDbObjectTypes()
   //
@@ -633,6 +736,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);
@@ -948,6 +1052,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 +1098,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 +1217,10 @@ class ThinConnectionImpl extends ConnectionImpl {
     return '';
   }
 
+  getExternalName() {
+    return this.externalName;
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database instance name associated with the connection.
   //---------------------------------------------------------------------------
@@ -1016,6 +1228,10 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.instanceName;
   }
 
+  getInternalName() {
+    return this.internalName;
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database domain 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 {

package/lib/thin/lob.js

@@ -31,6 +31,7 @@ const LobImpl = require('../impl/lob.js');
 const constants = require('./protocol/constants.js');
 const LobOpMessage = require('./protocol/messages/lobOp.js');
 const errors = require('../errors.js');
+const types = require('../types.js');
 
 class ThinLobImpl extends LobImpl {
 
@@ -54,15 +55,31 @@ class ThinLobImpl extends LobImpl {
     await this.conn._protocol._processMessage(message);
     if (options.operation === constants.TNS_LOB_OP_READ) {
       return (message.data) ? message.data : null;
+    } else if (
+      options.operation === constants.TNS_LOB_OP_FILE_EXISTS ||
+      options.operation === constants.TNS_LOB_OP_FILE_ISOPEN
+    ) {
+      return message.boolFlag;
     } else {
       return message.amount;
     }
   }
 
+  //---------------------------------------------------------------------------
+  // getChunkSize()
+  //
+  // Internal method for returning the chunk size of the LOB.
+  //---------------------------------------------------------------------------
   getChunkSize() {
     return this._chunkSize;
   }
 
+  //---------------------------------------------------------------------------
+  // _getChunkSizeAsync()
+  //
+  // Internal method for returning the chunk size of the LOB fetched from
+  // the database.
+  //---------------------------------------------------------------------------
   async _getChunkSizeAsync() {
     this.checkConn();
     const options = {
@@ -73,29 +90,76 @@ class ThinLobImpl extends LobImpl {
     this._chunkSize = this._pieceSize = await this._sendMessage(options);
   }
 
+  //---------------------------------------------------------------------------
+  // getLength()
+  //
+  // Internal method for returning the length of a LOB.
+  //---------------------------------------------------------------------------
   getLength() {
     return this._length;
   }
 
+  //---------------------------------------------------------------------------
+  // getPieceSize()
+  //
+  // Internal method returning the size to use for each piece that is
+  // transferred when reading from the LOB.
+  //---------------------------------------------------------------------------
   getPieceSize() {
     return this._pieceSize;
   }
 
+  //---------------------------------------------------------------------------
+  // setPieceSize()
+  //
+  // Internal method to set the pieceSize for LOBs.
+  //---------------------------------------------------------------------------
   setPieceSize(value) {
     this._pieceSize = value;
   }
 
+  //---------------------------------------------------------------------------
+  // getType()
+  //
+  // Internal method returning the datatype of LOBs.
+  //---------------------------------------------------------------------------
   getType() {
     return this.dbType;
   }
 
+  //---------------------------------------------------------------------------
+  // getData()
+  //
+  // Internal method returning the data obtained from the database.
+  //---------------------------------------------------------------------------
   async getData(offset = 1, len = this._length) {
+    let shouldClose = false;
     if (!len) {
       len = this._length;
     }
-    return await this.read(offset, len);
+    if (this.dbType === types.DB_TYPE_BFILE) {
+      if (!await this.isFileOpen()) {
+        shouldClose = true;
+        await this.openFile();
+      }
+    }
+    let data;
+    // if read fails and BFILE was opened by application, we close it.
+    try {
+      data = await this.read(offset, len);
+    } finally {
+      if (shouldClose) {
+        await this.closeFile();
+      }
+    }
+    return data;
   }
 
+  //---------------------------------------------------------------------------
+  // read()
+  //
+  // Internal method for reading a portion (or all) of the data in the LOB.
+  //---------------------------------------------------------------------------
   async read(offset, length) {
     this.checkConn();
     const options = {
@@ -108,6 +172,11 @@ class ThinLobImpl extends LobImpl {
     return await this._sendMessage(options);
   }
 
+  //---------------------------------------------------------------------------
+  // write()
+  //
+  // Internal method for writing data to the LOB object.
+  //---------------------------------------------------------------------------
   async write(offset, data) {
     this.checkConn();
     const options = {
@@ -120,6 +189,11 @@ class ThinLobImpl extends LobImpl {
     this._length += data.length;
   }
 
+  //---------------------------------------------------------------------------
+  // getCsfrm()
+  //
+  // Return the character set encoding used by the LOB.
+  //---------------------------------------------------------------------------
   getCsfrm() {
     if (this.dbType._csfrm !== constants.CSFRM_NCHAR) {
       if (this._locator[constants.TNS_LOB_LOC_OFFSET_FLAG_3] &
@@ -155,11 +229,60 @@ class ThinLobImpl extends LobImpl {
     await this._getChunkSizeAsync();
   }
 
+  //---------------------------------------------------------------------------
+  // fileExists()
+  //
+  // Internal method for returning whether the file referenced by a BFILE
+  // exists.
+  //---------------------------------------------------------------------------
+  async fileExists() {
+    this.checkConn();
+    const options = {
+      operation: constants.TNS_LOB_OP_FILE_EXISTS,
+      sourceLobImpl: this,
+    };
+    return await this._sendMessage(options);
+  }
+
+  //---------------------------------------------------------------------------
+  // getDirFileName()
+  //
+  // Internal method for returning the directory alias and name of the file
+  // referenced by a BFILE
+  //---------------------------------------------------------------------------
+  getDirFileName() {
+    const dirNameOffset = constants.TNS_LOB_LOC_FIXED_OFFSET + 2;
+    const dirNameLen = this._locator.readUInt16BE(
+      constants.TNS_LOB_LOC_FIXED_OFFSET
+    );
+    const fileNameOffset = constants.TNS_LOB_LOC_FIXED_OFFSET + dirNameLen + 4;
+    const fileNameLen = this._locator.readUInt16BE(
+      dirNameOffset + dirNameLen
+    );
+    const dirName = this._locator.slice(
+      dirNameOffset, dirNameOffset + dirNameLen
+    ).toString();
+    const fileName = this._locator.slice(
+      fileNameOffset, fileNameOffset + fileNameLen
+    ).toString();
+    return { dirName: dirName, fileName: fileName };
+  }
+
+  //---------------------------------------------------------------------------
+  // checkConn()
+  //
+  // Internal method to check the connection.
+  //---------------------------------------------------------------------------
   checkConn() {
     if (!this.conn.nscon.connected)
       errors.throwErr(errors.ERR_INVALID_CONNECTION);
   }
 
+  //---------------------------------------------------------------------------
+  // close()
+  //
+  // Internal method to close the LOBs using piggyback mechanism.
+  //---------------------------------------------------------------------------
   close() {
     this.checkConn();
     if (this._isTempLob) {
@@ -169,6 +292,25 @@ class ThinLobImpl extends LobImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // closeFile()
+  //
+  // Internal method to close the opened file for BFILE LOBs.
+  //---------------------------------------------------------------------------
+  async closeFile() {
+    this.checkConn();
+    const options = {
+      operation: constants.TNS_LOB_OP_FILE_CLOSE,
+      sourceLobImpl: this,
+    };
+    await this._sendMessage(options);
+  }
+
+  //---------------------------------------------------------------------------
+  // init()
+  //
+  // Internal method to initialize LOBs.
+  //---------------------------------------------------------------------------
   init(conn, locator, dbType, len, chunkSize) {
     this.dirtyLength = false;
     this.conn = conn;
@@ -184,6 +326,56 @@ class ThinLobImpl extends LobImpl {
     this._pieceSize = chunkSize;
   }
 
+  //---------------------------------------------------------------------------
+  // isFileOpen()
+  //
+  // Internal method to check if the file is already open.
+  //---------------------------------------------------------------------------
+  async isFileOpen() {
+    const options = {
+      operation: constants.TNS_LOB_OP_FILE_ISOPEN,
+      sourceLobImpl: this
+    };
+    await this._sendMessage(options);
+  }
+
+  //---------------------------------------------------------------------------
+  // openFile()
+  //
+  // Internal method for opening file (BFILE).
+  //---------------------------------------------------------------------------
+  async openFile() {
+    this.checkConn();
+    const options =  {
+      operation: constants.TNS_LOB_OP_FILE_OPEN,
+      sourceLobImpl: this,
+      amount: constants.TNS_LOB_OPEN_READ_ONLY,
+      sendAmount: true
+    };
+    return await this._sendMessage(options);
+  }
+
+  //---------------------------------------------------------------------------
+  // setDirFileName()
+  //
+  // Internal method for setting the directory alias and name of the file
+  // referenced by a BFILE
+  //---------------------------------------------------------------------------
+  setDirFileName(dirObject) {
+    const dirNameLen = Buffer.byteLength(dirObject.dirName);
+    const dirNameOffset = constants.TNS_LOB_LOC_FIXED_OFFSET + 2;
+    const fileNameOffset = dirNameOffset + dirNameLen + 2;
+    const fileNameLen = Buffer.byteLength(dirObject.fileName);
+    const newLocLen = fileNameOffset + fileNameLen;
+    const newLocator = Buffer.allocUnsafe(newLocLen);
+    this._locator.copy(newLocator, 0, 0, constants.TNS_LOB_LOC_FIXED_OFFSET + 1);
+    newLocator.writeUInt16BE(dirNameLen, constants.TNS_LOB_LOC_FIXED_OFFSET);
+    newLocator.write(dirObject.dirName, dirNameOffset);
+    newLocator.writeInt16BE(fileNameLen, dirNameOffset + dirNameLen);
+    newLocator.write(dirObject.fileName, fileNameOffset);
+    this._locator = newLocator;
+  }
+
 }
 
 module.exports = ThinLobImpl;

package/lib/thin/pool.js

@@ -64,6 +64,7 @@ class ThinPoolImpl extends PoolImpl {
     this._usedConnectionList = new Set();
     this._password = params.password;
     this._walletPassword = params.walletPassword;
+    this._walletContent = params.walletContent;
     this._obfuscatedPassword = [];
     this._obfuscatedWalletPassword = [];
     this._token = params.token;
@@ -88,6 +89,13 @@ class ThinPoolImpl extends PoolImpl {
       this._obfuscatedWalletPassword = obj.obfuscatedValue;
       this._userConfig.walletPassword = null;
     }
+    // wallet content obfuscation
+    if (this._walletContent !== undefined) {
+      const obj = protocolUtil.setObfuscatedValue(this._walletContent);
+      this._walletContent = obj.value;
+      this._obfuscatedWalletContent = obj.obfuscatedValue;
+      this._userConfig.walletConent = null;
+    }
     // token obfuscation
     if (this._token !== undefined) {
       const obj = protocolUtil.setObfuscatedValue(this._token);
@@ -172,6 +180,13 @@ class ThinPoolImpl extends PoolImpl {
           this._obfuscatedWalletPassword);
     }
 
+    // deobfuscate wallet content
+    if (clonedAttrs.walletContent === null) {
+      clonedAttrs.walletContent =
+            protocolUtil.getDeobfuscatedValue(this._walletContent,
+              this._obfuscatedWalletContent);
+    }
+
     // deobfuscate token and private key
     // check for token expiry
     if (clonedAttrs.token === null) {

package/lib/thin/protocol/capabilities.js

@@ -118,6 +118,8 @@ class Capabilities {
       constants.TNS_CCAP_CTB_IMPLICIT_POOL;
     this.compileCaps[constants.TNS_CCAP_TTC5] =
       constants.TNS_CCAP_VECTOR_SUPPORT;
+    this.compileCaps[constants.TNS_CCAP_VECTOR_FEATURES] =
+      constants.TNS_CCAP_VECTOR_FEATURE_BINARY;
   }
 
   initRuntimeCaps() {