oracledb 6.9.0 → 7.0.0

package/lib/impl/sodaDocument.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -31,21 +31,12 @@ const errors = require('../errors.js');
 class SodaDocumentImpl {
 
   //---------------------------------------------------------------------------
-  // getContentAsBuffer()
+  // getContent()
   //
-  // Returns the document content as a Buffer object.
+  // Returns the document content.
   //---------------------------------------------------------------------------
-  getContentAsBuffer() {
-    errors.throwNotImplemented("getting doc content as a buffer");
-  }
-
-  //---------------------------------------------------------------------------
-  // getContentAsString()
-  //
-  // Returns the document content as a string.
-  //---------------------------------------------------------------------------
-  getContentAsString() {
-    errors.throwNotImplemented("getting doc content as a string");
+  getContent() {
+    errors.throwNotImplemented("getting doc content");
   }
 
   //---------------------------------------------------------------------------

package/lib/lob.js

@@ -117,12 +117,6 @@ class Lob extends Duplex {
   // called to associate a LOB implementation with this user facing object
   _setup(lobImpl, autoCloseLob) {
     this._impl = lobImpl;
-    // chunk size is not defined for BFILE LOBs
-    if (this.type !== types.DB_TYPE_BFILE) {
-      this._chunkSize = lobImpl.getChunkSize();
-    }
-    this._pieceSize = lobImpl.getPieceSize();
-    this._length = lobImpl.getLength();
     this._type = lobImpl.getType();
     if (typeof this._type === 'number') {
       this._type = types.getTypeByNum(this._type);
@@ -170,10 +164,11 @@ class Lob extends Duplex {
   // chunkSize
   //
   // Property for the chunk size of the LOB.
+  // returns undefined if the LOB is closed.
   //---------------------------------------------------------------------------
   get chunkSize() {
     this._checkNotBfile();
-    return this._chunkSize;
+    return this._impl?.getChunkSize();
   }
 
   //---------------------------------------------------------------------------
@@ -218,12 +213,12 @@ class Lob extends Duplex {
     if (offset === undefined) {
       offset = 1;
     } else {
-      errors.assertParamValue(Number.isInteger(offset) && offset > 0, 1);
+      errors.assertParamValue(Number.isSafeInteger(offset) && offset > 0, 1);
     }
     if (amount === undefined) {
       amount = 0;
     } else {
-      errors.assertParamValue(Number.isInteger(amount) && amount > 0, 2);
+      errors.assertParamValue(Number.isSafeInteger(amount) && amount > 0, 2);
     }
     errors.assert(this._impl, errors.ERR_INVALID_LOB);
     return await this._impl.getData(offset, amount);
@@ -257,6 +252,22 @@ class Lob extends Duplex {
     this._impl.setDirFileName(a1);
   }
 
+  //---------------------------------------------------------------------------
+  // trim()
+  //  trims non-BFILE LOBs to a smaller size as specified by the parameter.
+  //---------------------------------------------------------------------------
+  async trim(newSize) {
+    this._checkNotBfile();
+    errors.assertArgCount(arguments, 0, 1);
+    if (newSize === undefined) {
+      newSize = 0;
+    } else {
+      errors.assertParamValue(Number.isInteger(newSize) && newSize >= 0 &&
+        newSize < 2 ** 32, 1);
+    }
+    await this._impl.trim(newSize);
+  }
+
   //---------------------------------------------------------------------------
   // fileExists
   //
@@ -271,9 +282,10 @@ class Lob extends Duplex {
   // length
   //
   // Property for the length of the LOB.
+  // returns undefined if the LOB is closed.
   //---------------------------------------------------------------------------
   get length() {
-    return this._length;
+    return this._impl?.getLength();
   }
 
   //---------------------------------------------------------------------------
@@ -281,16 +293,16 @@ class Lob extends Duplex {
   //
   // Property for the size to use for each piece that is transferred when
   // reading from the LOB.
+  // returns undefined if the LOB is closed.
   //---------------------------------------------------------------------------
   get pieceSize() {
-    return this._pieceSize;
+    return this._impl?.getPieceSize();
   }
 
   set pieceSize(value) {
-    errors.assertPropValue(Number.isInteger(value) && value >= 0, "pieceSize");
+    errors.assertPropValue(Number.isSafeInteger(value) && value >= 0, "pieceSize");
     errors.assert(this._impl, errors.ERR_INVALID_LOB);
     this._impl.setPieceSize(value);
-    this._pieceSize = value;
   }
 
   //---------------------------------------------------------------------------
@@ -307,7 +319,8 @@ class Lob extends Duplex {
 nodbUtil.wrapFns(Lob.prototype, errors.ERR_BUSY_LOB,
   "close",
   "fileExists",
-  "getData");
+  "getData",
+  "trim");
 Lob.prototype._serializedRead = nodbUtil.wrapFn(Lob.prototype._readData, true);
 Lob.prototype._serializedWrite =
   nodbUtil.wrapFn(Lob.prototype._writeData, true);

package/lib/obfuscation.js

@@ -0,0 +1,97 @@
+// Copyright (c) 2026, Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
+
+'use strict';
+
+const { Buffer } = require('buffer');
+const crypto = require('crypto');
+
+class ObfuscatedValue {
+
+  constructor(value, options = {}) {
+    this._valueBuffer = null;
+    this._maskBuffer = null;
+    this._defaultReturnBuffer =
+      options.returnBuffer ??
+      (value !== undefined && value !== null && Buffer.isBuffer(value));
+    if (value !== undefined && value !== null) {
+      this.set(value, options);
+    }
+  }
+
+  set(value, options = {}) {
+    if (value === undefined || value === null) {
+      this.clear();
+      return;
+    }
+    const returnBuffer = options.returnBuffer ??
+      (Buffer.isBuffer(value) || this._defaultReturnBuffer === true);
+    const source = Buffer.isBuffer(value)
+      ? Buffer.from(value)
+      : Buffer.from(String(value));
+    const mask = crypto.randomBytes(source.length);
+    for (let i = 0; i < source.length; i++) {
+      source[i] = source[i] ^ mask[i];
+    }
+    this.clear();
+    this._valueBuffer = source;
+    this._maskBuffer = mask;
+    this._defaultReturnBuffer = returnBuffer;
+  }
+
+  get(options = {}) {
+    if (!this._valueBuffer || !this._maskBuffer) {
+      return null;
+    }
+    const returnBuffer = options.returnBuffer ??
+      (this._defaultReturnBuffer === true);
+    const result = Buffer.allocUnsafe(this._valueBuffer.length);
+    for (let i = 0; i < this._valueBuffer.length; i++) {
+      result[i] = this._valueBuffer[i] ^ this._maskBuffer[i];
+    }
+    if (returnBuffer) {
+      return result;
+    }
+    const text = result.toString();
+    result.fill(0);
+    return text;
+  }
+
+  clear() {
+    if (this._valueBuffer) {
+      this._valueBuffer.fill(0);
+      this._valueBuffer = null;
+    }
+    if (this._maskBuffer) {
+      this._maskBuffer.fill(0);
+      this._maskBuffer = null;
+    }
+  }
+}
+
+module.exports = {
+  ObfuscatedValue
+};

package/lib/oracledb.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2015, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2015, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -28,11 +28,14 @@
 
 const constants = require('./constants.js');
 const nodbUtil = require('./util.js');
+const { ObfuscatedValue } = require('./obfuscation.js');
 const errors = require('./errors.js');
 const types = require('./types.js');
 const impl = require('./impl');
 const process = require('process');
 const util = require('util');
+const parser = require('./parser.js');
+const parserHelpers = require('./impl/parserHelpers.js');
 
 // This version of node-oracledb works with Node.js 14.17 or later.
 // Note: the checked version is the minimum required for Node-API
@@ -47,7 +50,6 @@ errors.assert(vs[0] > 14 || (vs[0] === 14 && vs[1] >= 17),
 const AqDeqOptions = require('./aqDeqOptions.js');
 const AqEnqOptions = require('./aqEnqOptions.js');
 const AqMessage = require('./aqMessage.js');
-const protocolUtil = require('./thin/protocol/utils.js');
 const AqQueue = require('./aqQueue.js');
 const future = require('./future.js');
 const traceHandler = require('./traceHandler.js');
@@ -57,12 +59,14 @@ const Lob = require('./lob.js');
 const Pool = require('./pool.js');
 const PoolStatistics = require('./poolStatistics.js');
 const ResultSet = require('./resultset.js');
+const Pipeline = require('./pipeline.js');
 const settings = require('./settings.js');
 const SodaDatabase = require('./sodaDatabase.js');
 const SodaCollection = require('./sodaCollection.js');
 const SodaDocCursor = require('./sodaDocCursor.js');
 const SodaDocument = require('./sodaDocument.js');
 const SodaOperation = require('./sodaOperation.js');
+const EndUserSecurityContext = require('./endUserSecurityContext.js');
 
 const poolCache = {};
 const tempUsedPoolAliases = {};
@@ -131,6 +135,27 @@ function _initializeThinDriver() {
   require('./thin');
 }
 
+// validate external authentication credentials for token and non-token Authentications
+function _validateExternalAuthCredentials(outOptions, inCreatePool, isTokenAuth = false) {
+  if (!outOptions.externalAuth) {
+    return;
+  }
+  if (outOptions.password !== undefined) {
+    errors.throwErr(isTokenAuth ? errors.ERR_TOKEN_BASED_AUTH
+      : errors.ERR_WRONG_CRED_FOR_EXTAUTH);
+  }
+  if (outOptions.user) {
+    if (inCreatePool && !settings.thin) {
+      // Thick mode currently does not allow proxy users to be specified
+      // during pool creation.
+      errors.throwErr(errors.ERR_WRONG_CRED_FOR_EXTAUTH);
+    } else if (outOptions.user[0] !== '[' || outOptions.user.slice(-1) !== ']') {
+      // username is not enclosed in [].
+      errors.throwErr(errors.ERR_WRONG_USER_FORMAT_EXTAUTH_PROXY);
+    }
+  }
+}
+
 //-----------------------------------------------------------------------------
 // _verifyOptions()
 //
@@ -532,10 +557,7 @@ async function _verifyOptions(options, inCreatePool) {
 
   // check access token
   if (options.accessToken !== undefined) {
-
-    // cannot set username or password for token based authentication
-    errors.assert(outOptions.user === undefined &&
-      outOptions.password === undefined, errors.ERR_TOKEN_BASED_AUTH);
+    _validateExternalAuthCredentials(outOptions, inCreatePool, true);
 
     // homogenous (for pool) and externalAuth (both) must be set
     if (inCreatePool) {
@@ -581,17 +603,7 @@ async function _verifyOptions(options, inCreatePool) {
   // Check external Auth config.
   // Allow Session User enclosed in [] for proxy authentication.
   if (outOptions.token === undefined && outOptions.externalAuth) {
-    if (outOptions.password) {
-      errors.throwErr(errors.ERR_WRONG_CRED_FOR_EXTAUTH);
-    }
-    if (outOptions.user) {
-      if (inCreatePool) {
-        errors.throwErr(errors.ERR_WRONG_CRED_FOR_EXTAUTH);
-      } else if (outOptions.user[0] !== '[' || outOptions.user.slice(-1) !== ']') {
-        // username is not enclosed in [].
-        errors.throwErr(errors.ERR_WRONG_USER_FORMAT_EXTAUTH_PROXY);
-      }
-    }
+    _validateExternalAuthCredentials(outOptions, inCreatePool);
   }
 
   return outOptions;
@@ -613,15 +625,13 @@ async function createPool(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);
     }
   }
-
-  options = await _verifyOptions(options, true);
+  options = await _updateUserOptionsFromConnectString(options, true);
   const sessionCallback = options.sessionCallback;
   if (typeof sessionCallback === 'function')
     delete options.sessionCallback;
@@ -684,6 +694,15 @@ async function createPool(options) {
   pool._impl._connectString = options.connectString;
   pool._impl._user = options.user;
   try {
+    // registers a callback poolEventReg having 'eventName' and 'arguments of the
+    // event' as its arguments. It is passed as part of options while creating impl
+    // pool, so that events emitted in impl pool can access the lib pool instance.
+    // For now, no argument is passed as args, but can be used later for future metrics.
+    options.poolEventReg = ((eventName, ...args) => {
+      if (traceHandler.isEnabled()) {
+        traceHandler.getTraceInstance()?.[eventName](pool, ...args);
+      }
+    });
     await pool._impl.create(options);
   } finally {
     if (poolAlias) {
@@ -756,16 +775,14 @@ async function getConnection(a1) {
   // 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);
+  options = await _updateUserOptionsFromConnectString(options, false);
   settings.addToOptions(options,
     "connectionClass",
     "driverName",
@@ -906,14 +923,11 @@ async function shutdown(a1, a2) {
 }
 
 async function _setConfigParameters(obj, credential, configProvider) {
-  const configObject = {};
   const pmSection = 'njs';
   const params = obj[pmSection];
-  for (const key in params) {
-    const val = params[key];
-    configObject[key] = val;
-  }
+  const configObject = params ? { ...params } : {};
   configObject.connectString = obj.connect_descriptor;
+  configObject.configTTL = obj.config_time_to_live;
   if (!configObject.connectString)
     errors.throwErr(errors.ERR_CONFIG_PROVIDER_FAILED_TO_RETRIEVE_CONFIG, 'connect_descriptor must be set');
 
@@ -947,11 +961,11 @@ async function _retrieveParamValueFromVault(paramObj, credential, configProvider
     console.log("WARNING: Base64 Encoding in a JSON Password should only be used in development environments");
     return Buffer.from(paramObj.value, "base64").toString("utf-8");
   } else if (paramObj.type == "text") {
-    if (configProvider == 'azurevault' || configProvider == 'ocivault') {
+    if (configProvider == 'azurevault' || configProvider == 'ocivault' || configProvider == 'awssecretsmanager') {
       console.log("WARNING: Plain Text in a JSON Password should only be used in development environments");
       return paramObj.value;
     } else
-      errors.throwErr(errors.ERR_CONFIG_PROVIDER_PARAM_TYPE, 'password type text is only allowed in ocivault and azurevault');
+      errors.throwErr(errors.ERR_CONFIG_PROVIDER_PARAM_TYPE, 'password type text is only allowed in ocivault, azurevault and awssecretsmanager');
   } else if (paramObj.type == "azurevault") {
     paramMap.set('azuresecreturl', paramObj.value);
     if (!(configProvider == 'azure' || configProvider == 'azurevault'))
@@ -977,41 +991,47 @@ async function _retrieveParamValueFromVault(paramObj, credential, configProvider
     args.credential = credential;
     args.paramMap = paramMap;
     const vaultReturn = await hookFn(args);
-    const paramValue = vaultReturn[0];
-    return paramValue;
-  }  else {
+    return vaultReturn[0];
+  } else {
     errors.throwErr(errors.ERR_CONFIG_PROVIDER_PARAM_TYPE, 'password/wallet_location');
   }
 }
 //-----------------------------------------------------------------------------
 // _checkConfigProvider()
 //
-// Look for the config provider in the connection string and retreives
+// Look for the config provider in the connection string and retrieves
 // object stored in the config Provider.
 // Returns object based on precedence between input object and the one retrieved
 // from Config Provider.
 //-----------------------------------------------------------------------------
 async function _checkConfigProvider(options) {
   // Time for Cache entries to be deleted in milliseconds
-  const cacheEntriesDuration = settings.configProviderCacheTimeout * 1000;
-  let secondOpts;
+  let cacheEntriesDuration = settings.configProviderCacheTimeout * 1000;
+  let secondOpts, cachedConfigEntry;
   const url = options.connectString || options.connectionString;
   if (!url)
     return options;
 
-  if (configProviderCache && configProviderCache.has(url) && ((Date.now() - configProviderCache.get(url).timeAdded) < cacheEntriesDuration)) {
-    const cacheOpts1 = configProviderCache.get(url).cacheOpts;
-    secondOpts = { ...cacheOpts1};
+  if (configProviderCache && (cachedConfigEntry = configProviderCache.get(url))) {
+    const config = cachedConfigEntry.cacheOpts;
+    if (config.configTTL)
+      cacheEntriesDuration = config.configTTL * 1000;
 
-    //deobfuscate password
-    if (secondOpts.password)
-      secondOpts.password = protocolUtil.getDeobfuscatedValue(secondOpts.password.value, secondOpts.password.obfuscatedValue);
+    if ((Date.now() - cachedConfigEntry.timeAdded) < cacheEntriesDuration) {
+      secondOpts = { ...config};
 
-    //deobfuscate walletContent
-    if (secondOpts.walletContent)
-      secondOpts.walletContent = protocolUtil.getDeobfuscatedValue(secondOpts.walletContent.value, secondOpts.walletContent.obfuscatedValue);
+      //deobfuscate password
+      if (secondOpts.password instanceof ObfuscatedValue) {
+        secondOpts.password = secondOpts.password.get();
+      }
 
-  } else {
+      //deobfuscate walletContent
+      if (secondOpts.walletContent instanceof ObfuscatedValue) {
+        secondOpts.walletContent = secondOpts.walletContent.get();
+      }
+    }
+  }
+  if (!secondOpts) {
     let parsedUrl = url;
     let urlExtendedPart;
     const baseRegex = new RegExp("^config-(?<provider>[A-Za-z0-9]+)(://)(?<provider_arg>[^?]+)");
@@ -1047,9 +1067,9 @@ async function _checkConfigProvider(options) {
         // obfuscate password & walletcontent and store config in the cache
         const cacheOpts = { ...secondOpts};
         if (secondOpts.password)
-          cacheOpts.password = protocolUtil.setObfuscatedValue(secondOpts.password);
+          cacheOpts.password = new ObfuscatedValue(secondOpts.password);
         if (secondOpts.walletContent)
-          cacheOpts.walletContent = protocolUtil.setObfuscatedValue(secondOpts.walletContent);
+          cacheOpts.walletContent = new ObfuscatedValue(secondOpts.walletContent);
         configProviderCache.set(url, { cacheOpts, timeAdded: Date.now()});
       } catch (err) {
         errors.throwErr(errors.ERR_CONFIG_PROVIDER_FAILED_TO_RETRIEVE_CONFIG, err.message);
@@ -1101,6 +1121,30 @@ function modifyOptionsPrecedence(cloudConfig, userConfig) {
   return userConfig;
 
 }
+async function _updateUserOptionsFromConnectString(options, inCreatePool) {
+  let tempOptions;
+  const hasConnectString = options.connectString || options.connectionString;
+  if (!settings.thickModeDSNPassthrough && hasConnectString) {
+    tempOptions = Object.create(Object.getPrototypeOf(options));
+    Object.defineProperties(tempOptions, Object.getOwnPropertyDescriptors(options));
+    const { connectString, resolver } = parserHelpers.getConnectDescriptorFromEZConnect(tempOptions.connectString || tempOptions.connectionString);
+    if (tempOptions.connectString !== undefined) {
+      tempOptions.connectString = connectString;
+    } else if (tempOptions.connectionString != undefined) {
+      tempOptions.connectionString = connectString;
+    }
+
+    if (resolver) parserHelpers.mergeExtendedParams(tempOptions, resolver);
+  } else {
+    tempOptions = options;
+  }
+  options = await _verifyOptions(tempOptions, inCreatePool);
+  if (!settings.thickModeDSNPassthrough && options.connectString) {
+    await parserHelpers.applyConnectStringOverrides(options);
+  }
+  return options;
+}
+
 //-----------------------------------------------------------------------------
 // startup()
 //
@@ -1169,6 +1213,62 @@ function registerConfigurationProviderHook(configProvider, fn) {
   registeredConfigProviderHooks[configProvider] = fn;
 }
 
+//-----------------------------------------------------------------------------
+// enquoteLiteral()
+//
+// Returns a quoted SQL literal with embedded single quotes doubled.
+//-----------------------------------------------------------------------------
+function enquoteLiteral(value) {
+  errors.assertArgCount(arguments, 1, 1);
+  errors.assertParamValue(typeof value === 'string', 1);
+  return parser.enquoteLiteral(value);
+}
+
+//-----------------------------------------------------------------------------
+// enquoteName()
+//
+// Returns a quoted SQL identifier. Embedded double quotes are rejected and the
+// value is converted to uppercase using locale-independent Unicode rules when
+// capitalize is true.
+//-----------------------------------------------------------------------------
+function enquoteName(name, capitalize = true) {
+  errors.assertArgCount(arguments, 1, 2);
+  errors.assertParamValue(typeof name === 'string', 1);
+  if (arguments.length > 1)
+    errors.assertParamValue(typeof capitalize === 'boolean', 2);
+
+  if (name.includes('"')) {
+    errors.throwErr(errors.ERR_INVALID_SQL_NAME);
+  }
+  return `"${capitalize ? name.toUpperCase() : name}"`;
+}
+
+//-----------------------------------------------------------------------------
+// isQualifiedSqlName()
+//
+// Returns whether the trimmed value is a qualified SQL name. Qualified names
+// are dotted simple SQL names with an optional trailing @ database link, and
+// the database link name can itself be dotted.
+//-----------------------------------------------------------------------------
+function isQualifiedSqlName(name) {
+  errors.assertArgCount(arguments, 1, 1);
+  errors.assertParamValue(typeof name === 'string', 1);
+  const text = name.trim();
+  return parser.parseQualifiedSqlName(text, 0) === text.length;
+}
+
+//-----------------------------------------------------------------------------
+// isSimpleSqlName()
+//
+// Returns whether the trimmed value is a single simple SQL name.
+//-----------------------------------------------------------------------------
+function isSimpleSqlName(name) {
+  errors.assertArgCount(arguments, 1, 1);
+  errors.assertParamValue(typeof name === 'string', 1);
+  const text = name.trim();
+  return parser.parseSimpleSqlName(text, 0) === text.length;
+}
+
 // module exports
 module.exports = {
 
@@ -1182,6 +1282,7 @@ module.exports = {
   JsonId: types.JsonId,
   Lob,
   Pool,
+  Pipeline,
   PoolStatistics,
   ResultSet,
   SodaDatabase,
@@ -1192,13 +1293,18 @@ module.exports = {
   SparseVector: types.SparseVector,
   IntervalYM: types.IntervalYM,
   IntervalDS: types.IntervalDS,
+  EndUserSecurityContext,
 
   // top-level functions
+  enquoteLiteral,
+  enquoteName,
   getConnection: nodbUtil.callbackify(nodbUtil.wrapFn(getConnection)),
   createPool: nodbUtil.callbackify(nodbUtil.wrapFn(createPool)),
   getNetworkServiceNames: nodbUtil.callbackify(nodbUtil.wrapFn(getNetworkServiceNames)),
   getPool,
   initOracleClient,
+  isQualifiedSqlName,
+  isSimpleSqlName,
   registerProcessConfigurationHook,
   registerConfigurationProviderHook,
   shutdown: nodbUtil.callbackify(nodbUtil.wrapFn(shutdown)),
@@ -1702,6 +1808,14 @@ module.exports = {
     errors.assertPropValue(Number.isInteger(value) && value >= 0,
       "configProviderCacheTimeout");
     settings.configProviderCacheTimeout = value;
-  }
+  },
 
+  get thickModeDSNPassthrough() {
+    return settings.thickModeDSNPassthrough;
+  },
+
+  set thickModeDSNPassthrough(value) {
+    errors.assertPropValue(typeof value === 'boolean', "thickModeDSNPassthrough");
+    settings.thickModeDSNPassthrough = value;
+  },
 };