SAP HANA Database Connection Pool for Node

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

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

Table of contents

• 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

Install

npm install hdb-pool

Getting started

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
    });

Creating a pool

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);

dbParams

A dictionary with following properties:

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

options

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)

Getting a connection

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).

Returning a connection

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.

Destroying a connection

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.

Clearing the pool

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

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

Receiving events from 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.

Getting status overview of pool

const overview = pool.getPoolStatusOverview();

This function will show current status of the pool.

Running tests

npm install
npm test

License

MIT