oracledb 6.1.0 → 6.3.0

package/lib/impl/resultset.js

@@ -30,7 +30,9 @@ const constants = require('../constants.js');
 const errors = require('../errors.js');
 const nodbUtil = require('../util.js');
 const settings = require('../settings.js');
+const future = require('../future.js');
 const types = require('../types.js');
+const Lob = require('../lob.js');
 
 // define implementation class
 class ResultSetImpl {
@@ -100,36 +102,71 @@ class ResultSetImpl {
       metadata.fetchType = actualFetchType;
     }
 
+    let converter;
+    const userConverter = metadata.converter;
+
+    // If IsJson is set convert to JSON objects unless
+    // user defined output type handler overwrites it.
+    if (future.oldJsonColumnAsObj && metadata.isJson && metadata.dbType !== types.DB_TYPE_JSON
+      && userConverter === undefined) {
+      const outConverter = async function(val) {
+        if (!val) {
+          return val;
+        }
+
+        let result = val;
+        if (val instanceof Lob) {
+          result = await val.getData();
+        }
+        if (result instanceof Buffer) {
+          result = result.toString();
+        }
+        result = JSON.parse(result);
+        return result;
+      };
+      converter = outConverter;
+    }
+
     // in thin mode, Oracle NUMBER values are internally fetched as string in
     // order to preserve precision so must be converted to JavaScript Number
     // when needed; other numeric and date types are fetched natively as
     // JavaScript Number and Date values and are converted to string using
     // toString() when desired
     if (settings.thin) {
-      let converter;
-      const userConverter = metadata.converter;
       if (metadata.dbType === types.DB_TYPE_NUMBER &&
-          metadata.fetchType === types.DB_TYPE_NUMBER) {
+        metadata.fetchType === types.DB_TYPE_NUMBER) {
         converter = (v) => (v === null) ? null : parseFloat(v);
       } else if (metadata.fetchType === types.DB_TYPE_VARCHAR) {
         if (metadata.dbType === types.DB_TYPE_BINARY_DOUBLE ||
-           metadata.dbType === types.DB_TYPE_BINARY_FLOAT ||
-           metadata.dbType === types.DB_TYPE_DATE ||
-           metadata.dbType === types.DB_TYPE_TIMESTAMP ||
-           metadata.dbType === types.DB_TYPE_TIMESTAMP_LTZ ||
-           metadata.dbType === types.DB_TYPE_TIMESTAMP_TZ) {
+          metadata.dbType === types.DB_TYPE_BINARY_FLOAT ||
+          metadata.dbType === types.DB_TYPE_DATE ||
+          metadata.dbType === types.DB_TYPE_TIMESTAMP ||
+          metadata.dbType === types.DB_TYPE_TIMESTAMP_LTZ ||
+          metadata.dbType === types.DB_TYPE_TIMESTAMP_TZ) {
           converter = (v) => (v === null) ? null : v.toString();
         } else if (metadata.dbType === types.DB_TYPE_RAW) {
           converter = (v) => (v === null) ? null : v.toString('hex').toUpperCase();
         }
+      } else if (metadata.dbType === types.DB_TYPE_XMLTYPE) {
+        const xmlConverter = async function(val) {
+          if (!val) {
+            return val;
+          }
+          if (typeof val === 'string') {
+            return val;
+          }
+          return await val.getData();
+        };
+        converter = xmlConverter;
       }
       if (userConverter && converter) {
         const internalConverter = converter;
         converter = (v) => userConverter(internalConverter(v));
       }
-      if (converter) {
-        metadata.converter = converter;
-      }
+    }
+
+    if (converter) {
+      metadata.converter = converter;
     }
 
   }

package/lib/oracledb.js

@@ -48,6 +48,7 @@ const AqDeqOptions = require('./aqDeqOptions.js');
 const AqEnqOptions = require('./aqEnqOptions.js');
 const AqMessage = require('./aqMessage.js');
 const AqQueue = require('./aqQueue.js');
+const future = require('./future.js');
 const BaseDbObject = require('./dbObject.js');
 const Connection = require('./connection.js');
 const Lob = require('./lob.js');
