HANA Database Connection pool for Node.js, inspired by (and copied some ideas from): Generic Pool.

This module supports hana-client and node-hdb. If both exist, the hana-client will be chosen.

• Install
• Getting started
• Creating a pool
• Getting a connection
• Returning a connection
• Destroying a connection
• Clearing the pool
• Receiving events from pool
• Getting status overview of pool
• Running tests
• License

npm install hdb-pool

This is an example how to use this module:

// import the module
const Pool = require('hdb-pool');

// HANA connection info
const dbParams = {
    hostName: 'hana-server-name',
    port: '30015',
    userName: 'user-name',
    password: 'user-password'
};

// pool options
const options = {
    min: 2,
    max: 15,
};

// create the pool
const pool = Pool.createPool(dbParams, options);

// execute some sample sql via the pool 
pool.getConnection()
    .then(conn => {
        conn.exec('select current_timestamp from dummy', (err, rows) => {
          //return the connection back to pool  
          pool.release(client);
            if (err) {
                // error handling
            } else {
                // handle the result: rows
            }
        });
    })
    .catch(err => {
        // error handling
    });

The pool constructor takes two arguments:

• dbParams: a dictionary containing the HANA DB connection information.
• options : a dictionary containing the configuration for the Pool

const Pool = require('hdb-pool');
const pool = Pool.createPool(dbParams, options);

A dictionary with following properties:

• hostName: host name of HANA server.
• port: port number.
• userName: user name.
• password: password.

An optional dictionary with the any of the following properties:

• max: maximum number of resources to create at any given time. (default=50)
• min: minimum number of resources to keep in pool at any given time. (default=3)
• maxWaitingRequests: maximum number of waiting requests allowed. (default=0, no limit)
• requestTimeout: max milliseconds a request will wait for a resource before timing out. (default=5000)
• checkInterval: how often to run resource timeout checks. (default=0, disabled)
• idleTimeout: the time of a connection staying idle in the pool that eligible for eviction. (default=30000)
• debug: a flag for emitting those debug message. (default=false, disabled)

pool.getConnection()
    .then(conn => {...})
    .catch(err => {...});

Getting a HANA connection from the pool, the getConnecction does not have any argument.

It returns a Promise. The promise will be resolved with a connection if the connection is available in the pool. And the promise will be rejected with an error if the pool is unable to give a connection(eg: timeout).

pool.release(connection)
    .then(() => {...})
    .catch(err => {...});

Returning a connection to the pool, the release takes one required argument:

• connection: a 'borrowed' connection.

This function returns a Promise. This promise will resolve once the connection is accepted by the pool, or reject if the pool is unable to accept the connection for any reason (e.g connection is not a resource that came from the pool). If you do not care the outcome it is safe to ignore this promise.

pool.destroy(connection)
    .then(() => {...})
    .catch(err => {...});

Removing the connection from the pool and destroy the connection itself as well. The function takes one required argument:

• connection: a "borrowed" connection.

This function returns a Promise. This promise will resolve once the connection is accepted by the pool, If you do not care the outcome it is safe to ignore this promise.

pool.clear()
    .then(() => {...})
    .catch(err => {...});

This function clears the pool, removing/destroying all the connections and all the pending requests from the pool.

Pool.eventEmitter.on('poolDebug', myEventHandler);
Pool.eventEmitter.on('poolError', myEventHandlerError);
Pool.eventEmitter.on('connectionCreateError', myEventHandlerCreateError);
Pool.eventEmitter.on('connectionValidationError', myEventHandlerValidateError);
Pool.eventEmitter.on('requestTimeout', myEventHandlerValidateError);

Pool supports 5 different types of events:

• poolDebug: debug information of the pool, needs to be enabled by options.debug first.
• poolError: error information of the pool.
• connectionCreateError: connection creation error.
• connectionValidationError: connection validation error.
• requestTimeout: request timeout.

const overview = pool.getPoolStatusOverview();

This function will show current status of the pool.

npm install
npm test

MIT