oracledb 6.7.2 → 6.8.0

package/lib/impl/datahandlers/vector.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2024, Oracle and/or its affiliates.
+// Copyright (c) 2024, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -30,6 +30,7 @@ const { BaseBuffer, GrowableBuffer } = require('./buffer.js');
 const { Buffer } = require('buffer');
 const constants = require("./constants.js");
 const errors = require("../../errors.js");
+const types = require("../../types.js");
 
 /**
  * Class used for decoding
@@ -50,68 +51,83 @@ class VectorDecoder extends BaseBuffer {
       errors.throwErr(errors.ERR_UNEXPECTED_DATA,
         Buffer.from([magicByte]).toString('hex'));
     const version = this.readUInt8();
-    if (version > constants.TNS_VECTOR_VERSION_WITH_BINARY)
+    if (version > constants.TNS_VECTOR_VERSION_WITH_SPARSE)
       errors.throwErr(errors.ERR_VECTOR_VERSION_NOT_SUPPORTED, version);
     const flags = this.readUInt16BE();
     const vectorFormat = this.readUInt8();
     let numElements = this.readUInt32BE();
-    let elementSize, result;
+    let elementSize, value, sparseValue;
+
+    // For binary vector, NORM will never be present but space for NORM is reserved to keep
+    // same header lengh across the different vector formats.
+    if (vectorFormat === constants.VECTOR_FORMAT_BINARY || flags & constants.TNS_VECTOR_FLAG_NORM)
+      this.skipBytes(8);
+
+    let sparseFormat;
+    if (flags & constants.TNS_VECTOR_FLAG_SPARSE) {
+      sparseFormat = true;
+      sparseValue = {};
+      sparseValue.numDimensions = numElements; // vector dimensions.
+      numElements = this.readUInt16BE(); // actual elements.
+      sparseValue.indices = new Uint32Array(numElements);
+      for (let i = 0; i < numElements; i++) {
+        sparseValue.indices[i] = this.readUInt32BE();
+      }
+    }
+
     if (vectorFormat === constants.VECTOR_FORMAT_FLOAT32) {
       elementSize = 4;
-      result = new Float32Array(numElements);
+      value = new Float32Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_FLOAT64) {
       elementSize = 8;
-      result = new Float64Array(numElements);
+      value = new Float64Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_INT8) {
       elementSize = 1;
-      result = new Int8Array(numElements);
+      value = new Int8Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_BINARY) {
       elementSize = 1;
       // The number of dimensions are assumed to be multiple of 8.
       numElements = numElements / 8;
-      result = new Uint8Array(numElements);
+      value = new Uint8Array(numElements);
     } else {
       errors.throwErr(errors.ERR_VECTOR_FORMAT_NOT_SUPPORTED, vectorFormat);
     }
 
-    // For binary vector, NORM will never be present but space for NORM is reserved to keep
-    // same header lengh across the different vector formats.
-    if (vectorFormat === constants.VECTOR_FORMAT_BINARY || flags & constants.TNS_VECTOR_FLAG_NORM)
-      this.skipBytes(8);
+    if (sparseFormat) {
+      sparseValue.values = value;
+    }
 
     // parse data
+    let res;
     for (let i = 0; i < numElements; i++) {
       const buf = this.readBytes(elementSize);
       if (vectorFormat === constants.VECTOR_FORMAT_FLOAT32) {
-        result[i] = this.parseBinaryFloat(buf);
+        res = this.parseBinaryFloat(buf);
       } else if (vectorFormat === constants.VECTOR_FORMAT_FLOAT64)  {
-        result[i] = this.parseBinaryDouble(buf);
+        res = this.parseBinaryDouble(buf);
       } else {
-        result[i] = buf[0];
+        res = buf[0];
       }
+      value[i] = res;
     }
 
-    return result;
+    return sparseFormat ? types.SparseVector.create(sparseValue) : value;
   }
 
 }
 
 class VectorEncoder extends GrowableBuffer {
 
-  //---------------------------------------------------------------------------
-  // encode()
-  //
-  // Encodes the value as OSON and returns a buffer containing the OSON bytes.
-  //---------------------------------------------------------------------------
-  encode(value) {
-
-    // determine some basic information about the vector
-    let vectorFormat = constants.VECTOR_FORMAT_FLOAT32;
-    let writeFn = this.writeBinaryFloat.bind(this);
+  // Writes Header from value.
+  // It returns function to serialize the value.
+  // sparseVal is provided for SparseVector.
+  _updateVectorHeader(value, sparseVal) {
+    let flags = constants.TNS_VECTOR_FLAG_NORMSRC
+    | constants.TNS_VECTOR_FLAG_NORM; // NORM is present and reserve space.
     let numElements = value.length;
     let vectorVersion = constants.TNS_VECTOR_VERSION_BASE;
-    let flags = constants.TNS_VECTOR_FLAG_NORMSRC
-      | constants.TNS_VECTOR_FLAG_NORM; // NORM is present and reserve space.
+    let vectorFormat = constants.VECTOR_FORMAT_FLOAT32;
+    let writeFn = this.writeBinaryFloat.bind(this);
 
     if (Array.isArray(value) || value instanceof Float64Array) {
       vectorFormat = constants.VECTOR_FORMAT_FLOAT64;
@@ -127,6 +143,11 @@ class VectorEncoder extends GrowableBuffer {
       flags = constants.TNS_VECTOR_FLAG_NORMSRC; // only space is reserved.
       writeFn = this.writeUInt8.bind(this);
     }
+    if (sparseVal && sparseVal instanceof types.SparseVector) {
+      vectorVersion = constants.TNS_VECTOR_VERSION_WITH_SPARSE;
+      numElements = sparseVal.numDimensions;
+      flags |= constants.TNS_VECTOR_FLAG_SPARSE;
+    }
 
     // write header
     this.writeUInt8(constants.TNS_VECTOR_MAGIC_BYTE);
@@ -135,6 +156,30 @@ class VectorEncoder extends GrowableBuffer {
     this.writeUInt8(vectorFormat);
     this.writeUInt32BE(numElements);
     this.reserveBytes(8);
+    return writeFn;
+  }
+
+  //---------------------------------------------------------------------------
+  // encode()
+  //
+  // Encodes the value as OSON and returns a buffer containing the OSON bytes.
+  //---------------------------------------------------------------------------
+  encode(value) {
+    let writeFn;
+
+    if (value instanceof types.SparseVector) {
+      writeFn = this._updateVectorHeader(value.values, value);
+      const numElements = value.indices.length;
+      this.writeUInt16BE(numElements);
+
+      // Write indices
+      value.indices.forEach((element) => {
+        this.writeUInt32BE(element);
+      });
+      value = value.values;
+    } else {
+      writeFn = this._updateVectorHeader(value);
+    }
 
     // write data
     value.forEach((element) => {

package/lib/oracledb.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2015, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2015, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -67,6 +67,7 @@ const SodaOperation = require('./sodaOperation.js');
 const poolCache = {};
 const tempUsedPoolAliases = {};
 const defaultPoolAlias = 'default';
+const registeredHooks = [];
 let configProviderCache;
 
 // save arguments for call to initOracleClient()
@@ -188,6 +189,18 @@ async function _verifyOptions(options, inCreatePool) {
       "walletLocation");
     outOptions.walletLocation = options.walletLocation;
   }
+  if (options.networkCompression !== undefined) {
+    errors.assertParamPropValue(typeof options.networkCompression === 'boolean', 1,
+      "networkCompression");
+    outOptions.networkCompression = options.networkCompression;
+    outOptions.networkCompressionLevels = [];
+    outOptions.networkCompressionLevels.push('high');
+  }
+
+  if (options.networkCompressionThreshold !== undefined) {
+    errors.assertParamPropValue(Number.isInteger(options.networkCompressionThreshold), 1, "networkCompressionThreshold");
+    outOptions.networkCompressionThreshold = options.networkCompressionThreshold;
+  }
 
   //wallet content must be a string
   if (options.walletContent !== undefined) {
@@ -362,6 +375,13 @@ async function _verifyOptions(options, inCreatePool) {
     outOptions.terminal = options.terminal;
   }
 
+  // useSNI must be a boolean
+  if (options.useSNI !== undefined) {
+    errors.assertParamPropValue(typeof options.useSNI === 'boolean', 1,
+      "useSNI");
+    outOptions.useSNI = options.useSNI;
+  }
+
   // check pool specific options
   if (inCreatePool) {
 
@@ -513,9 +533,13 @@ async function _verifyOptions(options, inCreatePool) {
     if (typeof options.accessToken === 'function') {
       outOptions.accessTokenFn = options.accessToken;
       outOptions.accessTokenConfig = options.accessTokenConfig;
-      accessToken = await options.accessToken(false, options.accessTokenConfig);
-      if (!nodbUtil.isTokenValid(accessToken)) {
-        accessToken = await options.accessToken(true, options.accessTokenConfig);
+      try {
+        accessToken = await options.accessToken(false, outOptions.accessTokenConfig);
+        if (!nodbUtil.isTokenValid(accessToken)) {
+          accessToken = await options.accessToken(true, outOptions.accessTokenConfig);
+        }
+      } catch (error) {
+        errors.throwWrapErr(error, errors.ERR_ACCESS_TOKEN);
       }
     } else {
       accessToken = options.accessToken;
@@ -568,6 +592,18 @@ async function createPool(options) {
   // check arguments
   errors.assertArgCount(arguments, 1, 1);
   errors.assertParamValue(nodbUtil.isObject(options), 1);
+
+  // this will invoke hookFn() written in application side.
+  // for token based auth it will generate access token and save it in options.
+  for (const hookFn of registeredHooks) {
+    // eslint-disable-next-line no-useless-catch
+    try {
+      await hookFn(options);
+    } catch (error) {
+      errors.throwWrapErr(error, errors.ERR_CALLOUT_FN);
+    }
+  }
+
   options = await _verifyOptions(options, true);
   const sessionCallback = options.sessionCallback;
   if (typeof sessionCallback === 'function')
@@ -700,6 +736,17 @@ async function getConnection(a1) {
     return await pool.getConnection(options);
   }
 
+  // this will invoke hookFn() written in application side.
+  // for token based auth it will generate access token and save it in options.
+  for (const hookFn of registeredHooks) {
+    // eslint-disable-next-line no-useless-catch
+    try {
+      await hookFn(options);
+    } catch (error) {
+      errors.throwWrapErr(error, errors.ERR_CALLOUT_FN);
+    }
+  }
+
   // create a standalone connection
   options = await _verifyOptions(options, false);
   settings.addToOptions(options,
@@ -998,6 +1045,18 @@ async function startup(a1, a2) {
   await conn.close();
 }
 
+//-----------------------------------------------------------------------------
+// registerProcessConfigurationHook()
+//
+// Registers extension modules and registered modules will be called and
+// executed during pool and standalone connection creation.
+//-----------------------------------------------------------------------------
+function registerProcessConfigurationHook(fn) {
+  errors.assertArgCount(arguments, 1, 1);
+  errors.assertParamValue(typeof fn === 'function', 1);
+  registeredHooks.push(fn);
+}
+
 // module exports
 module.exports = {
 
@@ -1018,6 +1077,9 @@ module.exports = {
   SodaDocCursor,
   SodaDocument,
   SodaOperation,
+  SparseVector: types.SparseVector,
+  IntervalYM: types.IntervalYM,
+  IntervalDS: types.IntervalDS,
 
   // top-level functions
   getConnection: nodbUtil.callbackify(nodbUtil.wrapFn(getConnection)),
@@ -1025,6 +1087,7 @@ module.exports = {
   getNetworkServiceNames: nodbUtil.callbackify(nodbUtil.wrapFn(getNetworkServiceNames)),
   getPool,
   initOracleClient,
+  registerProcessConfigurationHook,
   shutdown: nodbUtil.callbackify(nodbUtil.wrapFn(shutdown)),
   startup: nodbUtil.callbackify(nodbUtil.wrapFn(startup)),
 
@@ -1269,6 +1332,10 @@ module.exports = {
     return settings.fetchTypeHandler;
   },
 
+  get dbObjectTypeHandler() {
+    return settings.dbObjectTypeHandler;
+  },
+
   get lobPrefetchSize() {
     return settings.lobPrefetchSize;
   },
@@ -1329,6 +1396,7 @@ module.exports = {
     return settings.configProviderCacheTimeout;
   },
 
+
   get thin() {
     return settings.thin;
   },
@@ -1413,6 +1481,13 @@ module.exports = {
     settings.fetchTypeHandler = value;
   },
 
+  set dbObjectTypeHandler(value) {
+    if (value !== undefined) {
+      errors.assertPropValue(typeof value === 'function', "dbObjectTypeHandler");
+    }
+    settings.dbObjectTypeHandler = value;
+  },
+
   set lobPrefetchSize(value) {
     errors.assertPropValue(Number.isInteger(value) && value >= 0,
       "lobPrefetchSize");
@@ -1509,6 +1584,7 @@ module.exports = {
     errors.assertPropValue(typeof value === 'string', "terminal");
     settings.terminal = value;
   },
+
   set configProviderCacheTimeout(value) {
     errors.assertPropValue(Number.isInteger(value) && value >= 0,
       "configProviderCacheTimeout");

package/lib/settings.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -64,7 +64,11 @@ class Settings {
     this.thinDriverInitialized = false;
     this.createFetchTypeMap(this.fetchAsString, this.fetchAsBuffer);
     this.fetchTypeHandler = undefined;
+    this.dbObjectTypeHandler = undefined;
     this._JsonId = types.JsonId;
+    this._SparseVector = types.SparseVector;
+    this._IntervalYM = types.IntervalYM;
+    this._IntervalDS = types.IntervalDS;
   }
 
   //---------------------------------------------------------------------------

package/lib/thin/connection.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -715,6 +715,9 @@ class ThinConnectionImpl extends ConnectionImpl {
     await this._protocol.breakMessage();
   }
 
+  isCompressionEnabled() {
+    return this.nscon.compressionEnabled;
+  }
   isHealthy() {
     try {
       if (this.nscon.recvInbandNotif() === 0)
@@ -839,7 +842,7 @@ class ThinConnectionImpl extends ConnectionImpl {
         this.nscon.endOfRequestSupport = endOfRequestSupport;
         await this._protocol._processMessage(authMessage);
       }
-      if (!params.token) { // non-token Authentication
+      if (!params.externalAuth) { // non-token Authentication
         await this._protocol._processMessage(authMessage); // OAUTH
       }
     } catch (err) {
@@ -1312,6 +1315,14 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.maxOpenCursors;
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the maximum length of identifiers supported by the database to
+  // which this connection has been established.
+  //---------------------------------------------------------------------------
+  getMaxIdentifierLength() {
+    return this.maxIdentifierLength;
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database service name associated with the connection.
   //---------------------------------------------------------------------------

package/lib/thin/dbObject.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -368,10 +368,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
     let isNull, obj, value;
     switch (type) {
       case types.DB_TYPE_NUMBER:
-        value = buf.readOracleNumber();
-        if (value !== null)
-          value = parseFloat(value);
-        return value;
+        return buf.readOracleNumber();
       case types.DB_TYPE_BINARY_INTEGER:
         return buf.readBinaryInteger();
       case types.DB_TYPE_VARCHAR:
@@ -429,7 +426,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
       if (objType.maxNumElements > 0 &&
           this.unpackedArray.length >= objType.maxNumElements) {
         errors.throwErr(errors.ERR_INVALID_COLL_INDEX_SET,
-          this.unpackedArray.length, 0, objType.maxNumElements);
+          this.unpackedArray.length, 0, objType.maxNumElements - 1);
       }
       this.unpackedArray.push(value);
     } else {
@@ -446,6 +443,26 @@ class ThinDbObjectImpl extends DbObjectImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // copy
+  //
+  // Creates and returns a copy of the ThinDBObjectImpl object. The copy is
+  // independent of the original object that was copied.
+  //---------------------------------------------------------------------------
+  copy() {
+    // We send in marshalled data of the original object to the constructor
+    // when we create the object copy
+    const newObjImpl = new ThinDbObjectImpl(this._objType, this._getPackedData());
+
+    // Set other properties
+    newObjImpl.toid = this.toid;
+    newObjImpl.flags = this.flags;
+    newObjImpl.imageFlags = this.imageFlags;
+    newObjImpl.imageVersion = this.imageVersion;
+
+    return newObjImpl;
+  }
+
   //---------------------------------------------------------------------------
   // deleteElement()
   //
@@ -459,7 +476,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
       }
       this.unpackedArray.splice(index, 1);
     } else {
-      this._unpackedAssocKeys = undefined;
+      this.unpackedAssocKeys = undefined;
       this.unpackedAssocArray.delete(index);
     }
   }
@@ -610,6 +627,20 @@ class ThinDbObjectImpl extends DbObjectImpl {
     return result;
   }
 
+  //---------------------------------------------------------------------------
+  // getLength
+  //
+  // Gets the size of the database object if it is a collection. Else returns
+  // undefined.
+  //---------------------------------------------------------------------------
+  getLength() {
+    this._ensureUnpacked();
+    if (this.unpackedArray)
+      return this.unpackedArray.length;
+    if (this.unpackedAssocArray)
+      return this.unpackedAssocArray.size;
+  }
+
   //---------------------------------------------------------------------------
   // hasElement()
   //

package/lib/thin/pool.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -197,7 +197,11 @@ class ThinPoolImpl extends PoolImpl {
         protocolUtil.getDeobfuscatedValue(this._token, this._obfuscatedToken);
       if (util.isTokenExpired(clonedAttrs.token)) {
         if (typeof this._accessTokenFn === 'function') {
-          accessToken = await this._accessTokenFn(true, this._accessTokenConfig);
+          try {
+            accessToken = await this._accessTokenFn(true, this._accessTokenConfig);
+          } catch (error) {
+            errors.throwWrapErr(error, errors.ERR_ACCESS_TOKEN);
+          }
           if (typeof accessToken === 'string') {
             clonedAttrs.token = accessToken;
             if (util.isTokenExpired(clonedAttrs.token)) {
@@ -211,7 +215,7 @@ class ThinPoolImpl extends PoolImpl {
             }
           } else if (typeof accessToken === 'object') {
             clonedAttrs.token = accessToken.token;
-            clonedAttrs.privateKey = accessToken.privateKey;
+            clonedAttrs.privateKey = util.denormalizePrivateKey(accessToken.privateKey);
             if (util.isTokenExpired(clonedAttrs.token)) {
               // IAM token is expired
               errors.throwErr(errors.ERR_TOKEN_HAS_EXPIRED);

package/lib/thin/protocol/capabilities.js

@@ -119,7 +119,7 @@ class Capabilities {
     this.compileCaps[constants.TNS_CCAP_TTC5] =
       constants.TNS_CCAP_VECTOR_SUPPORT;
     this.compileCaps[constants.TNS_CCAP_VECTOR_FEATURES] =
-      constants.TNS_CCAP_VECTOR_FEATURE_BINARY;
+      constants.TNS_CCAP_VECTOR_FEATURE_BINARY | constants.TNS_CCAP_VECTOR_FEATURE_SPARSE;
   }
 
   initRuntimeCaps() {

package/lib/thin/protocol/constants.js

@@ -644,6 +644,7 @@ module.exports = {
   TNS_CCAP_CTB_IMPLICIT_POOL: 0x08,
   TNS_CCAP_VECTOR_SUPPORT: 0x08,
   TNS_CCAP_VECTOR_FEATURE_BINARY: 0x01,
+  TNS_CCAP_VECTOR_FEATURE_SPARSE: 0x02,
 
   // runtime capability indices
   TNS_RCAP_COMPAT: 0,
@@ -767,6 +768,7 @@ module.exports = {
   TNS_VECTOR_MAX_LENGTH: 1048576,
   VECTOR_FORMAT_FLEX: 0,
   VECTOR_META_FLAG_FLEXIBLE_DIM: 1,
+  VECTOR_META_FLAG_SPARSE: 2,
 
   // other constants
   PACKET_HEADER_SIZE: 8,

package/lib/thin/protocol/messages/auth.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -94,8 +94,10 @@ class AuthMessage extends Message {
       this.userByteLen = 0;
     }
     this.token = config.token;
-    if (this.token)
+    if (config.externalAuth) {
       this.functionCode = constants.TNS_FUNC_AUTH_PHASE_TWO;
+      this.externalAuth = true;
+    }
     this.privateKey = config.privateKey;
     if (this.privateKey) {
       this.privateKey = util.normalizePrivateKey(this.privateKey);
@@ -107,6 +109,11 @@ class AuthMessage extends Message {
     this.osUser = config.osUser;
     this.program = config.program;
     this.terminal = config.terminal;
+    if (config.edition) {
+      this.edition = config.edition;
+    } else if (process.env.ORA_EDITION) {
+      this.edition = process.env.ORA_EDITION;
+    }
     this.setAuthMode(config);
   }
 
@@ -141,7 +148,7 @@ class AuthMessage extends Message {
     if (this.newPassword) {
       this.authMode |= constants.TNS_AUTH_MODE_CHANGE_PASSWORD;
     }
-    if (!this.token) {
+    if (!config.externalAuth) {
       this.authMode |= constants.TNS_AUTH_MODE_WITH_PASSWORD;
     }
   }
@@ -199,8 +206,10 @@ class AuthMessage extends Message {
         numPairs = 2;
       } else {
         numPairs = 4;
-        if (this.token) {
-          numPairs += 1;
+        if (this.externalAuth) {
+          numPairs += 5;
+          if (this.token)
+            numPairs += 1;
         } else {
           numPairs += 2;
           if (this.verifierType === constants.TNS_VERIFIER_TYPE_11G_1 ||
@@ -235,6 +244,9 @@ class AuthMessage extends Message {
           this.encryptedJDWPData = ED.getEncryptedJSWPData(this.sessionKey, this.conn.jdwpData);
           numPairs += 1;
         }
+        if (this.edition) {
+          numPairs += 1;
+        }
         if (this.schemaUser.length !== 0) {
           numPairs += 1;
         }
@@ -246,10 +258,17 @@ class AuthMessage extends Message {
       buf.writeUInt8(1);
       if (this.userByteLen > 0)
         buf.writeBytesWithLength(Buffer.from(this.username));
+      if (this.externalAuth) {
+        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", this.osUser ?? cInfo.userName);
+      }
       if (this.token) {
         buf.writeKeyValue("AUTH_TOKEN", this.token);
       } else {
-        if (!this.changePassword) {
+        if (!this.changePassword && !this.externalAuth) {
           buf.writeKeyValue("AUTH_SESSKEY", this.sessionKey, 1);
           if (!verifier11G) {
             buf.writeKeyValue("AUTH_PBKDF2_SPEEDY_KEY", this.speedyKey);
@@ -297,6 +316,9 @@ class AuthMessage extends Message {
       if (this.conn.jdwpData) {
         buf.writeKeyValue("AUTH_ORA_DEBUG_JDWP", this.encryptedJDWPData);
       }
+      if (this.edition) {
+        buf.writeKeyValue("AUTH_ORA_EDITION", this.edition);
+      }
 
     }
   }
@@ -331,6 +353,7 @@ class AuthMessage extends Message {
       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'];
+      this.conn.maxIdentifierLength = Number(this.sessionData['AUTH_MAX_IDEN_LENGTH'] || 30);
       const fullVersionNum = Number(this.sessionData['AUTH_VERSION_NO']);
       const versionNum = (fullVersionNum >> 24) & 0xFF;
       this.conn.warning = this.warning;

package/lib/thin/protocol/messages/fastAuth.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -70,6 +70,11 @@ class FastAuthMessage extends Message {
     } else {
       this.authMessage.processMessage(buf, messageType);
       this.endOfResponse = this.authMessage.endOfResponse;
+      if (this.authMessage.errorOccurred) {
+        // Capture the Error returned in TNS_MSG_TYPE_ERROR processing.
+        this.errorOccurred = this.authMessage.errorOccurred;
+        this.errorInfo = this.authMessage.errorInfo;
+      }
     }
   }