oracledb 6.10.0 → 7.0.1

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,20 +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 && !settings.thin) {
-        // Thick mode currently does not allow proxy users to 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);
-      }
-    }
+    _validateExternalAuthCredentials(outOptions, inCreatePool);
   }
 
   return outOptions;
@@ -616,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;
@@ -687,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) {
@@ -759,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",
@@ -909,13 +923,9 @@ 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)
@@ -951,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'))
@@ -981,9 +991,8 @@ 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');
   }
 }
@@ -1012,12 +1021,14 @@ async function _checkConfigProvider(options) {
       secondOpts = { ...config};
 
       //deobfuscate password
-      if (secondOpts.password)
-        secondOpts.password = protocolUtil.getDeobfuscatedValue(secondOpts.password.value, secondOpts.password.obfuscatedValue);
+      if (secondOpts.password instanceof ObfuscatedValue) {
+        secondOpts.password = secondOpts.password.get();
+      }
 
       //deobfuscate walletContent
-      if (secondOpts.walletContent)
-        secondOpts.walletContent = protocolUtil.getDeobfuscatedValue(secondOpts.walletContent.value, secondOpts.walletContent.obfuscatedValue);
+      if (secondOpts.walletContent instanceof ObfuscatedValue) {
+        secondOpts.walletContent = secondOpts.walletContent.get();
+      }
     }
   }
   if (!secondOpts) {
@@ -1056,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);
@@ -1110,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()
 //
@@ -1178,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 = {
 
@@ -1191,6 +1282,7 @@ module.exports = {
   JsonId: types.JsonId,
   Lob,
   Pool,
+  Pipeline,
   PoolStatistics,
   ResultSet,
   SodaDatabase,
@@ -1201,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)),
@@ -1711,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;
+  },
 };

package/lib/parser.js

@@ -0,0 +1,204 @@
+// 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';
+
+function isUnicodeLetter(ch) {
+  return /^\p{L}$/u.test(ch);
+}
+
+function isUnicodeDigit(ch) {
+  return /^\p{Nd}$/u.test(ch);
+}
+
+function isUnicodeMark(ch) {
+  return /^\p{M}$/u.test(ch);
+}
+
+function isWhitespace(ch) {
+  return /^\s$/u.test(ch);
+}
+
+function isUnquotedIdentifierChar(ch) {
+  return isUnicodeLetter(ch) || isUnicodeMark(ch) || isUnicodeDigit(ch) ||
+    ch === '_' || ch === '$' || ch === '#';
+}
+
+//-----------------------------------------------------------------------------
+// enquoteLiteral()
+//
+// Returns a quoted SQL literal with embedded single quotes doubled.
+//-----------------------------------------------------------------------------
+function enquoteLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+//-----------------------------------------------------------------------------
+// readChar()
+//
+// Returns the Unicode character at the specified UTF-16 index together with the
+// number of UTF-16 code units consumed. This keeps parser indexing correct for
+// supplementary characters.
+//-----------------------------------------------------------------------------
+function readChar(str, index) {
+  if (index >= str.length) {
+    return;
+  }
+  // Read one complete Unicode code point so surrogate pairs are handled as a
+  // single character by the parser.
+  const cp = str.codePointAt(index);
+  const ch = String.fromCodePoint(cp);
+  return { ch, size: ch.length };
+}
+
+//-----------------------------------------------------------------------------
+// skipSpaces()
+//
+// Advances past any Unicode whitespace characters and returns the next
+// non-whitespace index.
+//-----------------------------------------------------------------------------
+function skipSpaces(str, index) {
+  while (index < str.length) {
+    const next = readChar(str, index);
+    if (!isWhitespace(next.ch)) {
+      break;
+    }
+    // Advance by the width of the full code point rather than a single code
+    // unit.
+    index += next.size;
+  }
+  return index;
+}
+
+//-----------------------------------------------------------------------------
+// parseQuotedSimpleSqlName()
+//
+// Parses a quoted identifier. The opening quote is assumed to be at the
+// supplied index. Quoted identifiers must be non-empty and cannot contain a
+// raw double quote or a \u0000 character. The returned index points just after
+// the closing quote.
+//-----------------------------------------------------------------------------
+function parseQuotedSimpleSqlName(str, index) {
+  index += 1;
+  let hasContent = false;
+
+  while (index < str.length) {
+    const cur = readChar(str, index);
+    if (cur.ch === '"') {
+      // Reject empty quoted identifiers; otherwise consume the closing quote.
+      return hasContent ? index + cur.size : undefined;
+    }
+    if (cur.ch === '\u0000') {
+      return;
+    }
+
+    // Any non-quote, non-NUL character is accepted inside quoted names.
+    hasContent = true;
+    index += cur.size;
+  }
+}
+
+//-----------------------------------------------------------------------------
+// parseUnquotedSimpleSqlName()
+//
+// Parses an unquoted identifier. The first character must be a Unicode letter.
+// Remaining characters may be Unicode letters, combining marks, decimal
+// digits, or _, $, #. Parsing stops before the first character that is not part
+// of the identifier.
+//-----------------------------------------------------------------------------
+function parseUnquotedSimpleSqlName(str, index) {
+  const first = readChar(str, index);
+  if (!first || !isUnicodeLetter(first.ch)) {
+    return;
+  }
+
+  // Consume the required leading Unicode letter first.
+  index += first.size;
+  while (index < str.length) {
+    const cur = readChar(str, index);
+    if (!isUnquotedIdentifierChar(cur.ch)) {
+      break;
+    }
+    index += cur.size;
+  }
+
+  return index;
+}
+
+//-----------------------------------------------------------------------------
+// parseSimpleSqlName()
+//
+// Parses one simple identifier component, quoted or unquoted, and returns the
+// index just after the parsed component.
+//-----------------------------------------------------------------------------
+function parseSimpleSqlName(str, index) {
+  const cur = readChar(str, index);
+  if (!cur) {
+    return;
+  }
+  return cur.ch === '"' ? parseQuotedSimpleSqlName(str, index)
+    : parseUnquotedSimpleSqlName(str, index);
+}
+
+//-----------------------------------------------------------------------------
+// parseQualifiedSqlName()
+//
+// Parses a qualified SQL name made up of one or more simple SQL names
+// separated by dots, optionally followed by an @ database link name that can
+// itself contain dotted simple SQL names. The returned index points just
+// after the parsed qualified name; undefined is returned if parsing fails.
+//-----------------------------------------------------------------------------
+function parseQualifiedSqlName(str, index) {
+  let foundDbLink = false;
+
+  while (true) {
+    const parsedIndex = parseSimpleSqlName(str, index);
+    if (parsedIndex === undefined) {
+      return;
+    }
+
+    index = skipSpaces(str, parsedIndex);
+
+    if (index === str.length) {
+      return index;
+    }
+
+    const separator = readChar(str, index);
+    index = skipSpaces(str, index + separator.size);
+
+    if (!foundDbLink && separator.ch === '@') {
+      foundDbLink = true;
+    } else if (separator.ch !== '.') {
+      return;
+    }
+  }
+}
+
+module.exports = {
+  enquoteLiteral,
+  parseQualifiedSqlName,
+  parseSimpleSqlName
+};

