oracledb 6.3.0 → 6.4.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();
@@ -63,12 +64,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 +93,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",
@@ -255,60 +254,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 +333,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 +345,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 +352,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 +512,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 +530,9 @@ class ThinConnectionImpl extends ConnectionImpl {
         info.attributes.push(attr);
       }
     }
-    info.partial = false;
 
+    await this._parseTDS(result.outBinds.tds, info);
+    info.partial = false;
     return info;
 
   }
@@ -599,11 +627,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;
@@ -707,6 +732,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 +745,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 +858,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     return resultSet;
   }
 
-  //---------------------------------------------------------------------------
-  // Clears the statement cache for the connection
-  //---------------------------------------------------------------------------
-  resetStatementCache() {
-    this.statementCache.clear();
-    this._cursorsToClose.clear();
-  }
-
   //---------------------------------------------------------------------------
   // getDbObjectClass()
   //
@@ -945,31 +922,10 @@ 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);
+    if (this._drcpEstablishSession) {
+      cacheStatement = false;
     }
-    statement.inUse = true;
-    return statement;
+    return this.statementCache.getStatement(sql, cacheStatement);
   }
 
   //---------------------------------------------------------------------------
@@ -1064,7 +1020,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   // the connection object
   //---------------------------------------------------------------------------
   getStmtCacheSize() {
-    return this.statementCacheSize;
+    return this.statementCache._maxSize;
   }
 
   setCallTimeout(timeout) {

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() {

package/lib/thin/pool.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -53,6 +53,7 @@ class ThinPoolImpl extends PoolImpl {
     this._poolIncrement = params.poolIncrement;
     this._poolTimeout = params.poolTimeout;
     this._poolPingInterval = params.poolPingInterval;
+    this._poolPingTimeout = params.poolPingTimeout;
     this._stmtCacheSize = params.stmtCacheSize;
 
     // The user Config filterd from common layer is cached except
@@ -318,6 +319,13 @@ class ThinPoolImpl extends PoolImpl {
     return this._poolPingInterval;
   }
 
+  //---------------------------------------------------------------------------
+  // returns the pool ping Timeout (milliseconds)
+  //---------------------------------------------------------------------------
+  getPoolPingTimeout() {
+    return this._poolPingTimeout;
+  }
+
   //---------------------------------------------------------------------------
   // returns the pool timeout
   //---------------------------------------------------------------------------
@@ -363,13 +371,13 @@ class ThinPoolImpl extends PoolImpl {
   _scanIdleConnection() {
     while ((this._usedConnectionList.size + this._freeConnectionList.length) >
         this._poolMin && this._freeConnectionList.length > 0) {
-      const conn = this._freeConnectionList[this._freeConnectionList.length - 1];
+      const conn = this._freeConnectionList[0];
       if (Date.now() - conn._lastTimeUsed < this._poolTimeout * 1000) {
         break;
       }
 
       this.eventEmitter.emit('_removePoolConnection', conn);
-      this._freeConnectionList.pop();
+      this._freeConnectionList.shift();
     }
 
     this._schedulerJob = null;
@@ -495,11 +503,21 @@ class ThinPoolImpl extends PoolImpl {
           requiresPing = true;
       }
       if (requiresPing) {
+        let pingTimer;
         try {
+          if (this._poolPingTimeout) {
+            pingTimer = setTimeout(() => {
+              // force disconnect causes ping task to unblock
+              // and return.
+              conn.nscon.forceDisconnect();
+            }, this._poolPingTimeout);
+          }
           await conn.ping();
         } catch {
-          this.eventEmitter.emit('_removePoolConnection', conn);
+          conn.nscon.forceDisconnect();
           continue;
+        } finally {
+          clearTimeout(pingTimer);
         }
       }
 

package/lib/thin/protocol/capabilities.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -104,6 +104,8 @@ class Capabilities {
       constants.TNS_CCAP_CLIENT_FN_MAX;
     this.compileCaps[constants.TNS_CCAP_TTC4] =
       constants.TNS_CCAP_INBAND_NOTIFICATION;
+    this.compileCaps[constants.TNS_CCAP_TTC5] =
+      constants.TNS_CCAP_VECTOR_SUPPORT;
   }
 
   initRuntimeCaps() {

package/lib/thin/protocol/constants.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -28,6 +28,7 @@
 
 const { Buffer } = require('buffer');
 const constants = require('../../constants.js');
+const dataHandlerConstants = require('../../impl/datahandlers/constants.js');
 
 module.exports = {
 
@@ -198,6 +199,7 @@ module.exports = {
   TNS_DATA_TYPE_UD12: 124 + 256,
   TNS_DATA_TYPE_AL8: 125 + 256,
   TNS_DATA_TYPE_LFOP: 126 + 256,
+  TNS_DATA_TYPE_VECTOR: 127,
   TNS_DATA_TYPE_FCRT: 127 + 256,
   TNS_DATA_TYPE_DNY: 128 + 256,
   TNS_DATA_TYPE_OPR: 129 + 256,
@@ -513,42 +515,6 @@ module.exports = {
 
   // base JSON constants
   TNS_JSON_MAX_LENGTH: 32 * 1024 * 1024,
-  TNS_JSON_MAGIC_BYTE_1: 0xff,
-  TNS_JSON_MAGIC_BYTE_2: 0x4a,       // 'J'
-  TNS_JSON_MAGIC_BYTE_3: 0x5a,       // 'Z'
-  TNS_JSON_VERSION: 1,
-  TNS_JSON_FLAG_HASH_ID_UINT8: 0x0100,
-  TNS_JSON_FLAG_HASH_ID_UINT16: 0x0200,
-  TNS_JSON_FLAG_NUM_FNAMES_UINT16: 0x0400,
-  TNS_JSON_FLAG_FNAMES_SEG_UINT32: 0x0800,
-  TNS_JSON_FLAG_TINY_NODES_STAT: 0x2000,
-  TNS_JSON_FLAG_TREE_SEG_UINT32: 0x1000,
-  TNS_JSON_FLAG_REL_OFFSET_MODE: 0x01,
-  TNS_JSON_FLAG_INLINE_LEAF: 0x02,
-  TNS_JSON_FLAG_LEN_IN_PCODE: 0x04,
-  TNS_JSON_FLAG_NUM_FNAMES_UINT32: 0x08,
-  TNS_JSON_FLAG_IS_SCALAR: 0x10,
-
-  // JSON data types
-  TNS_JSON_TYPE_NULL: 0x30,
-  TNS_JSON_TYPE_TRUE: 0x31,
-  TNS_JSON_TYPE_FALSE: 0x32,
-  TNS_JSON_TYPE_STRING_LENGTH_UINT8: 0x33,
-  TNS_JSON_TYPE_NUMBER_LENGTH_UINT8: 0x34,
-  TNS_JSON_TYPE_BINARY_DOUBLE: 0x36,
-  TNS_JSON_TYPE_STRING_LENGTH_UINT16: 0x37,
-  TNS_JSON_TYPE_STRING_LENGTH_UINT32: 0x38,
-  TNS_JSON_TYPE_TIMESTAMP: 0x39,
-  TNS_JSON_TYPE_BINARY_LENGTH_UINT16: 0x3a,
-  TNS_JSON_TYPE_BINARY_LENGTH_UINT32: 0x3b,
-  TNS_JSON_TYPE_DATE: 0x3c,
-  TNS_JSON_TYPE_INTERVAL_YM: 0x3d,
-  TNS_JSON_TYPE_INTERVAL_DS: 0x3e,
-  TNS_JSON_TYPE_TIMESTAMP_TZ: 0x7c,
-  TNS_JSON_TYPE_TIMESTAMP7: 0x7d,
-  TNS_JSON_TYPE_BINARY_FLOAT: 0x7f,
-  TNS_JSON_TYPE_OBJECT: 0x84,
-  TNS_JSON_TYPE_ARRAY: 0xc0,
 
   // end-to-end metrics
   TNS_END_TO_END_ACTION: 0x0010,
@@ -608,7 +574,8 @@ module.exports = {
   TNS_CCAP_TTC3: 37,
   TNS_CCAP_TTC4: 40,
   TNS_CCAP_LOB2: 42,
-  TNS_CCAP_MAX: 45,
+  TNS_CCAP_TTC5: 44,
+  TNS_CCAP_MAX: 51,
 
   // compile time capability values
   TNS_CCAP_SQL_VERSION_MAX: 6,
@@ -630,7 +597,8 @@ module.exports = {
   TNS_CCAP_FIELD_VERSION_23_1_EXT_4: 21,
   TNS_CCAP_FIELD_VERSION_23_1_EXT_5: 22,
   TNS_CCAP_FIELD_VERSION_23_1_EXT_6: 23,
-  TNS_CCAP_FIELD_VERSION_MAX: 23,
+  TNS_CCAP_FIELD_VERSION_23_4: 24,
+  TNS_CCAP_FIELD_VERSION_MAX: 24,
   TNS_CCAP_O5LOGON: 8,
   TNS_CCAP_O5LOGON_NP: 2,
   TNS_CCAP_O7LOGON: 32,
@@ -660,6 +628,7 @@ module.exports = {
   TNS_CCAP_CLIENT_FN_MAX: 12,
   TNS_CCAP_LOB2_QUASI: 0x01,
   TNS_CCAP_LOB2_2GB_PREFETCH: 0x04,
+  TNS_CCAP_VECTOR_SUPPORT: 0x08,
 
   // runtime capability indices
   TNS_RCAP_COMPAT: 0,
@@ -680,28 +649,20 @@ module.exports = {
 
   // UDS flags
   TNS_UDS_FLAGS_IS_JSON: 0x00000100,
+  TNS_UDS_FLAGS_IS_OSON: 0x00000800,
 
   // other constants
-  TNS_MAX_SHORT_LENGTH: 252,
   TNS_ESCAPE_CHAR: 253,
-  TNS_LONG_LENGTH_INDICATOR: 254,
-  TNS_NULL_LENGTH_INDICATOR: 255,
+  TNS_LONG_LENGTH_INDICATOR: dataHandlerConstants.TNS_LONG_LENGTH_INDICATOR,
+  TNS_NULL_LENGTH_INDICATOR: dataHandlerConstants.TNS_NULL_LENGTH_INDICATOR,
   TNS_MAX_ROWID_LENGTH: 18,
-  TNS_DURATION_MID: 0x80000000,
-  TNS_DURATION_OFFSET: 60,
   TNS_DURATION_SESSION: 10,
   TNS_MAX_LONG_LENGTH: 0x7fffffff,
   TNS_SDU: 8192,
   TNS_TDU: 65535,
   TNS_TXN_IN_PROGRESS: 0x00000002,
   TNS_MAX_CONNECT_DATA: 230,
-  TNS_CHUNK_SIZE: 32767,
   TNS_MAX_UROWID_LENGTH: 3950,
-  TNS_HAS_REGION_ID: 0x80,
-
-  // timezone offsets
-  TZ_HOUR_OFFSET: 20,
-  TZ_MINUTE_OFFSET: 60,
 
   // drcp release mode
   DRCP_DEAUTHENTICATE: 0x00000002,
@@ -742,6 +703,10 @@ module.exports = {
   TNS_OBJ_TDS_TYPE_BLOB: 30,
   TNS_OBJ_TDS_TYPE_TIMESTAMP_LTZ: 33,
   TNS_OBJ_TDS_TYPE_BINARY_FLOAT: 37,
+  TNS_OBJ_TDS_TYPE_START_EMBED_ADT: 39,
+  TNS_OBJ_TDS_TYPE_END_EMBED_ADT: 40,
+  TNS_OBJ_TDS_TYPE_SUBTYPE_MARKER: 43,
+  TNS_OBJ_TDS_TYPE_EMBED_ADT_INFO: 44,
   TNS_OBJ_TDS_TYPE_BINARY_DOUBLE: 45,
 
   // xml type constants
@@ -760,11 +725,14 @@ module.exports = {
   // warnings
   TNS_WARN_COMPILATION_CREATE: 0x20,
 
+  // vector constants
+  TNS_VECTOR_MAX_LENGTH: 1048576,
+  VECTOR_FORMAT_FLEX: 0,
+  VECTOR_META_FLAG_FLEXIBLE_DIM: 1,
+
   // other constants
   PACKET_HEADER_SIZE: 8,
   NUMBER_AS_TEXT_CHARS: 172,
-  NUMBER_MAX_DIGITS: 40,
-  BUFFER_CHUNK_SIZE: 65536,
   CHUNKED_BYTES_CHUNK_SIZE: 65536,
 
   TNS_BASE64_ALPHABET_ARRAY: Buffer.from('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'),