@@ -69,22 +70,26 @@ const defaultPoolAlias = 'default';
 let _initOracleClientArgs;
 
 // Load the Oracledb binary
-function _initCLib() {
+function _initCLib(options) {
   /*global __non_webpack_require__*/  // quieten eslint
   const requireBinary = (typeof __non_webpack_require__ === 'function') ? __non_webpack_require__ : require; // See Issue 1156
-
   const binaryLocations = [
     '../' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BINARY_FILE,  // pre-built binary
-    '../' + nodbUtil.RELEASE_DIR + '/' + 'oracledb.node',       // binary built from source
-    '../build/Debug/oracledb.node',                             // debug binary
+    '../' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BUILD_FILE,   // binary built from source
+    '../build/Debug/' + nodbUtil.BUILD_FILE,                    // debug binary
     // Paths for Webpack.
     // Note: to use node-oracledb Thick mode, you will need a Webpack copy plugin to
     // copy 'node_modules/oracledb/build/' to the output directory,
     // see https://github.com/oracle/node-oracledb/issues/1156
     // If you want to use only node-oracledb Thin mode, a copy plugin is not needed.
     './node_modules/oracledb/' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BINARY_FILE,
-    './node_modules/oracledb/' + nodbUtil.RELEASE_DIR + '/' + 'oracledb.node'
+    './node_modules/oracledb/' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BUILD_FILE
   ];
+
+  if (options.binaryDir !== undefined) {
+    binaryLocations.splice(0, 0, options.binaryDir + '/' + nodbUtil.BINARY_FILE,
+      options.binaryDir + '/' + nodbUtil.BUILD_FILE);
+  }
   let oracledbCLib;
   for (let i = 0; i < binaryLocations.length; i++) {
     try {
@@ -467,9 +472,10 @@ async function _verifyOptions(options, inCreatePool) {
     let accessToken;
     if (typeof options.accessToken === 'function') {
       outOptions.accessTokenFn = options.accessToken;
-      accessToken = await options.accessToken(false);
+      outOptions.accessTokenConfig = options.accessTokenConfig;
+      accessToken = await options.accessToken(false, options.accessTokenConfig);
       if (!nodbUtil.isTokenValid(accessToken)) {
-        accessToken = await options.accessToken(true);
+        accessToken = await options.accessToken(true, options.accessTokenConfig);
       }
     } else {
       accessToken = options.accessToken;
@@ -478,9 +484,7 @@ async function _verifyOptions(options, inCreatePool) {
       errors.ERR_TOKEN_HAS_EXPIRED);
     if (accessToken.privateKey !== undefined) {
       errors.assert(typeof accessToken.privateKey === 'string', errors.ERR_TOKEN_BASED_AUTH);
-      accessToken.privateKey = accessToken.privateKey.replace(/\n/g, '');
-      accessToken.privateKey = accessToken.privateKey.replace('-----BEGIN PRIVATE KEY-----', '');
-      accessToken.privateKey = accessToken.privateKey.replace('-----END PRIVATE KEY-----', '');
+      accessToken.privateKey = nodbUtil.denormalizePrivateKey(accessToken.privateKey);
     }
 
     // store token and privatekey
@@ -493,9 +497,20 @@ async function _verifyOptions(options, inCreatePool) {
 
   }
 
-  // Check external Auth config
-  if (outOptions.token === undefined && outOptions.externalAuth && (outOptions.user || outOptions.password)) {
-    errors.throwErr(errors.ERR_WRONG_CRED_FOR_EXTAUTH);
+  // 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);
+      }
+    }
   }
 
   return outOptions;
@@ -682,12 +697,13 @@ function initOracleClient(arg1) {
     errors.assertParamPropString(options, 1, "configDir");
     errors.assertParamPropString(options, 1, "errorUrl");
     errors.assertParamPropString(options, 1, "driverName");
+    errors.assertParamPropString(options, 1, "binaryDir");
   }
   if (settings.thinDriverInitialized) {
     errors.throwErr(errors.ERR_THIN_CONNECTION_ALREADY_CREATED);
   }
   if (_initOracleClientArgs === undefined) {
-    const oracledbCLib = _initCLib();
+    const oracledbCLib = _initCLib(options);
     if (options.driverName === undefined)
       options.driverName = constants.DEFAULT_DRIVER_NAME + " thk";
     if (options.errorUrl === undefined)
@@ -863,6 +879,7 @@ module.exports = {
   DB_TYPE_TIMESTAMP_LTZ: types.DB_TYPE_TIMESTAMP_LTZ,
   DB_TYPE_TIMESTAMP_TZ: types.DB_TYPE_TIMESTAMP_TZ,
   DB_TYPE_VARCHAR: types.DB_TYPE_VARCHAR,
+  DB_TYPE_XMLTYPE: types.DB_TYPE_XMLTYPE,
 
   // fetchInfo type defaulting
   DEFAULT: constants.DEFAULT,
@@ -1008,6 +1025,9 @@ module.exports = {
   ARRAY: constants.OUT_FORMAT_ARRAY,
   OBJECT: constants.OUT_FORMAT_OBJECT,
 
+  // Instances
+  future,
+
   // property getters
   get autoCommit() {
     return settings.autoCommit;

package/lib/pool.js

@@ -192,10 +192,20 @@ class Pool extends EventEmitter {
       outOptions.user = options.username;
     }
 
+    if (this.externalAuth &&
+      outOptions.user && (outOptions.user[0] !== '['
+        || outOptions.user.slice(-1) !== ']')) {
+      // username is not enclosed in [].
+      errors.throwErr(errors.ERR_WRONG_USER_FORMAT_EXTAUTH_PROXY);
+    }
+
     // password must be a string
     if (options.password !== undefined) {
       errors.assertParamPropValue(typeof options.password === 'string', 1,
         "password");
+      if (this.externalAuth) {
+        errors.throwErr(errors.ERR_WRONG_CRED_FOR_EXTAUTH);
+      }
       outOptions.password = options.password;
     }
 

package/lib/sodaCollection.js

@@ -188,6 +188,16 @@ class SodaCollection {
     return doc;
   }
 
+  //---------------------------------------------------------------------------
+  // listIndexes()
+  //
+  //   To obtain all indices from the collection
+  //---------------------------------------------------------------------------
+  async listIndexes() {
+    const arr = await this._impl.listIndexes();
+    return arr.map(i => JSON.parse(i));
+  }
+
   //---------------------------------------------------------------------------
   // metaData()
   //
@@ -262,6 +272,7 @@ nodbUtil.wrapFns(SodaCollection.prototype,
   "insertManyAndGet",
   "insertOne",
   "insertOneAndGet",
+  "listIndexes",
   "save",
   "saveAndGet",
   "truncate");

package/lib/sodaOperation.js

@@ -94,6 +94,22 @@ class SodaOperation {
     }
   }
 
+
+  //---------------------------------------------------------------------------
+  // lock()
+  //
+  //  Pessimistic locking - similar to SELECT FOR UPDATE, these documents
+  //  cannot be updated by other threads until an explicit commit/rollback is
+  //  called.  With autoCommit set to true is applicable only for one immediate
+  //  operation and is not recommended in this context
+  //---------------------------------------------------------------------------
+  lock()  {
+    errors.assertArgCount(arguments, 0, 0);
+    this._options.lock = true;
+    return this;
+  }
+
+
   //---------------------------------------------------------------------------
   // replaceOne()
   //

package/lib/thin/connection.js

@@ -32,7 +32,7 @@ const ThinResultSetImpl = require('./resultSet.js');
 const ThinLobImpl  = require("./lob.js");
 const Protocol = require("./protocol/protocol.js");
 const { BaseBuffer } = require('./protocol/buffer.js');
-const {NetworkSession:nsi} = require("./sqlnet/networkSession.js");
+const {NetworkSession: nsi} = require("./sqlnet/networkSession.js");
 const { Statement } = require("./statement");
 const thinUtil = require('./util');
 const sqlNetConstants = require('./sqlnet/constants.js');
@@ -59,23 +59,29 @@ class ThinConnectionImpl extends ConnectionImpl {
    * @return {Promise}
    */
   async close() {
-    if (this._protocol.txnInProgress) {
-      await this.rollback();
-    }
-    this._protocol.callTimeout = 0;      // not applicable for close
-    if (this._drcpEnabled) {
-      await this._sessRelease();
-      this._drcpEstablishSession = true;
-    }
+    try {
+      if (this._protocol.txnInProgress) {
+        await this.rollback();
+      }
+      this._protocol.callTimeout = 0;      // not applicable for close
+      if (this._drcpEnabled) {
+        await this._sessRelease();
+        this._drcpEstablishSession = true;
+      }
 
-    if (this._pool && !this._dropSess) {
-      await this._pool.release(this);
-    } else {
-      if (!this._drcpEnabled) {
-        const message = new messages.LogOffMessage(this);
-        await this._protocol._processMessage(message);
+      if (this._pool && !this._dropSess) {
+        await this._pool.release(this);
+      } else {
+        if (!this._drcpEnabled) {
+          const message = new messages.LogOffMessage(this);
+          await this._protocol._processMessage(message);
+        }
+        this.nscon.disconnect();
       }
-      this.nscon.disconnect();
+    } catch (err) {
+      // immediate close of open socket on failure
+      // exception won't be thrown to user
+      this.nscon.disconnect(sqlNetConstants.NSFIMM);
     }
   }
 
@@ -153,6 +159,101 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // _execute()
+  //
+  // Calls the RPC that executes a SQL statement and returns the results.
+  //---------------------------------------------------------------------------
+  async _execute(statement, numIters, binds, options, executeManyFlag) {
+
+    // perform binds
+    const numBinds = statement.bindInfoList.length;
+    const numVars = binds.length;
+    if (numBinds !== numVars && (numVars === 0 || !binds[0].name)) {
+      errors.throwErr(errors.ERR_WRONG_NUMBER_OF_POSITIONAL_BINDS, numBinds, numVars);
+    }
+    for (let i = 0; i < binds.length; i++) {
+      await this._bind(statement, binds[i], i + 1);
+    }
+    if (statement.isPlSql && (options.batchErrors || options.dmlRowCounts)) {
+      errors.throwErr(errors.ERR_EXEC_MODE_ONLY_FOR_DML);
+    }
+
+    // send database request
+    const message = new messages.ExecuteMessage(this, statement, options);
+    message.numExecs = numIters;
+    message.arrayDmlRowCounts = options.dmlRowCounts;
+    message.batchErrors = options.batchErrors;
+    if (statement.isPlSql && statement.requiresFullExecute) {
+      message.numExecs = 1;
+      await this._protocol._processMessage(message);
+      statement.requiresFullExecute = false;
+      message.numExecs = numIters - 1;
+      message.offset = 1;
+    }
+    if (message.numExecs > 0) {
+      await this._protocol._processMessage(message);
+      statement.requiresFullExecute = false;
+    }
+
+    // if a define is required, send an additional request to the database
+    if (statement.requiresDefine && statement.sql) {
+      statement.requiresFullExecute = true;
+      await this._protocol._processMessage(message);
+      statement.requiresFullExecute = false;
+      statement.requiresDefine = false;
+    }
+
+    // process results
+    const result = {};
+    if (message.warning) {
+      result.warning = message.warning;
+    }
+    if (statement.numQueryVars > 0) {
+      result.resultSet = message.resultSet;
+    } else {
+      statement.bufferRowIndex = 0;
+      const outBinds = thinUtil.getOutBinds(statement, numIters,
+        executeManyFlag);
+      if (outBinds) {
+        result.outBinds = outBinds;
+      }
+      if (executeManyFlag) {
+        if (!statement.isPlSql) {
+          result.rowsAffected = statement.rowCount;
+          delete statement.rowCount;
+        }
+        if (options.dmlRowCounts) {
+          result.dmlRowCounts = options.dmlRowCounts;
+        }
+        if (options.batchErrors) {
+          result.batchErrors = options.batchErrors;
+        }
+      } else {
+        if (statement.isPlSql && options.implicitResultSet) {
+          result.implicitResults = options.implicitResultSet;
+        }
+        if (statement.lastRowid) {
+          result.lastRowid = statement.lastRowid;
+          delete statement.lastRowid;
+        }
+        if (statement.isPlSql) {
+          if (statement.rowCount) {
+            result.rowsAffected = statement.rowCount;
+          }
+        } else {
+          result.rowsAffected = statement.rowCount || 0;
+        }
+        if (statement.rowCount) {
+          delete statement.rowCount;
+        }
+      }
+      this._returnStatement(statement);
+    }
+
+    return result;
+  }
+
   //---------------------------------------------------------------------------
   // _parseElementType()
   //
@@ -772,26 +873,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     return resultSet;
   }
 
-  //---------------------------------------------------------------------------
-  // Prepares the sql given by user and binds the value to the statement object
-  //---------------------------------------------------------------------------
-  async _prepareAndBind(sql, binds, options, isParse = false) {
-    const stmt = this._prepare(sql, options);
-    let position = 0;
-    if (!isParse) {
-      const numBinds = stmt.bindInfoList.length;
-      const numVars = binds.length;
-      if (numBinds !== numVars && (numVars === 0 || !binds[0].name)) {
-        errors.throwErr(errors.ERR_WRONG_NUMBER_OF_POSITIONAL_BINDS, numBinds, numVars);
-      }
-      for (const variable of binds) {
-        await this._bind(stmt, variable, position + 1);
-        position += 1;
-      }
-    }
-    return stmt;
-  }
-
   //---------------------------------------------------------------------------
   // Clears the statement cache for the connection
   //---------------------------------------------------------------------------
@@ -812,139 +893,46 @@ class ThinConnectionImpl extends ConnectionImpl {
   }
 
   //---------------------------------------------------------------------------
-  // Parses the sql given by User
-  // calls the OAL8 RPC that parses the SQL statement and returns the metadata
-  // information for a statment.
+  // getStatementInfo()
+  //
+  // Parses the SQL statement and returns information about the statement.
   //---------------------------------------------------------------------------
   async getStatementInfo(sql) {
     const options = {};
     const result = {};
-    const statement = await this._prepareAndBind(sql, null, options, true);
+    const statement = this._prepare(sql, options);
     options.connection = this;
-    // parse the statement (but not for DDL which doesn't support it)
-    if (!statement.isDdl) {
-      const message = new messages.ExecuteMessage(this, statement, options);
-      message.parseOnly = true;
-      await this._protocol._processMessage(message);
-    }
-    if (statement.numQueryVars > 0) {
-      result.metaData = thinUtil.getMetadataMany(statement.queryVars);
-    }
-    result.bindNames = Array.from(statement.bindInfoDict.keys());
-    result.statementType = statement.statementType;
-    return result;
-  }
-
-  //---------------------------------------------------------------------------
-  // Prepares the sql given by the user,
-  // calls the OAL8 RPC that executes a SQL statement and returns the results.
-  //---------------------------------------------------------------------------
-  async execute(sql, numIters, binds, options, executeManyFlag) {
-    const result = {};
-    if (executeManyFlag) {
-      return await this.executeMany(sql, numIters, binds, options);
-    }
-    const statement = await this._prepareAndBind(sql, binds, options);
-
-    // send the initial request to the database
-    const message = new messages.ExecuteMessage(this, statement, options);
-    message.numExecs = 1;
-    await this._protocol._processMessage(message);
-    statement.requiresFullExecute = false;
-
-    // if a define is required, send an additional request to the database
-    if (statement.requiresDefine && statement.sql) {
-      statement.requiresFullExecute = true;
-      await this._protocol._processMessage(message);
-      statement.requiresFullExecute = false;
-      statement.requiresDefine = false;
-    }
-
-    // process message results
-    if (statement.numQueryVars > 0) {
-      result.resultSet = message.resultSet;
-    } else {
-      statement.bufferRowIndex = 0;
-      const bindVars = thinUtil.getBindVars(statement);
-      const outBinds = thinUtil.getExecuteOutBinds(bindVars);
-      if (outBinds) {
-        result.outBinds = outBinds;
-      }
-      if (statement.isPlSql) {
-        if (options.implicitResultSet) {
-          result.implicitResults = options.implicitResultSet;
-        }
-      }
-      if (statement.lastRowid) {
-        result.lastRowid = statement.lastRowid;
-        delete statement.lastRowid;
-      }
-      if (statement.isPlSql) {
-        if (statement.rowCount) {
-          result.rowsAffected = statement.rowCount;
-        }
-      } else {
-        result.rowsAffected = statement.rowCount || 0;
+    try {
+      if (!statement.isDdl) {
+        const message = new messages.ExecuteMessage(this, statement, options);
+        message.parseOnly = true;
+        await this._protocol._processMessage(message);
       }
-      if (statement.rowCount) {
-        delete statement.rowCount;
+      if (statement.numQueryVars > 0) {
+        result.metaData = thinUtil.getMetadataMany(statement.queryVars);
       }
+      result.bindNames = Array.from(statement.bindInfoDict.keys());
+      result.statementType = statement.statementType;
+      return result;
+    } finally {
       this._returnStatement(statement);
     }
-
-    return result;
   }
 
   //---------------------------------------------------------------------------
-  // executeMany()
+  // execute()
   //
-  // Prepares the sql given by the user, calls the OAL8 RPC that executes a SQL
-  // statement multiple times and returns the results.
+  // Calls the RPC that executes a SQL statement and returns the results.
   //---------------------------------------------------------------------------
-  async executeMany(sql, numIters, binds, options) {
-    const statement = await this._prepareAndBind(sql, binds, options);
-    if (statement.isPlSql && (options.batchErrors || options.dmlRowCounts)) {
-      errors.throwErr(errors.ERR_EXEC_MODE_ONLY_FOR_DML);
-    }
-
-    // send database request
-    const message = new messages.ExecuteMessage(this, statement, options);
-    message.numExecs = numIters;
-    message.arrayDmlRowCounts = options.dmlRowCounts;
-    message.batchErrors = options.batchErrors;
-    if (statement.isPlSql && statement.requiresFullExecute) {
-      message.numExecs = 1;
-      await this._protocol._processMessage(message);
-      statement.requiresFullExecute = false;
-      message.numExecs = numIters - 1;
-      message.offset = 1;
-    }
-    if (message.numExecs > 0) {
-      await this._protocol._processMessage(message);
-    }
-
-    // process results
-    const returnObj = {};
-    statement.bufferRowIndex = 0;
-    const bindVars = thinUtil.getBindVars(statement);
-    const outBinds = thinUtil.getExecuteManyOutBinds(bindVars, numIters);
-    if (outBinds) {
-      returnObj.outBinds = outBinds;
-    }
-    const rowsAffected = !statement.isPlSql ? statement.rowCount : undefined;
-    if (rowsAffected) {
-      returnObj.rowsAffected = rowsAffected;
-      delete statement.rowCount;
-    }
-    if (options.dmlRowCounts) {
-      returnObj.dmlRowCounts = options.dmlRowCounts;
-    }
-    if (options.batchErrors) {
-      returnObj.batchErrors = options.batchErrors;
+  async execute(sql, numIters, binds, options, executeManyFlag) {
+    const statement = this._prepare(sql, options);
+    try {
+      return await this._execute(statement, numIters, binds, options,
+        executeManyFlag);
+    } catch (err) {
+      this._returnStatement(statement);
+      throw err;
     }
-    this._returnStatement(statement);
-
-    return returnObj;
   }
 
   //---------------------------------------------------------------------------
@@ -1100,6 +1088,47 @@ class ThinConnectionImpl extends ConnectionImpl {
   getInstanceName() {
     return this.instanceName;
   }
-}
 
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database domain name associated with the connection.
+  //---------------------------------------------------------------------------
+  getDbDomain() {
+    return this.dbDomain;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database name associated with the connection.
+  //---------------------------------------------------------------------------
+  getDbName() {
+    return this.dbName;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns maximum number of cursors that can be opened in one session.
+  //---------------------------------------------------------------------------
+  getMaxOpenCursors() {
+    return this.maxOpenCursors;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database service name associated with the connection.
+  //---------------------------------------------------------------------------
+  getServiceName() {
+    return this.serviceName;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns boolean based on this._protocol.txnInProgress value.
+  //---------------------------------------------------------------------------
+  getTransactionInProgress() {
+    return this._protocol.txnInProgress === constants.TNS_TXN_IN_PROGRESS;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the warning object.
+  //---------------------------------------------------------------------------
+  getWarning() {
+    return this.warning;
+  }
+}
 module.exports = ThinConnectionImpl;