1. module ibm_db
   1. function ibm_db (options)
   2. function ibm_db.Database (options)
   3. function ibm_db.ODBC ()
   4. function ibm_db.ODBCConnection ()
   5. function ibm_db.ODBCResult ()
   6. function ibm_db.ODBCStatement ()
   7. function ibm_db.Pool (_options)
   8. function ibm_db.close (db)
   9. function ibm_db.debug (x)
   10. function ibm_db.getElapsedTime ()
   11. function ibm_db.open (connStr, options, cb)
   12. function ibm_db.openSync (connStr, options)
   13. function ibm_db.simple_queue ()
   14. number ibm_db.FETCH_ARRAY
   15. number ibm_db.FETCH_OBJECT
   16. number ibm_db.SQL_CLOSE
   17. number ibm_db.SQL_DESTROY
   18. number ibm_db.SQL_DROP
   19. number ibm_db.SQL_RESET_PARAMS
   20. number ibm_db.SQL_UNBIND
   21. object ibm_db.Database.prototype
   22. object ibm_db.ODBC.prototype
   23. object ibm_db.ODBCConnection.prototype
   24. object ibm_db.ODBCResult.prototype
   25. object ibm_db.ODBCStatement.prototype
   26. object ibm_db.Pool.prototype
   27. object ibm_db.simple_queue.prototype
2. module ibm_db.Database
   1. function ibm_db.Database (options)
3. module ibm_db.Database.prototype
   1. function ibm_db.Database.prototype.beginTransaction (cb)
   2. function ibm_db.Database.prototype.beginTransactionSync ()
   3. function ibm_db.Database.prototype.close (cb)
   4. function ibm_db.Database.prototype.closeSync ()
   5. function ibm_db.Database.prototype.columns (catalog, schema, table, column, callback)
   6. function ibm_db.Database.prototype.commitTransaction (cb)
   7. function ibm_db.Database.prototype.commitTransactionSync ()
   8. function ibm_db.Database.prototype.describe (obj, callback)
   9. function ibm_db.Database.prototype.endTransaction (rollback, cb)
   10. function ibm_db.Database.prototype.endTransactionSync (rollback)
   11. function ibm_db.Database.prototype.fetchStreamingResults (results, stream)
   12. function ibm_db.Database.prototype.open (connStr, cb)
   13. function ibm_db.Database.prototype.openSync (connStr)
   14. function ibm_db.Database.prototype.prepare (sql, cb)
   15. function ibm_db.Database.prototype.prepareSync (sql)
   16. function ibm_db.Database.prototype.query (query, params, cb)
   17. function ibm_db.Database.prototype.queryResult (query, params, cb)
   18. function ibm_db.Database.prototype.queryResultSync (query, params)
   19. function ibm_db.Database.prototype.queryStream (sql, params)
   20. function ibm_db.Database.prototype.querySync (query, params)
   21. function ibm_db.Database.prototype.rollbackTransaction (cb)
   22. function ibm_db.Database.prototype.rollbackTransactionSync ()
   23. function ibm_db.Database.prototype.setIsolationLevel (isolationLevel)
   24. function ibm_db.Database.prototype.tables (catalog, schema, table, type, callback)
   25. number ibm_db.Database.prototype.FETCH_ARRAY
   26. number ibm_db.Database.prototype.FETCH_OBJECT
   27. number ibm_db.Database.prototype.SQL_CLOSE
   28. number ibm_db.Database.prototype.SQL_DESTROY
   29. number ibm_db.Database.prototype.SQL_DROP
   30. number ibm_db.Database.prototype.SQL_RESET_PARAMS
   31. number ibm_db.Database.prototype.SQL_UNBIND
4. module ibm_db.ODBC
   1. function ibm_db.ODBC ()
   2. number ibm_db.ODBC.FETCH_ARRAY
   3. number ibm_db.ODBC.FETCH_OBJECT
   4. number ibm_db.ODBC.SQL_CLOSE
   5. number ibm_db.ODBC.SQL_DESTROY
   6. number ibm_db.ODBC.SQL_DROP
   7. number ibm_db.ODBC.SQL_RESET_PARAMS
   8. number ibm_db.ODBC.SQL_UNBIND
5. module ibm_db.ODBC.prototype
   1. function ibm_db.ODBC.prototype.createConnection ()
   2. function ibm_db.ODBC.prototype.createConnectionSync ()
6. module ibm_db.ODBCConnection
   1. function ibm_db.ODBCConnection ()
7. module ibm_db.ODBCConnection.prototype
   1. function ibm_db.ODBCConnection.prototype.beginTransaction ()
   2. function ibm_db.ODBCConnection.prototype.beginTransactionSync ()
   3. function ibm_db.ODBCConnection.prototype.close ()
   4. function ibm_db.ODBCConnection.prototype.closeSync ()
   5. function ibm_db.ODBCConnection.prototype.columns ()
   6. function ibm_db.ODBCConnection.prototype.createStatement ()
   7. function ibm_db.ODBCConnection.prototype.createStatementSync ()
   8. function ibm_db.ODBCConnection.prototype.endTransaction ()
   9. function ibm_db.ODBCConnection.prototype.endTransactionSync ()
   10. function ibm_db.ODBCConnection.prototype.open ()
   11. function ibm_db.ODBCConnection.prototype.openSync ()
   12. function ibm_db.ODBCConnection.prototype.query ()
   13. function ibm_db.ODBCConnection.prototype.querySync ()
   14. function ibm_db.ODBCConnection.prototype.setIsolationLevel ()
   15. function ibm_db.ODBCConnection.prototype.tables ()
8. module ibm_db.ODBCResult
   1. function ibm_db.ODBCResult ()
9. module ibm_db.ODBCResult.prototype
   1. function ibm_db.ODBCResult.prototype.closeSync ()
   2. function ibm_db.ODBCResult.prototype.fetch ()
   3. function ibm_db.ODBCResult.prototype.fetchAll ()
   4. function ibm_db.ODBCResult.prototype.fetchAllSync ()
   5. function ibm_db.ODBCResult.prototype.fetchSync ()
   6. function ibm_db.ODBCResult.prototype.getColumnNamesSync ()
   7. function ibm_db.ODBCResult.prototype.moreResultsSync ()
10. module ibm_db.ODBCStatement
    1. function ibm_db.ODBCStatement ()
11. module ibm_db.ODBCStatement.prototype
    1. function ibm_db.ODBCStatement.prototype._bind ()
    2. function ibm_db.ODBCStatement.prototype._bindSync ()
    3. function ibm_db.ODBCStatement.prototype._execute ()
    4. function ibm_db.ODBCStatement.prototype._executeDirect ()
    5. function ibm_db.ODBCStatement.prototype._executeDirectSync ()
    6. function ibm_db.ODBCStatement.prototype._executeNonQuery ()
    7. function ibm_db.ODBCStatement.prototype._executeNonQuerySync ()
    8. function ibm_db.ODBCStatement.prototype._executeSync ()
    9. function ibm_db.ODBCStatement.prototype._prepare ()
    10. function ibm_db.ODBCStatement.prototype.bind (ary, cb)
    11. function ibm_db.ODBCStatement.prototype.bindSync (ary)
    12. function ibm_db.ODBCStatement.prototype.closeSync ()
    13. function ibm_db.ODBCStatement.prototype.execute (params, cb)
    14. function ibm_db.ODBCStatement.prototype.executeDirect (sql, cb)
    15. function ibm_db.ODBCStatement.prototype.executeDirectSync ()
    16. function ibm_db.ODBCStatement.prototype.executeNonQuery (params, cb)
    17. function ibm_db.ODBCStatement.prototype.executeNonQuerySync ()
    18. function ibm_db.ODBCStatement.prototype.executeSync (params)
    19. function ibm_db.ODBCStatement.prototype.prepare (sql, cb)
    20. function ibm_db.ODBCStatement.prototype.prepareSync ()
12. module ibm_db.Pool
    1. function ibm_db.Pool (_options)
    2. number ibm_db.Pool.count
13. module ibm_db.Pool.prototype
    1. function ibm_db.Pool.prototype.cleanUp (connStr, callback)
    2. function ibm_db.Pool.prototype.close (callback)
    3. function ibm_db.Pool.prototype.init (count, connStr)
    4. function ibm_db.Pool.prototype.open (connStr, callback)
    5. function ibm_db.Pool.prototype.setConnectTimeout (timeout)
    6. function ibm_db.Pool.prototype.setMaxPoolSize (size)
14. module ibm_db.simple_queue
    1. function ibm_db.simple_queue ()
15. module ibm_db.simple_queue.prototype
    1. function ibm_db.simple_queue.prototype.maybeNext ()
    2. function ibm_db.simple_queue.prototype.next ()
    3. function ibm_db.simple_queue.prototype.push (fn)

module ibm_db

function ibm_db (options)

• description and source-code

  ibm_db = function (options)
  {
    return new Database(options);
  }

• example usage

  n/a

function ibm_db.Database (options)

• description and source-code

  function Database(options)
  {
    var self = this;
  
    options = options || {};
  
    self.odbc = (options.odbc) ? options.odbc : ((ENV) ? ENV : new odbc.ODBC());
    if(!ENV) ENV = self.odbc;
    self.queue = new SimpleQueue();
    self.fetchMode = options.fetchMode || null;
    self.connected = false;
    self.connectTimeout = options.connectTimeout || null;
    self.systemNaming = options.systemNaming;
  }

