oracledb 6.6.0 → 6.7.1

package/lib/traceHandler.js

@@ -0,0 +1,133 @@
+// Copyright (c) 2024, 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';
+
+/**
+ * TraceHandler interface defination which application needs to implement
+ * the hooks defined. The hooks will be called by the driver with traceContext
+ * data.
+ *
+ * TraceContext Data details.
+ * connectLevelConfig - Connection Config details.
+ *      protcol         - tcp/tcps protocol.
+ *      user            - user/schema associated.
+ *      instanceName    - instance Name.
+ *      pdbName         - PDB name.
+ *      serviceName     - service name.
+ *      connectString   - connect string passed.
+ *      hostName        - host name.
+ *      port            - port number.
+ *      poolMin         - pool Min.
+ *      poolMax         - pool Max.
+ *      poolIncrement   - pool Increment.
+ *
+ * callLevelConfig - Post connection, call leveldetails.
+ *      statement       - SQL statement.
+ *      values          - Bind values.
+ *
+ * additionalConfig - Custom Config based on the methods executed.
+ *      args            - input arguments of function.
+ *      self            - the current instance on which function is called.
+ *      result          - the result object returned after calling function.
+ *      implicitRelease - true if implicit release is done.
+ *
+ */
+
+class TraceHandlerBase {
+
+  constructor() {
+    this._config = {};
+  }
+
+  // check if sending traces is enabled.
+  isEnabled() {
+    return (this._config.enable);
+  }
+
+  // Enable sending traces
+  enable() {
+    this._config.enable = true;
+  }
+
+  // Disable sending traces
+  disable() {
+    this._config.enable = false;
+  }
+
+  // It is called before invoking a public async method.
+  onEnterFn(/*traceContext*/) {
+  }
+
+  // It is called after invoking a public async method.
+  // The same traceContext object passed inside onEnterFn
+  // will be passed in this function.
+  onExitFn(/*traceContext*/) {
+  }
+
+  // called when a round trip is begun
+  // OpenTelemetry will start a new span as a child of the public API span.
+  onBeginRoundTrip(/*traceContext*/) {
+  }
+
+  // called when a round trip has ended
+  // OpenTelemetry will end the span
+  // The same traceContext object passed inside onBeginRoundTrip
+  // is passed here.
+  onEndRoundTrip(/*traceContext*/) {
+  }
+
+}
+
+// singleton object pointing to traceHandler instance.
+let _currentTraceObject;
+
+// It enables user defined implementation of
+// TraceHandlerBase interface to be used.
+function setTraceInstance(obj) {
+  _currentTraceObject = obj;
+}
+
+// It returns the user defined instance implementing the interface.
+function getTraceInstance() {
+  return _currentTraceObject;
+}
+
+// returns if tracing is enabled.
+function isEnabled() {
+  return _currentTraceObject?.isEnabled();
+}
+
+module.exports = {
+  // class
+  TraceHandlerBase,
+
+  // methods
+  setTraceInstance,
+  getTraceInstance,
+  isEnabled
+
+};

package/lib/util.js

@@ -32,6 +32,16 @@ const process = require('process');
 const util = require('util');
 const types = require('./types.js');
 const constants = require('./constants.js');
+const traceHandler = require('./traceHandler.js');
+
+// set of valid network characters
+const validNetworkCharacterSet = new Set(['A', 'B', 'C', 'D', 'E', 'F', 'G',
+  'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+  'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
+  'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '<', '>', '/', '\\', ',',
+  '.', ':', ';', '\'', '"', '-', '_', '$', '+', '*', '#', '&', '!', '%', '?',
+  '@']);
 
 // node-oracledb version number
 let packageJSON;
@@ -54,6 +64,17 @@ const BUILD_FILE = 'oracledb.node';
 // Staging directory used by maintainers building the npm package
 const STAGING_DIR = 'package/Staging';
 