package/lib/pipeline.js

@@ -0,0 +1,113 @@
+// 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 errors = require('./errors.js');
+const nodbUtil = require('./util.js');
+const settings = require('./settings.js');
+
+class Pipeline {
+  constructor() {
+    this.operations = []; // operations in pipeline.
+  }
+
+  _validExecOptions = [
+    'autoCommit', 'fetchArraySize', 'maxRows', 'outFormat', 'prefetchRows'
+  ];
+
+  _validExecManyOptions = [...this._validExecOptions, 'bindDefs'];
+
+  _checkOptions(opts, validOptions) {
+    if (opts && typeof opts === 'object') {
+      for (const [k,] of Object.entries(opts)) {
+        if (!validOptions.includes(k))
+          errors.throwErr(errors.ERR_PIPELINE_EXEC_OPTION_NOT_SUPPORTED, k);
+      }
+    }
+  }
+
+  _addOperation(opType, data = {}) {
+    if (['execute', 'fetchOne', 'fetchMany', 'fetchAll'].includes(opType))
+      this._checkOptions(data.options, this._validExecOptions);
+    else if (opType === 'executeMany')
+      this._checkOptions(data.options, this._validExecManyOptions);
+    this.operations.push({ opType, ...data });
+  }
+
+  addExecute(statement, parameters = [], options = {}) {
+    errors.assertParamValue(nodbUtil.isObject(options), 3);
+    this._addOperation('execute', { statement, parameters, options });
+  }
+
+  addExecuteMany(statement, parameters, options = {}) {
+    errors.assertParamValue(nodbUtil.isObject(options), 3);
+    this._addOperation('executeMany', { statement, parameters, options });
+  }
+
+  addFetchOne(statement, parameters = [], options = {}, fetchLobs = true) {
+    errors.assertParamValue(nodbUtil.isObject(options), 3);
+    options.prefetchRows = options.prefetchRows ?? 1;
+    options.fetchArraySize = options.fetchArraySize ?? 1;
+    errors.assertParamValue(typeof fetchLobs === 'boolean', 4);
+    this._addOperation('fetchOne', { statement, parameters, options,
+      fetchLobs});
+  }
+
+  addFetchMany(statement, parameters = [], options = {},
+    numRows = settings.fetchArraySize, fetchLobs = true) {
+    errors.assertParamValue(nodbUtil.isObject(options), 3);
+    options.prefetchRows = options.prefetchRows ?? numRows;
+    if (numRows > 0)
+      options.fetchArraySize = options.fetchArraySize ?? numRows;
+    errors.assertParamValue(Number.isInteger(numRows) && numRows >= 0, 4);
+    errors.assertParamValue(typeof fetchLobs === 'boolean', 5);
+    this._addOperation('fetchMany', { statement, parameters, options,
+      numRows, fetchLobs});
+  }
+
+  addFetchAll(statement, parameters = [], options = {},
+    fetchArraySize, fetchLobs) {
+    errors.assertParamValue(nodbUtil.isObject(options), 3);
+    fetchArraySize = fetchArraySize ?? options.fetchArraySize ??
+      settings.fetchArraySize;
+    options.prefetchRows = options.prefetchRows ?? fetchArraySize;
+    options.fetchArraySize = fetchArraySize;
+    fetchLobs = fetchLobs ?? true;
+    errors.assertParamValue(Number.isInteger(fetchArraySize) &&
+    fetchArraySize > 0, 4);
+    errors.assertParamValue(typeof fetchLobs === 'boolean', 5);
+    this._addOperation('fetchAll', { statement, parameters, options,
+      fetchArraySize, fetchLobs});
+  }
+
+  addCommit() {
+    this._addOperation('commit', {});
+  }
+
+}
+
+module.exports = Pipeline;