• example usage

  ...
  ### Using node < v0.10 on Linux
  
  Be aware that through node v0.9 the uv_queue_work function, which is used to
  execute the ODBC functions on a separate thread, uses libeio for its thread
  pool. This thread pool by default is limited to 4 threads.
  
  This means that if you have long running queries spread across multiple
  instances of ibmdb.Database() or using odbc.Pool(), you will only be able to
  have 4 concurrent queries.
  
  You can increase the thread pool size by using @developmentseed's [node-eio]
  (https://github.com/developmentseed/node-eio).
  
  #### install:
  ```bash
  ...

function ibm_db.ODBC ()

• description and source-code

  function ODBC() { [native code] }

• example usage

  ...
  var odbc = require("bindings")("odbc_bindings")
  , SimpleQueue = require("./simple-queue")
  , util = require("util")
  , Readable = require('stream').Readable
  , Q = require('q');
  
  
  // Call of odbc.ODBC() loads odbc library and allocate environment handle.
  // All calls of new Database() should use this same odbc unless passed as
  // options.odbc. ENV will keep value of this odbc after first call of Database.
  var ENV;
  
  module.exports = function (options)
  {
  return new Database(options);
  ...

function ibm_db.ODBCConnection ()

• description and source-code

  function ODBCConnection() { [native code] }

• example usage

  n/a

function ibm_db.ODBCResult ()

• description and source-code

  function ODBCResult() { [native code] }

• example usage

  n/a

function ibm_db.ODBCStatement ()

• description and source-code

  function ODBCStatement() { [native code] }

• example usage

  n/a

function ibm_db.Pool (_options)

• description and source-code

  function Pool(_options) {
    var self = this;
    self.options = {};
    self.maxPoolSize = 0;
    if(_options)
    {
      if(_options.idleTimeout && !isNaN(_options.idleTimeout))
        self.options.idleTimeout = _options.idleTimeout;
      if(_options.autoCleanIdle)
        self.options.autoCleanIdle = _options.autoCleanIdle;
      if(_options.maxPoolSize)
        self.maxPoolSize = _options.maxPoolSize;
      if(_options.connectTimeout)
        self.options.connectTimeout = _options.connectTimeout;
      if(_options.systemNaming)
        self.options.systemNaming=_options.systemNaming;
    }
    self.index = Pool.count++;
    self.availablePool = {};
    self.usedPool = {};
    self.poolSize = 0;
    if(!ENV) ENV = new odbc.ODBC();
    self.odbc = ENV;
    self.options.connectTimeout = self.options.connectTimeout || 60;
  }

• example usage

  ...
  ### Using node < v0.10 on Linux
  
  Be aware that through node v0.9 the uv_queue_work function, which is used to
  execute the ODBC functions on a separate thread, uses libeio for its thread
  pool. This thread pool by default is limited to 4 threads.
  
  This means that if you have long running queries spread across multiple
  instances of ibmdb.Database() or using odbc.Pool(), you will only be able to
  have 4 concurrent queries.
  
  You can increase the thread pool size by using @developmentseed's [node-eio]
  (https://github.com/developmentseed/node-eio).
  
  #### install:
  ```bash
  ...

function ibm_db.close (db)

• description and source-code

  close = function (db)
  {
    if(db && typeof(db) === "object")
    {
      for(key in db)
      {
        delete db[key];
      }
      delete db;
      db = undefined;
    }
  }

• example usage

  ...
  
  * Update build.zip and defautl connection timeout. (Bimal Jha)
  
  * Exit with error code on installation errors, to allow failure detection by automated build tools (Michael Szlapa)
  
  * Add pool related test files. (Bimal Jha)
  
  * Update conn.close() for Pool to avoid reconnection before moving to available pool.
  Add pool related test files and update existing test files. (Bimal Jha)
  
  * update examples (Bimal Jha)
  
  * Updating the new build.zip for windows (Bimal Jha)
  
  * delete build.zip file on ntx64 after unzip (bimaljha)
  ...

function ibm_db.debug (x)

• description and source-code

  debug = function (x) {
      if(x) {
          exports.debug = true;
          console.log("node-ibm_db logs enabled.");
      }
      else {
          exports.debug = false;
          console.log("node-ibm_db logs disabled.");
      }
  }

• example usage

  ...
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  
  *   [**Connection Pooling APIs**](#PoolAPIs)
  *   [**bindingParameters**](#bindParameters)
  *   [**CALL Statement**](#callStmt)
  *   [**Build Options**](#buildOptions)
  ...

function ibm_db.getElapsedTime ()

• description and source-code

  getElapsedTime = function (){
  var tstamp = (new Date() - ibmdbStartTime)/1000.0;
  //process.stdout.write(tstamp + " :: ");
  return (tstamp + " :: ");
  }

• example usage

  n/a

function ibm_db.open (connStr, options, cb)

• description and source-code

  open = function (connStr, options, cb)
  {
    var db, deferred;
  
    var DBFactory = function(options) {
      return new Database(options);
    };
  
    if (!cb && typeof options !== 'function')
    {
      if(!options)
      {
        options = null;
      }
      db = DBFactory(options);
      deferred = Q.defer();
      db.open(connStr, function(err) {
        if (err)
        {
          deferred.reject(err);
        }
        else
        {
          deferred.resolve(db);
        }
      });
      return deferred.promise;
    }
  
    else if (typeof options === 'function')
    {
      cb = options;
      options = null;
    }
  
    db = DBFactory(options);
  
    db.open(connStr, function (err) {
      cb(err, db);
    });
  }

• example usage

  ...
  
  ## Quick Example
  ------------------
  
  ```javascript
  var ibmdb = require('ibm_db');
  
  ibmdb.open("DATABASE=<dbname>;HOSTNAME=<myhost>;UID=db2user;
  PWD=password;PORT=<dbport>;PROTOCOL=TCPIP", function (err,conn) {
    if (err) return console.log(err);
  
    conn.query('select 1 from sysibm.sysdummy1', function (err, data) {
  if (err) console.log(err);
  else console.log(data);
  
  conn.close(function () {
  ...

function ibm_db.openSync (connStr, options)

• description and source-code

  openSync = function (connStr, options)
  {
    var db = new Database(options);
    db.openSync(connStr);
    return db;
  }

• example usage

  ...
  
  ```javascript
  var Database = require("ibm_db").Database
    , ibmdb = new Database();
  ```
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  ...

function ibm_db.simple_queue ()

• description and source-code

  function SimpleQueue() {
    var self = this;
  
    self.fifo = [];
    self.executing = false;
  }

• example usage

  n/a

module ibm_db.Database

function ibm_db.Database (options)

• description and source-code

  function Database(options)
  {
    var self = this;
  
    options = options || {};
  
    self.odbc = (options.odbc) ? options.odbc : ((ENV) ? ENV : new odbc.ODBC());
    if(!ENV) ENV = self.odbc;
    self.queue = new SimpleQueue();
    self.fetchMode = options.fetchMode || null;
    self.connected = false;
    self.connectTimeout = options.connectTimeout || null;
    self.systemNaming = options.systemNaming;
  }

• example usage

  ...
  ### Using node < v0.10 on Linux
  
  Be aware that through node v0.9 the uv_queue_work function, which is used to
  execute the ODBC functions on a separate thread, uses libeio for its thread
  pool. This thread pool by default is limited to 4 threads.
  
  This means that if you have long running queries spread across multiple
  instances of ibmdb.Database() or using odbc.Pool(), you will only be able to
  have 4 concurrent queries.
  
  You can increase the thread pool size by using @developmentseed's [node-eio]
  (https://github.com/developmentseed/node-eio).
  
  #### install:
  ```bash
  ...

module ibm_db.Database.prototype

function ibm_db.Database.prototype.beginTransaction (cb)

• description and source-code

  beginTransaction = function (cb)
  {
    var self = this
        , deferred = null
        , onBeginTransaction;
    if(!cb)
    {
      deferred = Q.defer();
      onBeginTransaction = function(err)
      {
        if(err)
        {
          deferred.reject(err);
        }
        else
        {
          deferred.resolve(true);
        }
      };
    }
  
    self.conn.beginTransaction(deferred ? onBeginTransaction : cb);
    self.conn.inTransaction = true;
  
    return deferred ? deferred.promise : self;
  }

• example usage

  ...
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  ...

function ibm_db.Database.prototype.beginTransactionSync ()

• description and source-code

  beginTransactionSync = function ()
  {
    var self = this;
  
    self.conn.beginTransactionSync();
    self.conn.inTransaction = true;
  
    return self;
  }

• example usage

  ...
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  
  *   [**Connection Pooling APIs**](#PoolAPIs)
  ...

function ibm_db.Database.prototype.close (cb)

• description and source-code

  close = function (cb)
  {
    var self = this, deferred;
    if(!cb)
    {
      deferred = Q.defer();
    }
  
    self.queue.push(function (next) {
      if(self.conn)
      {
        self.conn.close(function (err) {
          self.connected = false;
          delete self.conn;
  
          if (cb)
          {
            cb(err);
          } else
          {
            deferred.resolve(err);
          }
          return next();
        });
      }
      else
      {
        self.connected = false;
      }
    }); // self.queue.push
  
    return deferred ? deferred.promise : false;
  }

• example usage

  ...
  
  * Update build.zip and defautl connection timeout. (Bimal Jha)
  
  * Exit with error code on installation errors, to allow failure detection by automated build tools (Michael Szlapa)
  
  * Add pool related test files. (Bimal Jha)
  
  * Update conn.close() for Pool to avoid reconnection before moving to available pool.
  Add pool related test files and update existing test files. (Bimal Jha)
  
  * update examples (Bimal Jha)
  
  * Updating the new build.zip for windows (Bimal Jha)
  
  * delete build.zip file on ntx64 after unzip (bimaljha)
  ...

function ibm_db.Database.prototype.closeSync ()

• description and source-code

  closeSync = function ()
  {
    var self = this;
  
    var result;
    if(self.conn) result = self.conn.closeSync();
  
    self.connected = false;
    delete self.conn;
  
    return result
  }

• example usage

  ...
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  ...

function ibm_db.Database.prototype.columns (catalog, schema, table, column, callback)

• description and source-code

  columns = function (catalog, schema, table, column, callback)
  {
    var self = this;
    if (!self.queue) self.queue = [];
  
    callback = callback || arguments[arguments.length - 1];
  
    self.queue.push(function (next)
    {
      self.conn.columns(catalog, schema, table, column, function (err, result)
      {
        if (err) return callback(err, [], false);
  
        result.fetchAll(function (err, data)
        {
          result.closeSync();
          callback(err, data);
          return next();
        });
      });
    });
  }

• example usage

  ...
    var self = this;
    if (!self.queue) self.queue = [];
  
    callback = callback || arguments[arguments.length - 1];
  
    self.queue.push(function (next)
    {
      self.conn.columns(catalog, schema, table, column, function (err, result)
      {
  if (err) return callback(err, [], false);
  
  result.fetchAll(function (err, data)
  {
    result.closeSync();
    callback(err, data);
  ...

function ibm_db.Database.prototype.commitTransaction (cb)

• description and source-code

  commitTransaction = function (cb)
  {
    var self = this, deferred = null, onEndTransaction;
    if(!cb)
    {
      deferred = Q.defer();
      onEndTransaction = function(err)
      {
        if(err)
        {
          deferred.reject(err);
        }
        else
        {
          deferred.resolve(true);
        }
      };
    }
  
    //don't rollback
    self.conn.endTransaction(false, deferred ? onEndTransaction : cb);
    self.conn.inTransaction = false;
  
    return deferred ? deferred.promise : self;
  }

• example usage

  ...
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  
  *   [**Connection Pooling APIs**](#PoolAPIs)
  *   [**bindingParameters**](#bindParameters)
  ...

function ibm_db.Database.prototype.commitTransactionSync ()

• description and source-code

  commitTransactionSync = function ()
  {
    var self = this;
  
    self.conn.endTransactionSync(false); //don't rollback
    self.conn.inTransaction = false;
  
    return self;
  }

• example usage

  ...
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  
  *   [**Connection Pooling APIs**](#PoolAPIs)
  *   [**bindingParameters**](#bindParameters)
  *   [**CALL Statement**](#callStmt)
  ...

function ibm_db.Database.prototype.describe (obj, callback)

• description and source-code

  describe = function (obj, callback)
  {
    var self = this;
  
    if (typeof(callback) !== "function")
    {
      throw({
        error : "[node-odbc] Missing Arguments",
        message : "You must specify a callback function in order " +
                  "for the describe method to work."
      });
  
      return false;
    }
  
    if (typeof(obj) !== "object")
    {
      callback({
        error : "[node-odbc] Missing Arguments",
        message : "You must pass an object as argument 0 if you want " +
                  "anything productive to happen in the describe method."
      }, []);
  
      return false;
    }
  
    if (!obj.database)
    {
      callback({
        error : "[node-odbc] Missing Arguments",
        message : "The object you passed did not contain a database " +
                  "property. This is required for the describe method to work."
      }, []);
  
      return false;
    }
  
    //set some defaults if they weren't passed
    obj.schema = obj.schema || "%";
    obj.type = obj.type || "table";
  
    if (obj.table && obj.column)
    {
      //get the column details
      self.columns(obj.database, obj.schema, obj.table, obj.column, callback);
    }
    else if (obj.table)
    {
      //get the columns in the table
      self.columns(obj.database, obj.schema, obj.table, "%", callback);
    }
    else
    {
      //get the tables in the database
      self.tables(obj.database, obj.schema, null, obj.type || "table", callback);
    }
  }

• example usage

  ...
  	/*
  	 * In its most basic form you must call describe passing it an object which
  	 * contains the database name and a callback function.
  	 *
  	 * This will return a list of tables in the database for all schemas.
  	 */
  	
  	db.describe({
  		database : 'myAwesomeDatabase'
  	}, function (error, result) {
  		if (error) {
  			console.log(error);
  			return false;
  		}
  ...

function ibm_db.Database.prototype.endTransaction (rollback, cb)

• description and source-code

  endTransaction = function (rollback, cb)
  {
    var self = this;
  
    self.conn.endTransaction(rollback, cb);
    self.conn.inTransaction = false;
  
    return self;
  }

• example usage

  ...
    return deferred ? deferred.promise : self;
  };
  
  Database.prototype.endTransaction = function (rollback, cb)
  {
    var self = this;
  
    self.conn.endTransaction(rollback, cb);
    self.conn.inTransaction = false;
  
    return self;
  };
  
  Database.prototype.commitTransaction = function (cb)
  {
  ...

function ibm_db.Database.prototype.endTransactionSync (rollback)

• description and source-code

  endTransactionSync = function (rollback)
  {
    var self = this;
  
    self.conn.endTransactionSync(rollback);
    self.conn.inTransaction = false;
  
    return self;
  }

• example usage

  ...
    return self;
  };
  
  Database.prototype.endTransactionSync = function (rollback)
  {
    var self = this;
  
    self.conn.endTransactionSync(rollback);
    self.conn.inTransaction = false;
  
    return self;
  };
  
  Database.prototype.commitTransactionSync = function ()
  {
  ...

function ibm_db.Database.prototype.fetchStreamingResults (results, stream)

• description and source-code

  fetchStreamingResults = function (results, stream)
  {
    var self = this;
    return results.fetch(function (err, data)
    {
      if (err)
      {
        return process.nextTick(function () { stream.emit('error', err); });
      }
      // when no more data returns, return push null to indicate the end of stream
      if (!data)
      {
        return stream.push(null);
      }
      // if pushing the data returns 'true', that means we can query and push more
      // immediately othewise the _read function will be called again (executing
      // this function) once the reading party is ready to recieve more
      if (stream.push(data))
      {
        return self.fetchStreamingResults(results, stream);
      }
    });
  }

• example usage

  ...
    var self = this;
    var stream = new Readable({ objectMode: true });
    var results;
    stream._read = function()
    {
  // after the first internal call to _read, the 'results' should be set
  // and the stream can continue fetching the results
  if (results) return self.fetchStreamingResults(results, stream);
  
  // in the first call to _read the stream starts to emit data once we've
  // queried for results
  return self.queryResult(sql, params, function (err, result)
  {
    if (err)
    {
  ...

function ibm_db.Database.prototype.open (connStr, cb)

• description and source-code

  open = function (connStr, cb) {
    var self = this, deferred;
  
    if (typeof(connStr) === "object")
    {
      var obj = connStr;
      connStr = "";
  
      Object.keys(obj).forEach(function (key) {
        connStr += key + "=" + obj[key] + ";";
      });
    }
  
    if (!cb)
    {
      deferred = Q.defer();
    }
  
    self.odbc.createConnection(function (err, conn) {
      if(!cb)
      {
        if (err) deferred.reject(err);
      } else
      {
        if (err) return cb(err);
      }
  
      self.conn = conn;
  
      if (self.connectTimeout || self.connectTimeout === 0)
      {
        self.conn.connectTimeout = self.connectTimeout;
      }
      if (typeof(self.systemNaming) !== 'undefined')
      {
        self.conn.systemNaming = self.systemNaming;
      }
  
      self.conn.open(connStr, function (err, result)
      {
        if(cb)
        {
          if (err) return cb(err);
  
          self.connected = true;
  
          return cb(err, result);
        }
        else
        {
          if(err) deferred.reject(err);
  
          self.connected = true;
          deferred.resolve(result);
        }
      }); //conn.open
    }); // odbc.createConnection
  
    return deferred ? deferred.promise : null;
  }

• example usage

  ...
  
  ## Quick Example
  ------------------
  
  ```javascript
  var ibmdb = require('ibm_db');
  
  ibmdb.open("DATABASE=<dbname>;HOSTNAME=<myhost>;UID=db2user;
  PWD=password;PORT=<dbport>;PROTOCOL=TCPIP", function (err,conn) {
    if (err) return console.log(err);
  
    conn.query('select 1 from sysibm.sysdummy1', function (err, data) {
  if (err) console.log(err);
  else console.log(data);
  
  conn.close(function () {
  ...

function ibm_db.Database.prototype.openSync (connStr)

• description and source-code

  openSync = function (connStr)
  {
    var self =  this;
  
    self.conn = self.odbc.createConnectionSync();
  
    if (self.connectTimeout || self.connectTimeout === 0)
    {
      self.conn.connectTimeout = self.connectTimeout;
    }
    if (typeof(self.systemNaming) !== 'undefined')
    {
      self.conn.systemNaming = self.systemNaming;
    }
  
    if (typeof(connStr) === "object")
    {
      var obj = connStr;
      connStr = "";
  
      Object.keys(obj).forEach(function (key) {
        connStr += key + "=" + obj[key] + ";";
      });
    }
  
    var result = self.conn.openSync(connStr);
  
    if (result)
    {
      self.connected = true;
    }
  
    return result;
  }

• example usage

  ...
  
  ```javascript
  var Database = require("ibm_db").Database
    , ibmdb = new Database();
  ```
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  ...

function ibm_db.Database.prototype.prepare (sql, cb)

• description and source-code

  prepare = function (sql, cb)
  {
    var self = this, deferred;
  
    if(!cb)
    {
      deferred = Q.defer();
    }
  
    self.conn.createStatement(function (err, stmt)
    {
      if(err)
      {
        if(cb)
        {
          return cb(err);
        } else
        {
          deferred.reject(err);
        }
      }
  
      stmt.queue = new SimpleQueue();
  
      stmt.prepare(sql, function (err)
      {
        if (err)
        {
          if(cb)
          {
            return cb(err);
          } else
          {
            deferred.reject(err)
          }
        }
  
        deferred ? deferred.resolve(stmt) : cb(null, stmt);
      });
    });
    return deferred ? deferred.promise : null;
  }

• example usage

  ...
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  ...

function ibm_db.Database.prototype.prepareSync (sql)

• description and source-code

  prepareSync = function (sql)
  {
    var self = this;
  
    var stmt = self.conn.createStatementSync();
  
    stmt.queue = new SimpleQueue();
  
    stmt.prepareSync(sql);
  
    return stmt;
  }

• example usage

  ...
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  ...

function ibm_db.Database.prototype.query (query, params, cb)

• description and source-code

  query = function (query, params, cb)
  {
    var self = this, deferred, sql, resultset = [], multipleResultSet = false;
  
    exports.debug && console.log(getElapsedTime(), "odbc.js:query() => Entry");
    //support for promises
    if (!cb && typeof params !== 'function')
    {
      deferred = Q.defer();
      !params ? params = null : '';
    }
  
    if (typeof(params) === 'function')
    {
      cb = params;
      params = null;
    }
  
    if (!self.connected)
    {
      deferred ? deferred.reject({ message : "Connection not open."}) :
                 cb({ message : "Connection not open."}, [], false);
      return deferred ?  deferred.promise : false;
    }
  
    self.queue.push(function (next) {
      function cbQuery (initialErr, result, outparams)
      {
        if(outparams) {
          resultset = outparams;
          multipleResultSet = true;
        }
        if (result && typeof(result) === 'object') {
          fetchMore();
        } else {
          cb(initialErr, resultset);
          return next();
        }
  
        function fetchMore()
        {
          if (self.fetchMode)
          {
            result.fetchMode = self.fetchMode;
          }
  
          result.fetchAll(function (err, data, rowcount) {
            var moreResults = false, moreResultsError = null;
  
            // If there is any error, return it now only.
            if( err || initialErr )
            {
              // For pooled connection, if we get SQL30081N, then close
              // the connection now only and then proceed.
              if(self.realClose){
                if((err && err['message'] &&
                        err['message'].search("SQL30081N") != -1) ||
                   (initialErr && initialErr['message'] &&
                    initialErr['message'].search("SQL30081N") != -1))
                {
                  self.closeSync();
                }
              }
              if(multipleResultSet) resultset.push(data);
              else resultset = data;
              deferred ? deferred.reject(initialErr || err) : cb(initialErr || err, resultset);
              result.closeSync();
              initialErr = null;
              err = null;
              return next();
            }
  
            // Get the result data
            try
            {
              if(rowcount)  // Check for more result set.
                  moreResults = result.moreResultsSync();
            }
            catch (e)
            {
              moreResultsError = e;
              moreResults = false;
            }
  
            //close the result before calling back
            //if there are not more result sets
            if (moreResults)
            {
                if( data.length ) resultset.push(data);
                multipleResultSet = true;
                fetchMore();
            }
            else
            {
              result.closeSync();
              if( data.length ) {
                if(multipleResultSet) resultset.push(data);
                else resultset = data;
              }
  
              exports.debug && console.log(getElapsedTime(), "odbc.js:query() => Done.");
              // send exception error and/or data to callback function.
              // only once with all the results.
              !cb ? deferred.resolve(resultset) : cb(moreResultsError, resultset);
            }
  
            moreResultsError = null;
            return next();
          });
        }
      } //function cbQuery
  
      if(typeof query === "object")
      {
          sql = query.sql;
          if(query.params) params = query.params;
      }
      else
      {
          sql = query;
      }
      exports.debug && console.log(getElapsedTime(), "odbc.js:query() => ", sql);
      if (params)
      {
        if(Array.isArray(params))
        {
          var err = parseParams(params);
          if(err) deferred ? deferred.reject(err) : cb(err);
        }
        if(typeof query === 'object')
        {
            query.params = params;
            self.conn.query(query, cbQuery);
        }
        else
            self.conn.query(query, params, cbQuery);
      }
      else
      {
        self.conn.query(query, cbQuery);
      }
    }); //self.queue.push
    return deferred ? deferred.promise : false;
  }

• example usage

  ...
  
  ```javascript
  var ibmdb = require('ibm_db');
  
  ibmdb.open("DATABASE=<dbname>;HOSTNAME=<myhost>;UID=db2user;PWD=password;PORT=<dbport>;PROTOCOL
  =TCPIP", function (err,conn) {
  if (err) return console.log(err);
  
  conn.query('select 1 from sysibm.sysdummy1', function (err, data) {
    if (err) console.log(err);
    else console.log(data);
  
    conn.close(function () {
      console.log('done');
    });
  });
  ...

function ibm_db.Database.prototype.queryResult (query, params, cb)

• description and source-code

  queryResult = function (query, params, cb)
  {
    var self = this, sql;
  
    if (typeof(params) === 'function')
    {
      cb = params;
      params = null;
    }
  
    if (!self.connected)
    {
      return cb({ message : "Connection not open."}, null);
    }
  
    if(typeof query === "object")
    {
        sql = query.sql;
        if(query.params) params = query.params;
    }
    else
    {
        sql = query;
    }
  
    exports.debug && console.log(getElapsedTime(), "odbc.js:queryResult() => ", sql);
    self.queue.push(function (next) {
      //ODBCConnection.query() is the fastest-path querying mechanism.
      if (params)
      {
        if(Array.isArray(params))
        {
          var err = parseParams(params);
          if(err) cb(err);
        }
        if(typeof query === 'object')
        {
          query.params = params;
          self.conn.query(query, cbQuery);
        }
        else
          self.conn.query(sql, params, cbQuery);
      }
      else
      {
        self.conn.query(sql, cbQuery);
      }
  
      function cbQuery (err, result)
      {
        if (err)
        {
          cb(err, null);
          return next();
        }
  
        if (self.fetchMode)
        {
          result.fetchMode = self.fetchMode;
        }
  
        cb(err, result);
  
        return next();
      } // function cbQuery
    }); //self.queue.push
  }

• example usage

  ...
  conn.openSync(cn);
  
  // create table and insert some rows to it.
  conn.querySync("create table mytab (c1 int, c2 varchar(20))");
  conn.querySync("insert into mytab values (1, 'bimal'),(2, 'kamal'),(3,'mohan'),(4,'ram&#
  x27;)");
  
  // Select data from table
  conn.queryResult("select * from mytab", function (err, result) {
  if(err) {
    console.log(err);
    return;
  }
  
  // Fetch single row at once and process it.
  // Note that queryResult will bring only 64k data from server and result.fetchSync
  ...

function ibm_db.Database.prototype.queryResultSync (query, params)

• description and source-code

  queryResultSync = function (query, params)
  {
    var self = this, result, sql;
  
    if (!self.connected)
    {
      throw ({ message : "Connection not open."});
    }
  
    if(typeof query === "object")
    {
        sql = query.sql;
        if(query.params) params = query.params;
    }
    else
    {
        sql = query;
    }
  
    exports.debug && console.log(getElapsedTime(), "odbc.js:queryResultSync() => ", sql);
    if (params)
    {
      if(Array.isArray(params))
      {
          var err = parseParams(params);
          if(err) cb(err);
      }
      if(sql.search(/^call /i))
      {
        if(typeof query === 'object')
        {
          query.params = params;
          self.conn.querySync(query);
        }
        else
          result = self.conn.querySync(sql, params);
      }
      else // Its a CALL statement.
      {
        result = self.conn.querySync({"sql":sql, "params":params, "noResults":true});
        return result;
      }
    }
    else
    {
      result = self.conn.querySync(sql);
    }
  
    if (self.fetchMode)
    {
      result.fetchMode = self.fetchMode;
    }
  
    return result;
  }

• example usage

  n/a

function ibm_db.Database.prototype.queryStream (sql, params)

• description and source-code

  function queryStream(sql, params)
  {
    var self = this;
    var stream = new Readable({ objectMode: true });
    var results;
    stream._read = function()
    {
      // after the first internal call to _read, the 'results' should be set
      // and the stream can continue fetching the results
      if (results) return self.fetchStreamingResults(results, stream);
  
      // in the first call to _read the stream starts to emit data once we've
      // queried for results
      return self.queryResult(sql, params, function (err, result)
      {
        if (err)
        {
          return process.nextTick(function () { stream.emit('error', err); });
        }
        results = result;
        return self.fetchStreamingResults(results, stream);
      });
    };
    return stream;
  }

• example usage

  ...
    , ibmdb = new Database();
  ```
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  ...

function ibm_db.Database.prototype.querySync (query, params)

• description and source-code

  querySync = function (query, params)
  {
    var self = this, result, sql, outparams = null;
  
    if (!self.connected)
    {
      throw ({ message : "Connection not open."});
    }
  
    if(typeof query === "object")
    {
        sql = query.sql;
        if(query.params) params = query.params;
    }
    else
    {
        sql = query;
    }
  
    exports.debug && console.log(getElapsedTime(), "odbc.js:querySync() => ", sql);
    if (params)
    {
      if(Array.isArray(params))
      {
          var err = parseParams(params);
          if(err) return err;
      }
      if(typeof query === 'object')
      {
          query.params = params;
          result = self.conn.querySync(query);
      }
      else
      {
        result = self.conn.querySync(sql, params);
      }
    }
    else
    {
      result = self.conn.querySync(query);
    }
  
    if(Array.isArray(result))
    {
      if(result[1]) {
          outparams = result[1]; // INOUT and OUT param values for SP.
      }
      result = result[0];
    }
    if(!result) return outparams;  // For noResults.
  
    // Processing for resultset.
    var data, resultset = [], moreResults = true, moreResultsError = null;
    var nullresult = true;
  
    if(outparams) {
        resultset = outparams;
        nullresult = false;
    }
    if (self.fetchMode)
    {
      result.fetchMode = self.fetchMode;
    }
  
    while(moreResults)
    {
        data = result.fetchAllSync();
        if(!data.length) {
            moreResults = false;
            break;
        }
        try
        {
            moreResults = result.moreResultsSync();
        }
        catch (e)
        {
            moreResultsError = e;
            moreResults = false;
            break;
        }
        if(data.length) {
            if(nullresult && !moreResults) resultset = data;
            else resultset.push(data);
            nullresult = false;
        }
    }
    result.closeSync();
  
    if(moreResultsError) return moreResultsError;
    if(nullresult) return [];
  
    return resultset;
  }

• example usage

  ...
  var Database = require("ibm_db").Database
    , ibmdb = new Database();
  ```
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  ...

function ibm_db.Database.prototype.rollbackTransaction (cb)

• description and source-code

  rollbackTransaction = function (cb)
  {
    var self = this, deferred = null, onEndTransaction;
    if(!cb) {
      deferred = Q.defer();
      onEndTransaction = function(err) {
        if(err) {
          deferred.reject(err);
        }
        else {
          deferred.resolve(true);
        }
      };
    }
  
    self.conn.endTransaction(true, deferred ? onEndTransaction : cb); //rollback
    self.conn.inTransaction = false;
  
    return deferred ? deferred.promise : self;
  }

• example usage

  ...
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  
  *   [**Connection Pooling APIs**](#PoolAPIs)
  *   [**bindingParameters**](#bindParameters)
  *   [**CALL Statement**](#callStmt)
  *   [**Build Options**](#buildOptions)
  ...

function ibm_db.Database.prototype.rollbackTransactionSync ()

• description and source-code

  rollbackTransactionSync = function ()
  {
    var self = this;
  
    self.conn.endTransactionSync(true); //rollback
    self.conn.inTransaction = false;
  
    return self;
  }

• example usage

  ...
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  
  *   [**Connection Pooling APIs**](#PoolAPIs)
  *   [**bindingParameters**](#bindParameters)
  *   [**CALL Statement**](#callStmt)
  *   [**Build Options**](#buildOptions)
  ...

function ibm_db.Database.prototype.setIsolationLevel (isolationLevel)

• description and source-code

  setIsolationLevel = function (isolationLevel)
  {
    var self = this;
    return (self.conn.setIsolationLevel(isolationLevel));
  }

• example usage

  ...
  
    return stmt;
  };
  
  Database.prototype.setIsolationLevel = function(isolationLevel)
  {
    var self = this;
    return (self.conn.setIsolationLevel(isolationLevel));
  };
  
  //Proxy all of the ODBCStatement functions so that they are queued
  odbc.ODBCStatement.prototype._execute = odbc.ODBCStatement.prototype.execute;
  odbc.ODBCStatement.prototype._executeSync = odbc.ODBCStatement.prototype.executeSync;
  odbc.ODBCStatement.prototype._executeDirect = odbc.ODBCStatement.prototype.executeDirect;
  odbc.ODBCStatement.prototype._executeDirectSync = odbc.ODBCStatement.prototype.executeDirectSync;
  ...

function ibm_db.Database.prototype.tables (catalog, schema, table, type, callback)

• description and source-code

  tables = function (catalog, schema, table, type, callback)
  {
    var self = this;
    if (!self.queue) self.queue = [];
  
    callback = callback || arguments[arguments.length - 1];
  
    self.queue.push(function (next)
    {
      self.conn.tables(catalog, schema, table, type, function (err, result)
      {
        if (err) return callback(err, [], false);
  
        result.fetchAll(function (err, data)
        {
          result.closeSync();
          callback(err, data);
          return next();
        });
      });
    });
  }

• example usage

  ...
    var self = this;
    if (!self.queue) self.queue = [];
  
    callback = callback || arguments[arguments.length - 1];
  
    self.queue.push(function (next)
    {
      self.conn.tables(catalog, schema, table, type, function (err, result)
      {
  if (err) return callback(err, [], false);
  
  result.fetchAll(function (err, data)
  {
    result.closeSync();
    callback(err, data);
  ...

module ibm_db.ODBC

function ibm_db.ODBC ()

• description and source-code

  function ODBC() { [native code] }

• example usage

  ...
  var odbc = require("bindings")("odbc_bindings")
  , SimpleQueue = require("./simple-queue")
  , util = require("util")
  , Readable = require('stream').Readable
  , Q = require('q');
  
  
  // Call of odbc.ODBC() loads odbc library and allocate environment handle.
  // All calls of new Database() should use this same odbc unless passed as
  // options.odbc. ENV will keep value of this odbc after first call of Database.
  var ENV;
  
  module.exports = function (options)
  {
  return new Database(options);
  ...

module ibm_db.ODBC.prototype

function ibm_db.ODBC.prototype.createConnection ()

• description and source-code

  function createConnection() { [native code] }

• example usage

  ...
  }
  
  if (!cb)
  {
    deferred = Q.defer();
  }
  
  self.odbc.createConnection(function (err, conn) {
    if(!cb)
    {
      if (err) deferred.reject(err);
    } else
    {
      if (err) return cb(err);
    }
  ...

function ibm_db.ODBC.prototype.createConnectionSync ()

• description and source-code

  function createConnectionSync() { [native code] }

• example usage

  ...
  return deferred ? deferred.promise : null;
  }; // Database.open function
  
  Database.prototype.openSync = function (connStr)
  {
  var self =  this;
  
  self.conn = self.odbc.createConnectionSync();
  
  if (self.connectTimeout || self.connectTimeout === 0)
  {
    self.conn.connectTimeout = self.connectTimeout;
  }
  if (typeof(self.systemNaming) !== 'undefined')
  {
  ...

module ibm_db.ODBCConnection

function ibm_db.ODBCConnection ()

• description and source-code

  function ODBCConnection() { [native code] }

• example usage

  n/a

module ibm_db.ODBCConnection.prototype

function ibm_db.ODBCConnection.prototype.beginTransaction ()

• description and source-code

  function beginTransaction() { [native code] }

• example usage

  ...
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  ...

function ibm_db.ODBCConnection.prototype.beginTransactionSync ()

• description and source-code

  function beginTransactionSync() { [native code] }

• example usage

  ...
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  
  *   [**Connection Pooling APIs**](#PoolAPIs)
  ...

function ibm_db.ODBCConnection.prototype.close ()

• description and source-code

  function close() { [native code] }

• example usage

  ...
  
  * Update build.zip and defautl connection timeout. (Bimal Jha)
  
  * Exit with error code on installation errors, to allow failure detection by automated build tools (Michael Szlapa)
  
  * Add pool related test files. (Bimal Jha)
  
  * Update conn.close() for Pool to avoid reconnection before moving to available pool.
  Add pool related test files and update existing test files. (Bimal Jha)
  
  * update examples (Bimal Jha)
  
  * Updating the new build.zip for windows (Bimal Jha)
  
  * delete build.zip file on ntx64 after unzip (bimaljha)
  ...

function ibm_db.ODBCConnection.prototype.closeSync ()

• description and source-code

  function closeSync() { [native code] }

• example usage

  ...
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  ...

function ibm_db.ODBCConnection.prototype.columns ()

• description and source-code

  function columns() { [native code] }

• example usage

  ...
    var self = this;
    if (!self.queue) self.queue = [];
  
    callback = callback || arguments[arguments.length - 1];
  
    self.queue.push(function (next)
    {
      self.conn.columns(catalog, schema, table, column, function (err, result)
      {
  if (err) return callback(err, [], false);
  
  result.fetchAll(function (err, data)
  {
    result.closeSync();
    callback(err, data);
  ...

function ibm_db.ODBCConnection.prototype.createStatement ()

• description and source-code

  function createStatement() { [native code] }

• example usage

  ...
  var self = this, deferred;
  
  if(!cb)
  {
    deferred = Q.defer();
  }
  
  self.conn.createStatement(function (err, stmt)
  {
    if(err)
    {
      if(cb)
      {
        return cb(err);
      } else
  ...

function ibm_db.ODBCConnection.prototype.createStatementSync ()

• description and source-code

  function createStatementSync() { [native code] }

• example usage

  ...
    return deferred ? deferred.promise : null;
  };
  
  Database.prototype.prepareSync = function (sql)
  {
    var self = this;
  
    var stmt = self.conn.createStatementSync();
  
    stmt.queue = new SimpleQueue();
  
    stmt.prepareSync(sql);
  
    return stmt;
  };
  ...

function ibm_db.ODBCConnection.prototype.endTransaction ()

• description and source-code

  function endTransaction() { [native code] }

• example usage

  ...
    return deferred ? deferred.promise : self;
  };
  
  Database.prototype.endTransaction = function (rollback, cb)
  {
    var self = this;
  
    self.conn.endTransaction(rollback, cb);
    self.conn.inTransaction = false;
  
    return self;
  };
  
  Database.prototype.commitTransaction = function (cb)
  {
  ...

function ibm_db.ODBCConnection.prototype.endTransactionSync ()

• description and source-code

  function endTransactionSync() { [native code] }

• example usage

  ...
    return self;
  };
  
  Database.prototype.endTransactionSync = function (rollback)
  {
    var self = this;
  
    self.conn.endTransactionSync(rollback);
    self.conn.inTransaction = false;
  
    return self;
  };
  
  Database.prototype.commitTransactionSync = function ()
  {
  ...

function ibm_db.ODBCConnection.prototype.open ()

• description and source-code

  function open() { [native code] }

• example usage

  ...
  
  ## Quick Example
  ------------------
  
  ```javascript
  var ibmdb = require('ibm_db');
  
  ibmdb.open("DATABASE=<dbname>;HOSTNAME=<myhost>;UID=db2user;
  PWD=password;PORT=<dbport>;PROTOCOL=TCPIP", function (err,conn) {
    if (err) return console.log(err);
  
    conn.query('select 1 from sysibm.sysdummy1', function (err, data) {
  if (err) console.log(err);
  else console.log(data);
  
  conn.close(function () {
  ...

function ibm_db.ODBCConnection.prototype.openSync ()

• description and source-code

  function openSync() { [native code] }

• example usage

  ...
  
  ```javascript
  var Database = require("ibm_db").Database
    , ibmdb = new Database();
  ```
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  ...

function ibm_db.ODBCConnection.prototype.query ()

• description and source-code

  function query() { [native code] }

• example usage

  ...
  
  ```javascript
  var ibmdb = require('ibm_db');
  
  ibmdb.open("DATABASE=<dbname>;HOSTNAME=<myhost>;UID=db2user;PWD=password;PORT=<dbport>;PROTOCOL
  =TCPIP", function (err,conn) {
  if (err) return console.log(err);
  
  conn.query('select 1 from sysibm.sysdummy1', function (err, data) {
    if (err) console.log(err);
    else console.log(data);
  
    conn.close(function () {
      console.log('done');
    });
  });
  ...

function ibm_db.ODBCConnection.prototype.querySync ()

• description and source-code

  function querySync() { [native code] }

• example usage

  ...
  var Database = require("ibm_db").Database
    , ibmdb = new Database();
  ```
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  ...

function ibm_db.ODBCConnection.prototype.setIsolationLevel ()

• description and source-code

  function setIsolationLevel() { [native code] }

• example usage

  ...
  
    return stmt;
  };
  
  Database.prototype.setIsolationLevel = function(isolationLevel)
  {
    var self = this;
    return (self.conn.setIsolationLevel(isolationLevel));
  };
  
  //Proxy all of the ODBCStatement functions so that they are queued
  odbc.ODBCStatement.prototype._execute = odbc.ODBCStatement.prototype.execute;
  odbc.ODBCStatement.prototype._executeSync = odbc.ODBCStatement.prototype.executeSync;
  odbc.ODBCStatement.prototype._executeDirect = odbc.ODBCStatement.prototype.executeDirect;
  odbc.ODBCStatement.prototype._executeDirectSync = odbc.ODBCStatement.prototype.executeDirectSync;
  ...

function ibm_db.ODBCConnection.prototype.tables ()

• description and source-code

  function tables() { [native code] }

• example usage

  ...
    var self = this;
    if (!self.queue) self.queue = [];
  
    callback = callback || arguments[arguments.length - 1];
  
    self.queue.push(function (next)
    {
      self.conn.tables(catalog, schema, table, type, function (err, result)
      {
  if (err) return callback(err, [], false);
  
  result.fetchAll(function (err, data)
  {
    result.closeSync();
    callback(err, data);
  ...

module ibm_db.ODBCResult

function ibm_db.ODBCResult ()

• description and source-code

  function ODBCResult() { [native code] }

• example usage

  n/a

module ibm_db.ODBCResult.prototype

function ibm_db.ODBCResult.prototype.closeSync ()

• description and source-code

  function closeSync() { [native code] }

• example usage

  ...
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  ...

function ibm_db.ODBCResult.prototype.fetch ()

• description and source-code

  function fetch() { [native code] }

• example usage

  ...
  };
  return stream;
  };
  
  Database.prototype.fetchStreamingResults = function(results, stream)
  {
  var self = this;
  return results.fetch(function (err, data)
  {
    if (err)
    {
      return process.nextTick(function () { stream.emit('error', err); });
    }
    // when no more data returns, return push null to indicate the end of stream
    if (!data)
  ...

function ibm_db.ODBCResult.prototype.fetchAll ()

• description and source-code

  function fetchAll() { [native code] }

• example usage

  ...
        function fetchMore()
        {
          if (self.fetchMode)
          {
  result.fetchMode = self.fetchMode;
          }
  
          result.fetchAll(function (err, data, rowcount) {
  var moreResults = false, moreResultsError = null;
  
  // If there is any error, return it now only.
  if( err || initialErr )
  {
    // For pooled connection, if we get SQL30081N, then close
    // the connection now only and then proceed.
  ...

function ibm_db.ODBCResult.prototype.fetchAllSync ()

• description and source-code

  function fetchAllSync() { [native code] }

• example usage

  ...
  , cn = "DATABASE=dbname;HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=dbuser;PWD=xxx";
  
  ibmdb.open(cn,function(err,conn){
  var stmt = conn.prepareSync("select * from employee where empid = ?");
  
  //Bind and Execute the statment asynchronously
  stmt.execute([142], function (err, result) {
    data = result.fetchAllSync();
    console.log(data);
    result.closeSync();
    stmt.closeSync();
  
    //Close the connection
  	conn.close(function(err){});
  });
  ...

function ibm_db.ODBCResult.prototype.fetchSync ()

• description and source-code

  function fetchSync() { [native code] }

• example usage

  ...
  }
  
  // Fetch single row at once and process it.
  // Note that queryResult will bring only 64k data from server and result.fetchSync
  // will return each row from this 64k client buffer. Once all data is read from
  // buffer, ibm_db driver will bring another 64k chunk of data from server.
  var data;
  while( data = result.fetchSync() )
  {
    console.log(data);
  }
  
  // drop the table and close connection.
  conn.querySync("drop table mytab");
  conn.closeSync();
  ...

function ibm_db.ODBCResult.prototype.getColumnNamesSync ()

• description and source-code

  function getColumnNamesSync() { [native code] }

• example usage

  n/a

function ibm_db.ODBCResult.prototype.moreResultsSync ()

• description and source-code

  function moreResultsSync() { [native code] }

• example usage

  ...
    return next();
  }
  
  // Get the result data
  try
  {
    if(rowcount)  // Check for more result set.
        moreResults = result.moreResultsSync();
  }
  catch (e)
  {
    moreResultsError = e;
    moreResults = false;
  }
  ...

module ibm_db.ODBCStatement

function ibm_db.ODBCStatement ()

• description and source-code

  function ODBCStatement() { [native code] }

• example usage

  n/a

module ibm_db.ODBCStatement.prototype

function ibm_db.ODBCStatement.prototype._bind ()

• description and source-code

  function bind() { [native code] }

• example usage

  ...
        cb(err);
      } else
      {
        deferred.reject(err);
      }
    }
  }
  self._bind(params, function (err) {
    if (err) {
      if(!deferred)
      {
        cb(err);
      } else
      {
        deferred.reject(err);
  ...

function ibm_db.ODBCStatement.prototype._bindSync ()

• description and source-code

  function bindSync() { [native code] }

• example usage

  ...
  odbc.ODBCStatement.prototype.bindSync = function (ary) {
      var self = this;
      if(Array.isArray(ary))
      {
        var err = parseParams(ary);
        if(err) return false;
      }
      return self._bindSync(ary);
  };
  
  
  module.exports.Pool = Pool;
  
  Pool.count = 0;
  ...

function ibm_db.ODBCStatement.prototype._execute ()

• description and source-code

  function execute() { [native code] }

• example usage

  ...
    } else
    {
      deferred.reject(err);
    }
    return next();
  }
  
  self._execute(function (err, result, outparams) {
    if(!deferred)
    {
      cb(err, result, outparams);
    } else
    {
      if(err)
      {
  ...

function ibm_db.ODBCStatement.prototype._executeDirect ()

• description and source-code

  function executeDirect() { [native code] }

• example usage

  ...
  odbc.ODBCStatement.prototype.executeDirect = function (sql, cb)
  {
    var self = this;
  
    self.queue = self.queue || new SimpleQueue();
  
    self.queue.push(function (next) {
      self._executeDirect(sql, function (err, result) {
        cb(err, result);
  
        return next();
      });
    });
  };
  ...

function ibm_db.ODBCStatement.prototype._executeDirectSync ()

• description and source-code

  function executeDirectSync() { [native code] }

• example usage

  n/a

function ibm_db.ODBCStatement.prototype._executeNonQuery ()

• description and source-code

  function executeNonQuery() { [native code] }

• example usage

  ...
    else
    {
      deferred.reject(err);
    }
    return next();
  }
  
  self._executeNonQuery(function (err, result) {
    if(!deferred)
    {
      if(cb) cb(err, result);
    }
    else
    {
      if(err)
  ...

function ibm_db.ODBCStatement.prototype._executeNonQuerySync ()

• description and source-code

  function executeNonQuerySync() { [native code] }

• example usage

  n/a

function ibm_db.ODBCStatement.prototype._executeSync ()

• description and source-code

  function executeSync() { [native code] }

• example usage

  ...
    //If params are passed to this function, first bind them and
    //then execute.
    if (params)
    {
    err = self.bindSync(params);
    if(err !== true) console.log(err);
    }
    return self._executeSync();
  };
  
  function parseParams(params)
  {
  var err, prm, paramtype, ctype, sqltype, datatype, data, len;
  for (var i = 0; i < params.length; i++)
  {
  ...

function ibm_db.ODBCStatement.prototype._prepare ()

• description and source-code

  function prepare() { [native code] }

• example usage

  ...
  
  odbc.ODBCStatement.prototype.prepare = function (sql, cb) {
    var self = this;
  
    self.queue = self.queue || new SimpleQueue();
  
    self.queue.push(function (next) {
      self._prepare(sql, function (err) {
        if(cb) cb(err);
  
        return next();
      });
    });
  };
  ...

function ibm_db.ODBCStatement.prototype.bind (ary, cb)

• description and source-code

  bind = function (ary, cb) {
    var self = this;
  
    self.bindQueue = self.bindQueue || new SimpleQueue();
  
    self.bindQueue.push(function () {
      if(Array.isArray(ary))
      {
        var err = parseParams(ary);
        if(err && cb) cb(err);
      }
      self._bind(ary, function (err) {
        if(cb) cb(err);
  
        //NOTE: we do not call next() here because
        //we want to pop the next bind call only
        //after the next execute call
      });
    });
  }

• example usage

  ...
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  ...

function ibm_db.ODBCStatement.prototype.bindSync (ary)

• description and source-code

  bindSync = function (ary) {
      var self = this;
      if(Array.isArray(ary))
      {
        var err = parseParams(ary);
        if(err) return false;
      }
      return self._bindSync(ary);
  }

• example usage

  ...
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  20. [.rollbackTransactionSync()](#rollbackTransactionSyncApi)
  21. [.debug(value)](#enableDebugLogs)
  ...

function ibm_db.ODBCStatement.prototype.closeSync ()

• description and source-code

  function closeSync() { [native code] }

• example usage

  ...
  
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  ...

function ibm_db.ODBCStatement.prototype.execute (params, cb)

• description and source-code

  execute = function (params, cb)
  {
    var self = this, deferred;
    // promises logic
    if (!cb && typeof params !== 'function')
    {
      deferred = Q.defer();
      // if(!params)
      // {
      //   params = null;
      // }
  
    }
  
    self.queue = self.queue || new SimpleQueue();
  
    if (!cb)
    {
      cb = params;
      params = null;
    }
  
    self.queue.push(function (next) {
      //If params were passed to this function, then bind them and
      //then execute.
      if (params)
      {
        if(Array.isArray(params))
        {
          var err = parseParams(params);
          if(err)
          {
            if(!deferred)
            {
              cb(err);
            } else
            {
              deferred.reject(err);
            }
          }
        }
        self._bind(params, function (err) {
          if (err) {
            if(!deferred)
            {
              cb(err);
            } else
            {
              deferred.reject(err);
            }
            return next();
          }
  
          self._execute(function (err, result, outparams) {
            if(!deferred)
            {
              cb(err, result, outparams);
            } else
            {
              if(err)
              {
                deferred.reject(err);
              } else
              {
                deferred.resolve(result, outparams);
              }
            }
  
            return next();
          });
        });
      }
      //Otherwise execute and pop the next bind call
      else
      {
        self._execute(function (err, result, outparams) {
          if(!deferred)
          {
            cb(err, result, outparams);
          } else
          {
            if(err)
            {
              deferred.reject(err);
            } else
            {
              deferred.resolve(result, outparams);
            }
          }
  
          //NOTE: We only execute the next queued bind call after
          // we have called execute() or executeNonQuery(). This ensures
          // that we don't call a bind() a bunch of times without ever
          // actually executing that bind. Not
          self.bindQueue && self.bindQueue.next();
  
          return next();
        });
      }
    });
    return deferred ? deferred.promise : null;
  }

• example usage

  ...
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  ...

function ibm_db.ODBCStatement.prototype.executeDirect (sql, cb)

• description and source-code

  executeDirect = function (sql, cb)
  {
    var self = this;
  
    self.queue = self.queue || new SimpleQueue();
  
    self.queue.push(function (next) {
      self._executeDirect(sql, function (err, result) {
        cb(err, result);
  
        return next();
      });
    });
  }

• example usage

  n/a

function ibm_db.ODBCStatement.prototype.executeDirectSync ()

• description and source-code

  function executeDirectSync() { [native code] }

• example usage

  n/a

function ibm_db.ODBCStatement.prototype.executeNonQuery (params, cb)

• description and source-code

  executeNonQuery = function (params, cb)
  {
    var self = this, deferred;
  
    if (!cb && typeof params !== 'function')
    {
        deferred = Q.defer();
    }
    self.queue = self.queue || new SimpleQueue();
  
    if (!cb)
    {
      cb = params;
      params = null;
    }
  
    self.queue.push(function (next) {
      //If params were passed to this function, then bind them and
      //then executeNonQuery.
      if (params)
      {
        if(Array.isArray(params))
        {
          var err = parseParams(params);
          if(err)
          {
            if(!deferred)
            {
              if(cb) cb(err);
            }
            else
            {
              deferred.reject(err);
            }
          }
        }
        self._bind(params, function (err) {
          if (err) {
            if(!deferred)
            {
              if(cb) cb(err)
            }
            else
            {
              deferred.reject(err);
            }
            return next();
          }
  
          self._executeNonQuery(function (err, result) {
            if(!deferred)
            {
              if(cb) cb(err, result);
            }
            else
            {
              if(err)
              {
                deferred.reject(err);
              }
              else
              {
                deferred.resolve(result);
              }
            }
            return next();
          });
        });
      }
      //Otherwise executeNonQuery and pop the next bind call
      else {
        self._executeNonQuery(function (err, result) {
          if(!deferred)
          {
            if(cb) cb(err, result);
          }
          else
          {
            if(err)
            {
              deferred.reject(err);
            }
            else
            {
              deferred.resolve(result);
            }
          }
  
          //NOTE: We only execute the next queued bind call after
          // we have called execute() or executeNonQuery(). This ensures
          // that we don't call a bind() a bunch of times without ever
          // actually executing that bind. Not
          self.bindQueue && self.bindQueue.next();
  
          return next();
        });
      }
    });
    return deferred ? deferred.promise : null;
  }

• example usage

  ...
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  19. [.rollbackTransaction(callback)](#rollbackTransactionApi)
  ...

function ibm_db.ODBCStatement.prototype.executeNonQuerySync ()

• description and source-code

  function executeNonQuerySync() { [native code] }

• example usage

  n/a

function ibm_db.ODBCStatement.prototype.executeSync (params)

• description and source-code

  executeSync = function (params)
  {
    var self = this, err;
  
    //If params are passed to this function, first bind them and
    //then execute.
    if (params)
    {
        err = self.bindSync(params);
        if(err !== true) console.log(err);
    }
    return self._executeSync();
  }

• example usage

  ...
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  17. [.commitTransaction(callback)](#commitTransactionApi)
  18. [.commitTransactionSync()](#commitTransactionSyncApi)
  ...

function ibm_db.ODBCStatement.prototype.prepare (sql, cb)

• description and source-code

  prepare = function (sql, cb) {
    var self = this;
  
    self.queue = self.queue || new SimpleQueue();
  
    self.queue.push(function (next) {
      self._prepare(sql, function (err) {
        if(cb) cb(err);
  
        return next();
      });
    });
  }

• example usage

  ...
  1.  [.open(connectionString, [options,] callback)](#openApi)
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  ...

function ibm_db.ODBCStatement.prototype.prepareSync ()

• description and source-code

  function prepareSync() { [native code] }

• example usage

  ...
  2.  [.openSync(connectionString)](#openSyncApi)
  3.  [.query(sqlQuery [, bindingParameters], callback)](#queryApi)
  4.  [.querySync(sqlQuery [, bindingParameters])](#querySyncApi)
  5.  [.queryStream(sqlQuery [, bindingParameters])](#queryStreamApi)
  6.  [.close(callback)](#closeApi)
  7.  [.closeSync()](#closeSyncApi)
  8.  [.prepare(sql, callback)](#prepareApi)
  9.  [.prepareSync(sql)](#prepareSyncApi)
  10. [.execute([bindingParameters], callback)](#executeApi)
  11. [.executeSync([bindingParameters])](#executeSyncApi)
  12. [.executeNonQuery([bindingParameters], callback)](#executeNonQueryApi)
  13. [.bind(bindingParameters, callback)](#bindApi)
  14. [.bindSync(bindingParameters)](#bindSyncApi)
  15. [.beginTransaction(callback)](#beginTransactionApi)
  16. [.beginTransactionSync()](#beginTransactionSyncApi)
  ...

module ibm_db.Pool

function ibm_db.Pool (_options)

• description and source-code

  function Pool(_options) {
    var self = this;
    self.options = {};
    self.maxPoolSize = 0;
    if(_options)
    {
      if(_options.idleTimeout && !isNaN(_options.idleTimeout))
        self.options.idleTimeout = _options.idleTimeout;
      if(_options.autoCleanIdle)
        self.options.autoCleanIdle = _options.autoCleanIdle;
      if(_options.maxPoolSize)
        self.maxPoolSize = _options.maxPoolSize;
      if(_options.connectTimeout)
        self.options.connectTimeout = _options.connectTimeout;
      if(_options.systemNaming)
        self.options.systemNaming=_options.systemNaming;
    }
    self.index = Pool.count++;
    self.availablePool = {};
    self.usedPool = {};
    self.poolSize = 0;
    if(!ENV) ENV = new odbc.ODBC();
    self.odbc = ENV;
    self.options.connectTimeout = self.options.connectTimeout || 60;
  }

• example usage

  ...
  ### Using node < v0.10 on Linux
  
  Be aware that through node v0.9 the uv_queue_work function, which is used to
  execute the ODBC functions on a separate thread, uses libeio for its thread
  pool. This thread pool by default is limited to 4 threads.
  
  This means that if you have long running queries spread across multiple
  instances of ibmdb.Database() or using odbc.Pool(), you will only be able to
  have 4 concurrent queries.
  
  You can increase the thread pool size by using @developmentseed's [node-eio]
  (https://github.com/developmentseed/node-eio).
  
  #### install:
  ```bash
  ...

module ibm_db.Pool.prototype

function ibm_db.Pool.prototype.cleanUp (connStr, callback)

• description and source-code

  cleanUp = function (connStr, callback) {
    var self = this;
    if(self.availablePool[connStr].length < 2) return;
  
    self.availablePool[connStr] = self.availablePool[connStr].filter(function(conn)
    {
      if(conn.lastUsed &&
         (Date.now()-conn.lastUsed > (self.options.idleTimeout || 1800 * 1000)) &&
         conn.realClose )
      {
         conn.realClose(function()
         {
           if(self.poolSize) self.poolSize--;
           exports.debug && console.log("odbc.js : pool[%s] : Pool.cleanUp() : " +
                   "pool.realClose() : Connection duration : %s", self.index,
                   (Date.now() - conn.created)/1000);
         });
         return false;
      }
      else
      {
        return true;
      }
    });
  }

• example usage

  ...
    //move this connection back to the connection pool at the end.
    if(db.conn)
    {
      self.availablePool[connStr] = self.availablePool[connStr] || [];
      self.availablePool[connStr].push(db);
  
      //start cleanUp if enabled
      if(self.options.autoCleanIdle) self.cleanUp(connStr);
    }
    if(exports.debug) {
      process.stdout.write(getElapsedTime());
      console.dir(self);
    }
  };  // db.close function
  ...

function ibm_db.Pool.prototype.close (callback)

• description and source-code

  close = function (callback)
  {
    var self = this
      , required = 0
      , received = 0
      , connections
      , key
      , x
      ;
  
    exports.debug && console.log("%s odbc.js : pool[%s] : pool.close()", getElapsedTime(), self.index);
    //we set a timeout because a previous db.close() may
    //have caused the a behind the scenes db.open() to prepare
    //a new connection
    setTimeout(function () {
      //merge the available pool and the usedPool
      var pools = {};
  
      for (key in self.availablePool)
      {
        pools[key] = (pools[key] || []).concat(self.availablePool[key]);
      }
  
      for (key in self.usedPool)
      {
        pools[key] = (pools[key] || []).concat(self.usedPool[key]);
      }
  
      exports.debug && console.log("%s odbc.js : pool[%s] : pool.close() - setTimeout() callback", getElapsedTime(), self.index);
      //console.dir(pools);
  
      if (Object.keys(pools).length === 0)
      {
        if (callback) return callback();
        else return null;
      }
  
      for (key in pools)
      {
        connections = pools[key];
        required += connections.length;
  
        if(exports.debug) {
          console.log("%s odbc.js : pool[%s] : pool.close() - processing pools %s - connections: %s",
                      getElapsedTime(), self.index, key, connections.length);
        }
  
        for (x = 0 ; x < connections.length; x ++)
        {
          (function (x) {
            //call the realClose method to avoid
            //automatically re-opening the connection
            if(exports.debug) {
              console.log("%s odbc.js : pool[%s] : pool.close() - calling realClose() for connection #%s",
                          getElapsedTime(), self.index, x);
            }
  
            if(connections[x].realClose) {
             connections[x].realClose(function () {
              if(exports.debug) {
                console.log("%s odbc.js : pool[%s] : pool.close() - realClose() callback for connection #%s",
                            getElapsedTime(), self.index, x);
              }
              module.exports.close(connections[x]);
              received += 1;
              if(self.poolSize) self.poolSize--;
  
              if (received === required)
              {
                if(callback) callback();
  
                //prevent mem leaks
                self = null;
                connections = null;
                required = null;
                received = null;
                key = null;
  
                return;
              }
             }); // connections[x].realClose i.e. conn.close().
            }
            else {
                exports.debug && console.log("%s realClose is not a member of connection %s", getElapsedTime(), x);
            }
          })(x);
        } //for loop.
      } //for (key in pools)
    }, 2000);  //setTimeout
  }

• example usage

  ...
  
  * Update build.zip and defautl connection timeout. (Bimal Jha)
  
  * Exit with error code on installation errors, to allow failure detection by automated build tools (Michael Szlapa)
  
  * Add pool related test files. (Bimal Jha)
  
  * Update conn.close() for Pool to avoid reconnection before moving to available pool.
  Add pool related test files and update existing test files. (Bimal Jha)
  
  * update examples (Bimal Jha)
  
  * Updating the new build.zip for windows (Bimal Jha)
  
  * delete build.zip file on ntx64 after unzip (bimaljha)
  ...

function ibm_db.Pool.prototype.init (count, connStr)

• description and source-code

  init = function (count, connStr)
  {
    var self = this;
    var ret = false;
  
    //check to see if we already have a connection for this connection string
    if (self.availablePool[connStr] && self.availablePool[connStr].length)
    {
      console.log("Pool is already initialized and it has "+
             self.availablePool[connStr].length + " available connections.\n");
      return;
    }
    else
    {
      if((self.maxPoolSize > 0) && (count > self.maxPoolSize))
      {
          console.log(getElapsedTime(), " ** Can not open connection more than max pool size.\n");
          count = self.maxPoolSize;
      }
  
      if(typeof(self.options.odbc) === undefined)
          self.options.odbc = self.odbc;
      for(var i = 0; i < count; i++)
      {
          var db = new Database(self.options);
          self.poolSize++;
          try{
              ret = db.openSync(connStr);
          } catch (ret) {
              self.poolSize--;
              exports.debug && console.log("%s odbc.js: %d connection(s) initialized.\n", getElapsedTime(), self.poolSize);
              return ret;
          }
          if(ret !== true) break;
          exports.debug && console.log("%s odbc.js : pool[%s] : pool.init %d", getElapsedTime(), self.index, i);
  
          self.availablePool[connStr] = self.availablePool[connStr] || [];
          db.created = Date.now();
  
          db.realClose = db.close;
          db.close = function (cb)
          {
            var db = this;
            db.lastUsed = Date.now();
            if(cb) cb(null);
            if(db.conn && db.conn.inTransaction)
            {
                db.rollbackTransaction(function(err){});
            }
            self.usedPool[connStr].splice(self.usedPool[connStr].indexOf(db), 1);
            if(db.conn)
            {
              self.availablePool[connStr] = self.availablePool[connStr] || [];
              self.availablePool[connStr].push(db);
              if(self.options.autoCleanIdle) self.cleanUp(connStr);
            }
          };  // db.close function
          self.availablePool[connStr].push(db);
      }
      self.usedPool[connStr] = self.usedPool[connStr] || [];
      exports.debug && console.log(getElapsedTime(), "Max pool size = " + self.maxPoolSize);
      return ret;
    }
  }

• example usage

  ...
  the next time you call `Pool.open()` for the same connection string.
  
  For applications using multiple connections simultaneously, it is recommended to
  use Pool.open instead of [ibmdb.open](#openApi).
  
  1.  [.open(connectionString, callback)](#openPoolApi)
  2.  [.close(callback)](#closePoolApi)
  3.  [.init(N, connStr)](#initPoolApi)
  4.  [.setMaxPoolSize(N)](#setMaxPoolSize)
  5.  [.setConnectTimeout(seconds)](#setConnectTimeout)
  
  ### <a name="openPoolApi"></a> 1) .open(connectionString, callback)
  
  Get a `Database` instance which is already connected to `connectionString`
  ...

function ibm_db.Pool.prototype.open (connStr, callback)

• description and source-code

  open = function (connStr, callback)
  {
    var self = this
      , db
      ;
  
    //check to see if we already have a connection for this connection string
    if (self.availablePool[connStr] && self.availablePool[connStr].length)
    {
      db = self.availablePool[connStr].shift();
      db.lastUsed=null;
      self.usedPool[connStr] = self.usedPool[connStr] || [];
      self.usedPool[connStr].push(db);
      callback(null, db);
    }
    else if((self.maxPoolSize > 0) && (self.poolSize >= self.maxPoolSize))
    {
      var timeout = self.options.connectTimeout;
      var error = {"message":"Connection Timeout Occurred, Pool is full."};
      var interval =  setInterval(function () {
        if (self.availablePool[connStr] && self.availablePool[connStr].length)
        {
          db = self.availablePool[connStr].shift();
          db.lastUsed=null;
          self.usedPool[connStr] = self.usedPool[connStr] || [];
          self.usedPool[connStr].push(db);
          clearInterval(interval);
          callback(null, db);
        }
        if(timeout === 0)
        {
          clearInterval(interval);
          callback(error, null);
        }
        else
        {
          timeout--;
        }
      }, 1000);  //setInterval
    }
    else
    {
      if(typeof(self.options.odbc) === undefined)
          self.options.odbc = self.odbc;
      db = new Database(self.options);
      self.poolSize++;
  
      db.realClose = db.close;
      db.close = function (cb)
      {
        var db = this;
        db.lastUsed = Date.now();
        //call back early, we can do the rest of this stuff after the client
        //thinks that the connection is closed.
        if(cb) cb(null);
  
        // If this connection has some active transaction, rollback the
        // transaction to free up the held resorces before moving back to
        // the pool. So that, next request can get afresh connection from pool.
        if(db.conn && db.conn.inTransaction)
        {
            db.rollbackTransaction(function(err){});
        }
  
        //remove this db from the usedPool
        self.usedPool[connStr].splice(self.usedPool[connStr].indexOf(db), 1);
  
        //move this connection back to the connection pool at the end.
        if(db.conn)
        {
          self.availablePool[connStr] = self.availablePool[connStr] || [];
          self.availablePool[connStr].push(db);
  
          //start cleanUp if enabled
          if(self.options.autoCleanIdle) self.cleanUp(connStr);
        }
        if(exports.debug) {
          process.stdout.write(getElapsedTime());
          console.dir(self);
        }
      };  // db.close function
  
      db.open(connStr, function (error) {
        exports.debug && console.log("%s odbc.js : pool[%s] : pool.db.open new connection.", getElapsedTime(), self.index);
        if(error)
        {
          self.poolSize--;
        }
        else
        {
          self.usedPool[connStr] = self.usedPool[connStr] || [];
          db.created = Date.now();
          self.usedPool[connStr].push(db);
        }
        callback(error, db);
      }); //db.open
    }
  }

• example usage

  ...
  
  ## Quick Example
  ------------------
  
  ```javascript
  var ibmdb = require('ibm_db');
  
  ibmdb.open("DATABASE=<dbname>;HOSTNAME=<myhost>;UID=db2user;
  PWD=password;PORT=<dbport>;PROTOCOL=TCPIP", function (err,conn) {
    if (err) return console.log(err);
  
    conn.query('select 1 from sysibm.sysdummy1', function (err, data) {
  if (err) console.log(err);
  else console.log(data);
  
  conn.close(function () {
  ...

function ibm_db.Pool.prototype.setConnectTimeout (timeout)

• description and source-code

  setConnectTimeout = function (timeout)
  {
      var self = this;
      self.options.connectTimeout = timeout;
      return true;
  }

• example usage

  ...
  For applications using multiple connections simultaneously, it is recommended to
  use Pool.open instead of [ibmdb.open](#openApi).
  
  1.  [.open(connectionString, callback)](#openPoolApi)
  2.  [.close(callback)](#closePoolApi)
  3.  [.init(N, connStr)](#initPoolApi)
  4.  [.setMaxPoolSize(N)](#setMaxPoolSize)
  5.  [.setConnectTimeout(seconds)](#setConnectTimeout)
  
  ### <a name="openPoolApi"></a> 1) .open(connectionString, callback)
  
  Get a `Database` instance which is already connected to `connectionString`
  
  * **connectionString** - The connection string for your database
  * **callback** - `callback (err, db)`
  ...

function ibm_db.Pool.prototype.setMaxPoolSize (size)

• description and source-code

  setMaxPoolSize = function (size)
  {
      var self = this;
      self.maxPoolSize = size;
      return true;
  }

• example usage

  ...
  
  For applications using multiple connections simultaneously, it is recommended to
  use Pool.open instead of [ibmdb.open](#openApi).
  
  1.  [.open(connectionString, callback)](#openPoolApi)
  2.  [.close(callback)](#closePoolApi)
  3.  [.init(N, connStr)](#initPoolApi)
  4.  [.setMaxPoolSize(N)](#setMaxPoolSize)
  5.  [.setConnectTimeout(seconds)](#setConnectTimeout)
  
  ### <a name="openPoolApi"></a> 1) .open(connectionString, callback)
  
  Get a `Database` instance which is already connected to `connectionString`
  
  * **connectionString** - The connection string for your database
  ...

module ibm_db.simple_queue

function ibm_db.simple_queue ()

• description and source-code

  function SimpleQueue() {
    var self = this;
  
    self.fifo = [];
    self.executing = false;
  }

• example usage

  n/a

module ibm_db.simple_queue.prototype

function ibm_db.simple_queue.prototype.maybeNext ()

• description and source-code

  maybeNext = function () {
    var self = this;
  
    if (!self.executing) {
      self.next();
    }
  }

• example usage

  ...
  }
  
  SimpleQueue.prototype.push = function (fn) {
  var self = this;
  
  self.fifo.push(fn);
  
  self.maybeNext();
  };
  
  SimpleQueue.prototype.maybeNext = function () {
  var self = this;
  
  if (!self.executing) {
    self.next();
  ...

function ibm_db.simple_queue.prototype.next ()

• description and source-code

  next = function () {
    var self = this;
  
    if (self.fifo.length) {
      var fn = self.fifo.shift();
  
      self.executing = true;
  
      fn(function () {
        self.executing = false;
  
        self.maybeNext();
      });
    }
  }

• example usage

  ...
            }
          }
  
          //NOTE: We only execute the next queued bind call after
          // we have called execute() or executeNonQuery(). This ensures
          // that we don't call a bind() a bunch of times without ever
          // actually executing that bind. Not
          self.bindQueue && self.bindQueue.next();
  
          return next();
        });
      }
    });
    return deferred ? deferred.promise : null;
  };
  ...

function ibm_db.simple_queue.prototype.push (fn)

• description and source-code

  push = function (fn) {
    var self = this;
  
    self.fifo.push(fn);
  
    self.maybeNext();
  }

• example usage

  ...
  {
    var self = this, deferred;
    if(!cb)
    {
      deferred = Q.defer();
    }
  
    self.queue.push(function (next) {
      if(self.conn)
      {
        self.conn.close(function (err) {
  self.connected = false;
  delete self.conn;
  
  if (cb)
  ...