oracledb 6.3.0 → 6.5.0

package/lib/thin/connection.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -31,7 +31,7 @@ const ConnectionImpl = require('../impl/connection.js');
 const ThinResultSetImpl = require('./resultSet.js');
 const ThinLobImpl  = require("./lob.js");
 const Protocol = require("./protocol/protocol.js");
-const { BaseBuffer } = require('./protocol/buffer.js');
+const { BaseBuffer } = require('../impl/datahandlers/buffer.js');
 const {NetworkSession: nsi} = require("./sqlnet/networkSession.js");
 const { Statement } = require("./statement");
 const thinUtil = require('./util');
@@ -41,6 +41,7 @@ const process = require('process');
 const types = require('../types.js');
 const errors = require("../errors.js");
 const messages = require('./protocol/messages');
+const StatementCache = require('./statementCache.js');
 
 const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
   heldValue.disconnect();
@@ -49,8 +50,6 @@ const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
 class TDSBuffer extends BaseBuffer {
 }
 
-const connectionCookies = new Map();
-
 class ThinConnectionImpl extends ConnectionImpl {
 
   /**
@@ -63,12 +62,10 @@ class ThinConnectionImpl extends ConnectionImpl {
       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 {
@@ -94,13 +91,13 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   //---------------------------------------------------------------------------
-  // _determineElementObjType()
+  // _getElementTypeObj()
   //
-  // Determine the element type's object type. This is needed when processing
+  // Get the element type's object type. This is needed when processing
   // collections with an object as the element type since this information is
   // not available in the TDS.
   //---------------------------------------------------------------------------
-  async _determineElementObjType(info) {
+  async _getElementTypeObj(info) {
     const binds = [
       {
         name: "owner",
@@ -184,12 +181,20 @@ class ThinConnectionImpl extends ConnectionImpl {
     message.numExecs = numIters;
     message.arrayDmlRowCounts = options.dmlRowCounts;
     message.batchErrors = options.batchErrors;
-    if (statement.isPlSql && statement.requiresFullExecute) {
+
+    // if a PL/SQL statement requires a full execute, perform only a single
+    // iteration in order to allow the determination of input/output binds
+    // to be completed; after that, an execution of the remaining iterations
+    // can be performed.
+    if (statement.isPlSql && (statement.cursorId === 0 ||
+      statement.requiresFullExecute)) {
       message.numExecs = 1;
+      message.noImplicitRelease = true;
       await this._protocol._processMessage(message);
       statement.requiresFullExecute = false;
       message.numExecs = numIters - 1;
       message.offset = 1;
+      message.noImplicitRelease = false;
     }
     if (message.numExecs > 0) {
       await this._protocol._processMessage(message);
@@ -255,60 +260,77 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   //---------------------------------------------------------------------------
-  // _parseElementType()
+  // _parseTDSAttr()
   //
-  // Parses the element type from the TDS buffer.
+  // Returns the DB type and fills metadata from the TDS buffer.
   //---------------------------------------------------------------------------
-  async _parseElementType(buf, info) {
-    let oraTypeNum, csfrm;
-    const attrType = buf.readUInt8();
+  _parseTDSAttr(buf, metaData) {
+    let oraTypeNum, csfrm, attrType;
+
+    // skip until a type code that is of interest
+    for (;;) {
+      attrType = buf.readUInt8();
+      if (attrType === constants.TNS_OBJ_TDS_TYPE_EMBED_ADT_INFO) {
+        buf.skipBytes(1); // flags
+      } else if (attrType !== constants.TNS_OBJ_TDS_TYPE_SUBTYPE_MARKER) {
+        break;
+      }
+    }
+
+    // process the type code.
     switch (attrType) {
       case constants.TNS_OBJ_TDS_TYPE_NUMBER:
+        metaData.precision = buf.readInt8();
+        metaData.scale = buf.readInt8();
+        return types.DB_TYPE_NUMBER;
       case constants.TNS_OBJ_TDS_TYPE_FLOAT:
-        info.elementType = types.DB_TYPE_NUMBER;
-        break;
+        metaData.precision = buf.readInt8();
+        return types.DB_TYPE_NUMBER;
       case constants.TNS_OBJ_TDS_TYPE_VARCHAR:
       case constants.TNS_OBJ_TDS_TYPE_CHAR:
-        info.maxSize = buf.readUInt16BE();
+        metaData.maxSize = buf.readUInt16BE(); // maximum length
         oraTypeNum = (attrType === constants.TNS_OBJ_TDS_TYPE_VARCHAR) ?
           constants.TNS_DATA_TYPE_VARCHAR : constants.TNS_DATA_TYPE_CHAR;
         csfrm = buf.readUInt8();
-        info.elementType = types.getTypeByOraTypeNum(oraTypeNum, csfrm);
-        break;
+        csfrm = csfrm & 0x7f;
+        buf.skipBytes(2); // character set
+        return types.getTypeByOraTypeNum(oraTypeNum, csfrm);
       case constants.TNS_OBJ_TDS_TYPE_RAW:
-        info.elementType = types.DB_TYPE_RAW;
-        break;
+        metaData.maxSize = buf.readUInt16BE(); // maximum length
+        return types.DB_TYPE_RAW;
       case constants.TNS_OBJ_TDS_TYPE_BINARY_FLOAT:
-        info.elementType = types.DB_TYPE_BINARY_FLOAT;
-        break;
+        return types.DB_TYPE_BINARY_FLOAT;
       case constants.TNS_OBJ_TDS_TYPE_BINARY_DOUBLE:
-        info.elementType = types.DB_TYPE_BINARY_DOUBLE;
-        break;
+        return types.DB_TYPE_BINARY_DOUBLE;
       case constants.TNS_OBJ_TDS_TYPE_DATE:
-        info.elementType = types.DB_TYPE_DATE;
-        break;
+        return types.DB_TYPE_DATE;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP:
-        info.elementType = types.DB_TYPE_TIMESTAMP;
-        break;
+        buf.skipBytes(1); // precision
+        return types.DB_TYPE_TIMESTAMP;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP_LTZ:
-        info.elementType = types.DB_TYPE_TIMESTAMP_LTZ;
-        break;
+        buf.skipBytes(1); // precision
+        return types.DB_TYPE_TIMESTAMP_LTZ;
       case constants.TNS_OBJ_TDS_TYPE_TIMESTAMP_TZ:
-        info.elementType = types.DB_TYPE_TIMESTAMP_TZ;
-        break;
+        buf.skipBytes(1); // precision
+        return types.DB_TYPE_TIMESTAMP_TZ;
       case constants.TNS_OBJ_TDS_TYPE_BOOLEAN:
-        info.elementType = types.DB_TYPE_BOOLEAN;
-        break;
+        return types.DB_TYPE_BOOLEAN;
       case constants.TNS_OBJ_TDS_TYPE_CLOB:
-        this._determineElementTypeCharsetForm(info);
-        break;
+        return types.DB_TYPE_CLOB;
       case constants.TNS_OBJ_TDS_TYPE_BLOB:
-        info.elementType = types.DB_TYPE_BLOB;
-        break;
+        return types.DB_TYPE_BLOB;
       case constants.TNS_OBJ_TDS_TYPE_OBJ:
-        info.elementType = types.DB_TYPE_OBJECT;
-        await this._determineElementObjType(info);
-        break;
+        buf.skipBytes(5);
+        return types.DB_TYPE_OBJECT;
+      case constants.TNS_OBJ_TDS_TYPE_START_EMBED_ADT:
+        // loop until end type, TNS_OBJ_TDS_TYPE_END_EMBED_ADT
+        // is received.
+        while (this._parseTDSAttr(buf, {}) !== 0) {
+          continue;
+        }
+        return types.DB_TYPE_OBJECT;
+      case constants.TNS_OBJ_TDS_TYPE_END_EMBED_ADT:
+        return 0;
       default:
         errors.throwErr(errors.ERR_TDS_TYPE_NOT_SUPPORTED, attrType);
     }
@@ -317,12 +339,9 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   // _parseTDS()
   //
-  // Parses the TDS for the type. This is only needed for collection types, so
-  // if the TDS is determined to be for an object type, the remaining
-  // information is ignored.
+  // Parses the TDS (type descriptor segment) for the type.
   //---------------------------------------------------------------------------
   async _parseTDS(tds, info) {
-
     // parse initial TDS bytes
     const buf = new TDSBuffer(tds);
     buf.skipBytes(4);                   // end offset
@@ -332,10 +351,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     // if the number of attributes exceeds 1, the type cannot refer to a
     // collection, so nothing further needs to be done
     const numAttrs = buf.readUInt16BE();
-    if (numAttrs > 1) {
-      info.isCollection = false;
-      return;
-    }
 
     // continue parsing TDS bytes to discover if type refers to a collection
     buf.skipBytes(1);                   // TDS attributes?
@@ -343,23 +358,41 @@ class ThinConnectionImpl extends ConnectionImpl {
     buf.skipBytes(2);                   // ADT number (always zero)
     buf.skipBytes(4);                   // offset to index table
 
-    // if type of first attribute is not a collection, nothing further needs
-    // to be done
-    const attrType = buf.readUInt8();
-    info.isCollection = (attrType === constants.TNS_OBJ_TDS_TYPE_COLL);
-    if (!info.isCollection)
-      return;
-
-    // continue parsing TDS to determine element type
-    const elementPos = buf.readUInt32BE();
-    info.maxNumElements = buf.readUInt32BE();
-    info.collectionType = buf.readUInt8();
-    if (info.collectionType === constants.TNS_OBJ_PLSQL_INDEX_TABLE) {
-      info.collectionFlags = constants.TNS_OBJ_HAS_INDEXES;
+    // check to see if type refers to a collection (only one attribute is
+    // present in that case).
+    info.isCollection = false;
+    if (numAttrs === 1) {
+      const pos = buf.pos;
+      const attrType = buf.readUInt8();
+      if (attrType === constants.TNS_OBJ_TDS_TYPE_COLL) {
+        info.isCollection = true;
+      } else {
+        buf.pos = pos;
+      }
     }
-    buf.pos = elementPos;
 
-    await this._parseElementType(buf, info);
+    // Handle collections
+    if (info.isCollection) {
+      // continue parsing TDS to determine element type
+      const elementPos = buf.readUInt32BE();
+      info.maxNumElements = buf.readUInt32BE();
+      info.collectionType = buf.readUInt8();
+      if (info.collectionType === constants.TNS_OBJ_PLSQL_INDEX_TABLE) {
+        info.collectionFlags = constants.TNS_OBJ_HAS_INDEXES;
+      }
+      buf.pos = elementPos;
+      info.elementTypeInfo = {};
+      info.elementType = this._parseTDSAttr(buf, info.elementTypeInfo);
+      if (info.elementType === types.DB_TYPE_OBJECT) {
+        await this._getElementTypeObj(info);
+      }
+    } else {
+      if (info.attributes) { // skip for XML type as it has no attributes.
+        for (const attr of info.attributes) {
+          this._parseTDSAttr(buf, attr);
+        }
+      }
+    }
   }
 
   //---------------------------------------------------------------------------
@@ -485,9 +518,9 @@ class ThinConnectionImpl extends ConnectionImpl {
 
     // process TDS and attributes cursor
     info.version = result.outBinds.version;
-    await this._parseTDS(result.outBinds.tds, info);
     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] };
@@ -503,8 +536,9 @@ class ThinConnectionImpl extends ConnectionImpl {
         info.attributes.push(attr);
       }
     }
-    info.partial = false;
 
+    await this._parseTDS(result.outBinds.tds, info);
+    info.partial = false;
     return info;
 
   }
@@ -560,26 +594,6 @@ 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
@@ -599,11 +613,8 @@ class ThinConnectionImpl extends ConnectionImpl {
     this.statementCache = null;
     this.currentSchema = "";
     this.invokeSessionCallback = true;
-    this.statementCache = new Map();
     this.statementCacheSize = params.stmtCacheSize;
-    this._numCursorsToClose = 0;
     this._currentSchemaModified = false;
-    this._cursorsToClose = new Set();
     this._tempLobsToClose = [];
     this._tempLobsTotalSize = 0;
     this._drcpEstablishSession = false;
@@ -667,37 +678,24 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     try {
-      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;
+      if (this.nscon.supportsFastAuth) {
+        const fastAuthMessage = new messages.FastAuthMessage(this);
+        fastAuthMessage.protocolMessage = protocolMessage;
+        fastAuthMessage.dataTypeMessage = dataTypeMessage;
+        fastAuthMessage.authMessage = authMessage;
+        await this._protocol._processMessage(fastAuthMessage);
+        if (fastAuthMessage.reNegotiate) {
+          // Fast Authentication failed.
+          await this._protocol._processMessage(dataTypeMessage);
+          await this._protocol._processMessage(authMessage);
+        }
       } 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
@@ -707,6 +705,7 @@ class ThinConnectionImpl extends ConnectionImpl {
       throw err;
     }
 
+    this.statementCache = new StatementCache(this.statementCacheSize);
     // maintain a list of partially populated database object types
     this._partialDbObjectTypes = [];
 
@@ -719,51 +718,10 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   //---------------------------------------------------------------------------
-  // Sets that a statement is no longer in use
+  // Return the statement to the statement cache, if applicable
   //---------------------------------------------------------------------------
   _returnStatement(statement) {
-    if (statement.bindInfoList) {
-      statement.bindInfoList.forEach(bindInfo => {
-        bindInfo.bindVar = null;
-      });
-    }
-    if (statement.queryVars) {
-      statement.queryVars.forEach(queryVar => {
-        queryVar.values.fill(null);
-      });
-    }
-    if (statement.returnToCache) {
-      statement.inUse = false;
-    } else if (statement.cursorId !== 0) {
-      this._addCursorToClose(statement.cursorId);
-    }
-  }
-
-  //---------------------------------------------------------------------------
-  // Adds the cursors that needs to be closed to the _cursorsToClose set
-  //---------------------------------------------------------------------------
-  _addCursorToClose(cursorId) {
-    if (this._cursorsToClose.has(cursorId)) {
-      const reason = `attempt to close cursor ${cursorId} twice`;
-      errors.throwErr(errors.ERR_INTERNAL, reason);
-    }
-    this._cursorsToClose.add(cursorId);
-  }
-
-  //---------------------------------------------------------------------------
-  // Adjusts the statement cache to remove least recently used statements
-  //---------------------------------------------------------------------------
-  _adjustStatementCache() {
-    while (this.statementCache.size > this.statementCacheSize) {
-      const sql = this.statementCache.keys().next().value;
-      const stmt = this.statementCache.get(sql);
-      this.statementCache.delete(sql);
-      if (stmt.inUse) {
-        stmt.returnToCache = false;
-      } else if (stmt.cursorId !== 0) {
-        this._addCursorToClose(stmt.cursorId);
-      }
-    }
+    this.statementCache.returnStatement(statement);
   }
 
   //---------------------------------------------------------------------------
@@ -873,14 +831,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     return resultSet;
   }
 
-  //---------------------------------------------------------------------------
-  // Clears the statement cache for the connection
-  //---------------------------------------------------------------------------
-  resetStatementCache() {
-    this.statementCache.clear();
-    this._cursorsToClose.clear();
-  }
-
   //---------------------------------------------------------------------------
   // getDbObjectClass()
   //
@@ -945,31 +895,8 @@ class ThinConnectionImpl extends ConnectionImpl {
   // new session is going to be used.
   //---------------------------------------------------------------------------
   _getStatement(sql, cacheStatement = false) {
-    let statement = this.statementCache.get(sql);
-    if (!statement) {
-      statement = new Statement();
-      statement._prepare(sql);
-      if (cacheStatement && !this._drcpEstablishSession && !statement.isDdl &&
-          this.statementCacheSize > 0) {
-        statement.returnToCache = true;
-        this.statementCache.set(sql, statement);
-        this._adjustStatementCache();
-      }
-    } else if (statement.inUse || !cacheStatement ||
-        this._drcpEstablishSession) {
-      if (!cacheStatement) {
-        this.statementCache.delete(sql);
-        statement.returnToCache = false;
-      }
-      if (statement.inUse || this._drcpEstablishSession) {
-        statement = statement._copy();
-      }
-    } else {
-      this.statementCache.delete(sql);
-      this.statementCache.set(sql, statement);
-    }
-    statement.inUse = true;
-    return statement;
+    return this.statementCache.getStatement(sql, cacheStatement,
+      this._drcpEstablishSession);
   }
 
   //---------------------------------------------------------------------------
@@ -1064,7 +991,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   // the connection object
   //---------------------------------------------------------------------------
   getStmtCacheSize() {
-    return this.statementCacheSize;
+    return this.statementCache._maxSize;
   }
 
   setCallTimeout(timeout) {
@@ -1121,7 +1048,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   // Returns boolean based on this._protocol.txnInProgress value.
   //---------------------------------------------------------------------------
   getTransactionInProgress() {
-    return this._protocol.txnInProgress === constants.TNS_TXN_IN_PROGRESS;
+    return this._protocol.txnInProgress;
   }
 
   //---------------------------------------------------------------------------

package/lib/thin/dbObject.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -31,7 +31,7 @@ const constants = require('./protocol/constants.js');
 const errors = require('../errors.js');
 const types = require('../types.js');
 const DbObjectImpl = require('../impl/dbObject.js');
-const { GrowableBuffer } = require('./protocol/buffer.js');
+const { GrowableBuffer } = require('../impl/datahandlers/buffer.js');
 const ThinLobImpl = require('./lob.js');
 
 class DbObjectPickleBuffer extends GrowableBuffer {
@@ -280,9 +280,11 @@ class ThinDbObjectImpl extends DbObjectImpl {
           buf.writeBytesWithLength(value);
           break;
         case types.DB_TYPE_BINARY_DOUBLE:
+          buf.writeUInt8(8);
           buf.writeBinaryDouble(value);
           break;
         case types.DB_TYPE_BINARY_FLOAT:
+          buf.writeUInt8(4);
           buf.writeBinaryFloat(value);
           break;
         case types.DB_TYPE_DATE:

package/lib/thin/lob.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -89,11 +89,11 @@ class ThinLobImpl extends LobImpl {
     return this.dbType;
   }
 
-  async getData() {
-    if (this._length < 0) {
-      errors.throwErr(errors.ERR_INVALID_LOB);
+  async getData(offset = 1, len = this._length) {
+    if (!len) {
+      len = this._length;
     }
-    return await this.read(1, this._length);
+    return await this.read(offset, len);
   }
 
   async read(offset, length) {
@@ -157,7 +157,7 @@ class ThinLobImpl extends LobImpl {
 
   checkConn() {
     if (!this.conn.nscon.connected)
-      errors.throwErr(errors.ERR_LOB_CLOSED);
+      errors.throwErr(errors.ERR_INVALID_CONNECTION);
   }
 
   close() {