+//-----------------------------------------------------------------------------
+// assertParamPropNetworkName()
+//
+// Asserts input vaue and sanitized value passes specified condition
+// -----------------------------------------------------------------------------
+function assertParamPropNetworkName(obj, parameterNum, propName) {
+  errors.assertParamPropString(obj, parameterNum, propName);
+  const sanitizedValue = sanitize(obj[propName]);
+  errors.assertParamPropValue(obj[propName] === sanitizedValue, parameterNum, propName);
+}
+
 // getInstallURL returns a string with installation URL
 function getInstallURL() {
   return ('Node-oracledb installation instructions: https://node-oracledb.readthedocs.io/en/latest/user_guide/installation.html');
@@ -113,6 +134,77 @@ function getInstallHelp() {
   return mesg;
 }
 
+function getOperationName(methodName) {
+  const className = (this.constructor.name === 'Object') ? 'oracledb'
+    : `oracledb.${this.constructor.name}`;
+  return `${className}.${methodName}`;
+}
+
+// It returns an userContext after populating the traceContext with this below data.
+//    Operation derived from className, methodName.
+//    Initialize the callLevelTraceData.
+//    traceContext is filled.
+function traceEnterFn(traceContext) {
+  if (!traceHandler.isEnabled()) {
+    return;
+  }
+
+  // initialize callLevel data
+  if (this._impl) {
+    this._impl._callLevelTraceData = {};
+  }
+
+  // fill the traceContext.
+  traceContext.additionalConfig = {};
+  traceContext.additionalConfig.self = this;
+  traceContext.additionalConfig.args = traceContext.args;
+  traceContext.operation = getOperationName.call(this, traceContext.fn.name);
+  traceContext.connectLevelConfig = this._impl?._getConnectTraceConfig();
+  traceHandler.getTraceInstance().onEnterFn(traceContext);
+}
+
+// It calls the onExitFn method providing the userContext resturned in onEnterFn.
+function traceExitFn(traceContext, result, err) {
+  const callExitFn = traceHandler.isEnabled();
+  if (!callExitFn) {
+    return;
+  }
+
+  // Fill the traceContext.
+  traceContext.error = err;
+  traceContext.additionalConfig.result = result;
+  if (this._impl) {
+    // fill function call state.
+    traceContext.callLevelConfig = this._impl._callLevelTraceData;
+  }
+  if (['oracledb.getConnection', 'oracledb.createPool'].includes(traceContext.operation)) {
+    if (err) {
+      if (traceContext.args && traceContext.args.length >= 1) {
+        // connectString and user information is populated in traceContext,
+        // which is useful if an error happens and connection object is not created.
+        const config = {};
+        const inp = traceContext.args[0];
+        config.user = inp.user || inp.username;
+        config.connectString = inp.connectString || inp.connectionString;
+        traceContext.connectLevelConfig = config;
+      }
+    } else {
+      traceContext.connectLevelConfig = result._impl._getConnectTraceConfig();
+    }
+  } else if (traceContext.operation === 'oracledb.Pool.getConnection') {
+    if (!err) {
+      // we update the connectTraceConfig with more values with returned conn.
+      traceContext.connectLevelConfig = result._impl._getConnectTraceConfig();
+    }
+  }
+
+  traceHandler.getTraceInstance().onExitFn(traceContext);
+  if (this._impl) {
+    // cleanup the function call state.
+    this._impl._callLevelTraceData = undefined;
+  }
+}
+
 // The callbackify function is used to wrap async methods to add optional
 // callback support. If the last parameter passed to a method is a function,
 // then it is assumed that the callback pattern is being used and the promise
@@ -124,9 +216,7 @@ function callbackify(func) {
     // if last argument is not a function, simply invoke the function as usual
     // and a promise will be returned
     if (typeof arguments[arguments.length - 1] !== 'function') {
-      return func.apply(this, arguments).catch(function stackCapture(err) {
-        throw errors.transformErr(err, stackCapture);
-      });
+      return func.apply(this, arguments);
     }
 
     // otherwise, resolve or reject the promise and invoke the callback
@@ -134,9 +224,7 @@ function callbackify(func) {
     const cb = arguments[arguments.length - 1];
     func.apply(this, args).then(function(result) {
       cb(null, result);
-    }, function stackCapture(err) {
-      cb(errors.transformErr(err, stackCapture));
-    });
+    }, cb);
   };
   if (func.name) {
     Object.defineProperty(wrapper, 'name', { value: func.name });
@@ -144,17 +232,30 @@ function callbackify(func) {
   return wrapper;
 }
 
-// The serialize function is used to wrap methods to ensure that the connection
-// is not used concurrently by multiple threads
-function serialize(func) {
-  return async function() {
+// the wrapFn() function is used to wrap a single method to ensure that calls
+// are serialized and that concurrent calls are prevented where that is needed;
+// this method also ensures that error information is captured correctly.
+// If tracing is enabled, the hooks onEnterFn and onExitFn are called after
+// the input traceContext is prepared. The func is passed in traceContext
+// which is filled with additional context inside onEnterFn.
+function wrapFn(func, serialize, preventConcurrentErrorCode) {
+  const wrapper = async function wrapper() {
 
     let connImpl;
+    const traceEnabled = traceHandler.isEnabled();
+    const traceContext = {fn: func, args: arguments};
+
+    // if concurrent operations are to be prevented, check for that now
+    if (preventConcurrentErrorCode) {
+      if (this._isActive)
+        errors.throwErr(preventConcurrentErrorCode);
+      this._isActive = true;
+    }
 
     // determine the connection implementation associated with the object, if
     // one currently exists and acquire the "lock"; this simply checks to see
     // if another operation is in progress, and if so, waits for it to complete
-    if (this._impl) {
+    if (serialize && this._impl) {
       connImpl = this._impl._getConnImpl();
       await connImpl._acquireLock();
     }
@@ -162,48 +263,54 @@ function serialize(func) {
     // call the function and ensure that the lock is "released" once the
     // function has completed -- either successfully or in failure -- but only
     // if a connection implementation is currently associated with this object
+    let result, tErr;
     try {
-      return await func.apply(this, arguments);
+      if (traceEnabled) {
+        traceEnterFn.call(this, traceContext);
+      }
+      result = await traceContext.fn.apply(this, arguments);
+      return result;
+    } catch (err) {
+      tErr = errors.transformErr(err, wrapper);
+      throw tErr;
     } finally {
       if (connImpl)
         connImpl._releaseLock();
+      if (preventConcurrentErrorCode) {
+        this._isActive = false;
+      }
+      if (traceEnabled) {
+        traceExitFn.call(this, traceContext, result, tErr);
+      }
     }
-  };
-}
 
-function preventConcurrent(func, errorCode) {
-  return async function() {
-    if (this._isActive)
-      errors.throwErr(errorCode);
-    this._isActive = true;
-    try {
-      return await func.apply(this, arguments);
-    } finally {
-      this._isActive = false;
-    }
   };
+  if (func.name) {
+    Object.defineProperty(wrapper, 'name', { value: func.name });
+  }
+  return wrapper;
 }
 
 // The wrapFns() function is used to wrap the named methods on the prototype
-// in multiple ways (serialize, preventConcurrent and callbackify); the
+// so that a number of common tasks can be done in a single place; the
 // arguments following the formal arguments contain the names of methods to
 // wrap on the prototype; if the first extra argument is an error code, it is
 // used to wrap to prevent concurrent access
 function wrapFns(proto) {
   let nameIndex = 1;
+  let serialize = true;
   let preventConcurrentErrorCode;
   if (typeof arguments[1] === 'number') {
-    nameIndex = 2;
+    nameIndex++;
     preventConcurrentErrorCode = arguments[1];
+  } else if (typeof arguments[1] === 'boolean') {
+    nameIndex++;
+    serialize = arguments[1];
   }
   for (let i = nameIndex; i < arguments.length; i++) {
     const name = arguments[i];
     const f = proto[name];
-    if (preventConcurrentErrorCode) {
-      proto[name] = callbackify(preventConcurrent(serialize(f),
-        preventConcurrentErrorCode));
-    } else
-      proto[name] = callbackify(serialize(f));
+    proto[name] = callbackify(wrapFn(f, serialize, preventConcurrentErrorCode));
   }
 }
 
@@ -412,6 +519,42 @@ function makeDate(useLocal, year, month, day, hour, minute,
     fseconds) - offset * 60000);
 }
 
+//---------------------------------------------------------------------------
+// sanitize()
+//
+// this function replaces invalid characters in a string with characters
+// guaranteed to be in the Network Character Set.
+//---------------------------------------------------------------------------
+function sanitize(text) {
+  let value = text.split('');
+
+  // if first character is single/double quote
+  if ((value[0] === '\'' || value[0] === '"')) {
+    value = value.splice(1);
+  }
+
+  // if last character is single/double quote
+  if ((value[value.length - 1] === '\'' || value[value.length - 1] === '"')) {
+    value.pop();
+  }
+
+  // look for invalid characters, and replace them with '?'
+  // in case of default values and throw an error
+  // for user provided values
+  for (let i = 0; i < value.length; i++) {
+    if (!validNetworkCharacterSet.has(value[i])) {
+      value[i] = '?';
+    }
+  }
+
+  // if last character is a backslash
+  if (value[value.length - 1] === '\\') {
+    value[value.length - 1] = '?';
+  }
+
+  return value.join('');
+}
+
 // define exports
 module.exports = {
   BINARY_FILE,
@@ -420,6 +563,7 @@ module.exports = {
   RELEASE_DIR,
   STAGING_DIR,
   addTypeProperties,
+  assertParamPropNetworkName,
   callbackify,
   denormalizePrivateKey,
   getInstallURL,
@@ -436,8 +580,8 @@ module.exports = {
   isXid,
   normalizeXid,
   makeDate,
-  preventConcurrent,
-  serialize,
+  sanitize,
   verifySodaDoc,
+  wrapFn,
   wrapFns
 };

package/lib/version.js

@@ -30,7 +30,7 @@
 
 module.exports = {
   VERSION_MAJOR: 6,
-  VERSION_MINOR: 6,
-  VERSION_PATCH: 0,
+  VERSION_MINOR: 7,
+  VERSION_PATCH: 1,
   VERSION_SUFFIX: ''
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oracledb",
-  "version": "6.6.0",
+  "version": "6.7.1",
   "description": "A Node.js module for Oracle Database access from JavaScript and TypeScript",
   "license": "(Apache-2.0 OR UPL-1.0)",
   "homepage": "http://oracle.github.io/node-oracledb/",

package/build/Release/oracledb-6.6.0-darwin-arm64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.6.0-darwin-arm64.node v22.2.0 6e81601d4d09137e859660fbbe090e1b272adbb2 5f182c720d6541c3b267d5d370f606f90b5b0c38 Wed, 17 Jul 2024 06:45:24 GMT

package/build/Release/oracledb-6.6.0-darwin-x64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.6.0-darwin-x64.node v20.11.1 6e81601d4d09137e859660fbbe090e1b272adbb2 5f182c720d6541c3b267d5d370f606f90b5b0c38 Wed, 17 Jul 2024 04:43:48 GMT

package/build/Release/oracledb-6.6.0-js-buildinfo.txt

@@ -1 +0,0 @@
-6e81601d4d09137e859660fbbe090e1b272adbb2

package/build/Release/oracledb-6.6.0-linux-arm64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.6.0-linux-arm64.node v20.12.2 6e81601d4d09137e859660fbbe090e1b272adbb2 5f182c720d6541c3b267d5d370f606f90b5b0c38 Wed, 17 Jul 2024 07:10:04 GMT

package/build/Release/oracledb-6.6.0-linux-x64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.6.0-linux-x64.node v16.20.2 6e81601d4d09137e859660fbbe090e1b272adbb2 5f182c720d6541c3b267d5d370f606f90b5b0c38 Wed, 17 Jul 2024 07:13:04 GMT

package/build/Release/oracledb-6.6.0-win32-x64.node-buildinfo.txt

@@ -1 +0,0 @@
-oracledb-6.6.0-win32-x64.node v18.16.0 6e81601d4d09137e859660fbbe090e1b272adbb2 5f182c720d6541c3b267d5d370f606f90b5b0c38 Wed, 17 Jul 2024 07:26:50 GMT

package/examples/README.md

@@ -1,138 +0,0 @@
-# Node-oracledb Examples
-
-The directory in node-oracledb's [Github repository](https://github.com/oracle/node-oracledb/tree/main/examples) contains a lot of [node-oracledb](https://www.npmjs.com/package/oracledb) examples.
-Documentation is [here](https://node-oracledb.readthedocs.io/en/latest/).
-
-To run the examples:
-
-- [Install node-oracledb](https://node-oracledb.readthedocs.io/en/latest/user_guide/installation.html#quickstart).
-
-- Ensure that you navigate to the `examples` directory in your terminal window
-  or IDE, where you are running the samples.
-
-- Review `dbconfig.js`.
-
-In your terminal window or IDE, set the following environment variables to
-provide credentials for the `dbconfig.js` file.
-
-- `NODE_ORACLEDB_USER` must be set to the database user.
-
-- `NODE_ORACLEDB_PASSWORD` must be set to the database password.
-
-- `NODE_ORACLEDB_CONNECTIONSTRING` must be set to the connection string that points to your database's location.
-
-- `NODE_ORACLEDB_EXTERNALAUTH` provides the options for enabling external authentication. Setting this environment variable to "true" will enable external authentication. To ensure external authentication works, firstly make sure the Oracle external authentication service is correctly configured. See [Documentation for External Authentication](https://node-oracledb.readthedocs.io/en/latest/user_guide/connection_handling.html#extauth) for details.
-
-- `NODE_ORACLEDB_DRIVER_MODE` provides an option to set the 'Thin' or 'Thick' modes of node-oracledb. Setting this environment variable to "thick" will enable Thick mode.
-Setting it to "thin" will retain the Thin mode. The default mode is Thin.
-
-- `NODE_ORACLEDB_WALLET_LOCATION` must be set to the local directory name for the wallets that may be required for mutual TLS (mTLS) connections, especially to Oracle Cloud
-Autonomous Databases optionally. The wallet location can also be provided as a part of the database connect string.
-
-- `NODE_ORACLEDB_WALLET_PASSWORD` must set to the password for the wallets that may be required for mutual TLS (mTLS) connections, especially to Oracle Cloud Autonomous Databases.
-
-- `NODE_ORACLEDB_CLIENT_LIB_DIR` provides an optional path for the Oracle Client libraries to be used on Windows and macOS platforms, when using Thick mode in node-oracledb.
-
-Review the examples and then run them individually.  For example, to see what
-  the file `example.js` does, use:
-
-  ```
-  node example.js
-  ```
-
-After running the examples, the demonstration objects can be dropped with
-  `demodrop.js`:
-
-  ```
-  node demodrop.js
-  ```
-
-Many examples can be run in either node-oracledb Thin (the default) or Thick
-modes.  Thin mode is a pure JavaScript implementation of node-oracledb.
-Setting the environment variable `NODE_ORACLEDB_DRIVER_MODE` to `'thick'` will
-make examples use Thick mode.
-
-## Example Overview
-
-If this is your first time with node-oracledb, start with
-[`example.js`](example.js).
-
-File Name                                                 | Description
-----------------------------------------------------------|----------------------------------------------------------------------------------
-[`aqmulti.js`](aqmulti.js)                                | Oracle Advanced Queuing (AQ) example passing multiple messages
-[`aqobject.js`](aqobject.js)                              | Oracle Advanced Queuing (AQ) example passing an Oracle Database object
-[`aqoptions.js`](aqoptions.js)                            | Oracle Advanced Queuing (AQ) example setting options and message attributes
-[`aqraw.js`](aqraw.js)                                    | Basic Oracle Advanced Queuing (AQ) example passing text messages
-[`aqutil.js`](aqutil.js)                                  | Common file to setup the user credentials for all the Advanced Queuing (AQ) examples.
-[`blobhttp.js`](blobhttp.js)                              | Simple web app that streams an image
-[`calltimeout.js`](calltimeout.js)                        | Shows how to cancel a SQL statement if it doesn't complete in a specified time
-[`connect.js`](connect.js)                                | Basic example for creating a standalone (non-pooled) connection
-[`connectionpool.js`](connectionpool.js)                  | Basic example creating a pool of connections
-[`cqn1.js`](cqn1.js)                                      | Basic Continuous Query Notification (CQN) example
-[`cqn2.js`](cqn2.js)                                      | Continuous Query Notification with notification grouping
-[`date_timestamp1.js`](date_timestamp1.js)                | Show some basic DATE and TIMESTAMP behaviors
-[`date_timestamp2.js`](date_timestamp2.js)                | Show some DATE and TIMESTAMP behaviors with timezones
-[`dbconfig.js`](dbconfig.js)                              | Common file used by examples for setting connection credentials
-[`dbmsoutputgetline.js`](dbmsoutputgetline.js)            | Show fetching DBMS_OUTPUT by binding buffers
-[`dbmsoutputpipe.js`](dbmsoutputpipe.js)                  | Show fetching DBMS_OUTPUT by using a pipelined table
-[`demodrop.js`](demodrop.js)                              | Drops the schema objects created by the examples
-[`demosetup.js`](demosetup.js)                            | Used to create common schema objects for the examples
-[`dmlrupd.js`](dmlrupd.js)                                | Example of DML RETURNING where multiple rows are matched
-[`em_batcherrors.js`](em_batcherrors.js)                  | `executeMany()` example showing handling data errors
-[`em_dmlreturn1.js`](em_dmlreturn1.js)                    | `executeMany()` example of DML RETURNING that returns single values
-[`em_dmlreturn2.js`](em_dmlreturn2.js)                    | `executeMany()` example of DML RETURNING that returns multiple values
-[`em_insert1.js`](em_insert1.js)                          | Array DML example using `executeMany()` with bind-by-name syntax
-[`em_insert2.js`](em_insert2.js)                          | Array DML example using `executeMany()` with bind by position
-[`em_plsql.js`](em_plsql.js)                              | `executeMany()` example calling PL/SQL multiple times with one call
-[`em_rowcounts.js`](em_rowcounts.js)                      | `executeMany()` example showing how to find the number of rows affected by each input row
-[`endtoend.js`](endtoend.js)                              | Example showing setting tracing attributes
-[`example.js`](example.js)                                | Basic example showing creating a table, inserting multiple rows, and querying rows
-[`impres.js`](impres.js)                                  | Shows PL/SQL 'Implict Results' returning multiple query results from PL/SQL code.
-[`insert1.js`](insert1.js)                                | Basic example creating a table and inserting data.  Shows DDL and DML
-[`insert2.js`](insert2.js)                                | Basic example showing auto commit behavior
-[`lastinsertid.js`](lastinsertid.js)                      | Shows inserting a row and getting its ROWID.
-[`lobbinds.js`](lobbinds.js)                              | Demonstrates how to bind and query LOBs
-[`lobinsert1.js`](lobinsert1.js)                          | Shows inserting a file into a CLOB column
-[`lobinsert2.js`](lobinsert2.js)                          | Inserts text into a CLOB column using the RETURNING INTO method.
-[`lobinserttemp.js`](lobinserttemp.js)                    | Writes data to a Temporary CLOB and then inserts it into the database
-[`lobplsqltemp.js`](lobplsqltemp.js)                      | Streams data into a Temporary CLOB and then passes it to PL/SQL
-[`lobselect.js`](lobselect.js)                            | Shows basic, non-streaming CLOB and BLOB queries
-[`lobstream1.js`](lobstream1.js)                          | Shows how to stream LOBs to files
-[`lobstream2.js`](lobstream2.js)                          | Shows using Stream data events to fetch a CLOB
-[`lowercasecolumns.js`](lowercasecolumns.js)              | Shows how a type handler can convert column names to lower case
-[`metadata.js`](metadata.js)                              | Shows the metadata available after executing SELECT statements
-[`plsqlarray.js`](plsqlarray.js)                          | Examples of binding PL/SQL "INDEX BY" tables
-[`plsqlfunc.js`](plsqlfunc.js)                            | How to call a PL/SQL function
-[`plsqlproc.js`](plsqlproc.js)                            | How to call a PL/SQL procedure
-[`plsqlrecord.js`](plsqlrecord.js)                        | Shows binding of PL/SQL RECORDS
-[`plsqlvarrayrecord.js`](plsqlvarrayrecord.js)            | Shows binding a VARRAY of RECORD in PL/SQL
-[`plsqlrowtype.js`](plsqlrowtype.js)                      | Shows binding of PL/SQL %ROWTYPE object
-[`raw.js`](raw.js)                                        | Shows using a Buffer to insert and select a RAW
-[`refcursor.js`](refcursor.js)                            | Shows using a ResultSet to fetch rows from a REF CURSOR
-[`refcursortoquerystream.js`](refcursortoquerystream.js)  | Converts a REF CURSOR returned from `execute()` to a query stream.
-[`resultset1.js`](resultset1.js)                          | Executes a query and uses a ResultSet to fetch rows with `getRow()`
-[`resultset2.js`](resultset2.js)                          | Executes a query and uses a ResultSet to fetch batches of rows with `getRows()`
-[`resultsettoquerystream.js`](resultsettoquerystream.js)  | Converts a ResultSet returned from `execute()` into a Readable Stream.
-[`rowlimit.js`](rowlimit.js)                              | Shows ways to limit the number of records fetched by queries
-[`sampleazuretokenauth.js`](sampleazuretokenauth.js)      | Shows connection pooling with Azure token based authentication.
-[`sampleocitokenauth.js`](sampleocitokenauth.js)          | Shows connection pooling with OCI OAuth 2.0 token based authentication.
-[`select1.js`](select1.js)                                | Executes a basic query without using a connection pool or ResultSet
-[`select2.js`](select2.js)                                | Executes queries to show array and object output formats
-[`selectgeometry.js`](selectgeometry.js)                  | Insert and query Oracle Spatial geometries
-[`selectjson.js`](selectjson.js)                          | Shows some JSON features of Oracle Database 21c
-[`selectjsonblob.js`](selectjsonblob.js)                  | Shows how to use a BLOB as a JSON column store
-[`selectobject.js`](selectobject.js)                      | Insert and query a named Oracle database object
-[`selectnestedcursor.js`](selectnestedcursor.js)          | Shows selecting from a nested cursor
-[`selectstream.js`](selectstream.js)                      | Executes a basic query using a Readable Stream
-[`selectvarray.js`](selectvarray.js)                      | Shows inserting and selecting from a VARRAY column
-[`sessionfixup.js`](sessionfixup.js)                      | Shows a pooled connection callback to efficiently set session state
-[`sessiontagging1.js`](sessiontagging1.js)                | Simple pooled connection tagging for setting session state
-[`sessiontagging2.js`](sessiontagging2.js)                | More complex example of pooled connection tagging for setting session state
-[`soda1.js`](soda1.js)                                    | Basic Simple Oracle Document Access (SODA) example
-[`typehandlerdate.js`](typehandlerdate.js)                | Show how a type handler can format a queried date in a locale-specific way
-[`typehandlernum.js`](typehandlernum.js)                  | Show how a type handler can alter queried numbers
-[`vectortype1.js`](vectortype1.js)                        | Insert and query VECTOR columns.
-[`vectortype2.js`](vectortype2.js)                        | Insert data into VECTOR columns and verify vector operations.
-[`version.js`](version.js)                                | Shows the node-oracledb version attributes
-[`webapp.js`](webapp.js)                                  | A simple web application using a connection pool
-[`xmltypeInDbObject.js`](xmltypeInDbObject.js)            | Work with XMLType data in DbObject (Thin mode only)