brianc

pg-pool

const EventEmitter = require('events').EventEmitter

const removeWhere = (list, predicate) => {

  return i === -1 ? undefined : list.splice(i, 1)[0]

  constructor(client, idleListener, timeoutId) {

  throw new Error('Release called on client which has already been released to the pool.')

    return { callback: callback, result: undefined }

  const result = new Promise(function (resolve, reject) {

    // replace the stack trace that leads to `TCP.onStreamRead` with one that leads back to the

    // application that created the query

  return { callback: cb, result: result }

function makeIdleListener(pool, client) {

    client.removeListener('error', idleListener)

      pool.log('additional client error after disconnection due to error', err)

    // TODO - document that once the pool emits an error

    // the client has already been closed & purged and is unusable

    this.options = Object.assign({}, options)

    if (options != null && 'password' in options) {

      // "hiding" the password so it doesn't show up in stack traces

      // or if the client is console.logged

      Object.defineProperty(this.options, 'password', {

    if (options != null && options.ssl && options.ssl.key) {

      // "hiding" the ssl->key so it doesn't show up in stack traces

      Object.defineProperty(this.options.ssl, 'key', {

    this.options.max = this.options.max || this.options.poolSize || 10

    this.options.maxUses = this.options.maxUses || Infinity

    this.options.allowExitOnIdle = this.options.allowExitOnIdle || false

    this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0

    this.log = this.options.log || function () {}

    this.Client = this.options.Client || Client || require('pg').Client

    this.Promise = this.options.Promise || global.Promise

    if (typeof this.options.idleTimeoutMillis === 'undefined') {

      this.options.idleTimeoutMillis = 10000

    return this._clients.length >= this.options.max

        this._idle.slice().map((item) => {

    // if we don't have any waiting, do nothing

    // if we don't have any idle clients and we have no more room do nothing

    if (!this._idle.length && this._isFull()) {

    const pendingItem = this._pendingQueue.shift()

  "description": "Connection pool for node-postgres",

    "url": "git://github.com/brianc/node-postgres.git",

    "url": "https://github.com/brianc/node-pg-pool/issues"

  "homepage": "https://github.com/brianc/node-pg-pool#readme",

  "gitHead": "eaafac36dc8f4a13f1fecc9e3420d35559fd8e2b"

  "gitHead": "b03c071d2d15af259e1e008e9628191c865e58fa"

[![Build Status](https://travis-ci.org/brianc/node-pg-pool.svg?branch=master)](https://travis-ci.org/brianc/node-pg-pool)

to use pg-pool you must first create an instance of a pool

// configuration as whatever `pg` version you have installed

// these properties are passed unchanged to both the node-postgres Client constructor

// and the node-pool (https://github.com/coopernurse/node-pool) constructor

// allowing you to fully configure the behavior of both

  idleTimeoutMillis: 1000, // close idle clients after 1 second

  connectionTimeoutMillis: 1000, // return an error after 1 second if connection could not be established

  maxUses: 7500, // close (and replace) a connection after it has been used 7500 times (see below for discussion)

//you can supply a custom client constructor

//if you want to use the native postgres client

var NativeClient = require('pg').native.Client

var nativePool = new Pool({ Client: NativeClient })

//you can even pool pg-native clients directly

var PgNativeClient = require('pg-native')

var pgNativePool = new Pool({ Client: PgNativeClient })

The Pool constructor does not support passing a Database URL as the parameter. To use pg-pool on heroku, for example, you need to parse the URL into a config object. Here is an example of how to parse a Database URL.

const params = url.parse(process.env.DATABASE_URL);

  database: params.pathname.split('/')[1],

  Transforms, 'postgres://DBuser:secret@DBHost:#####/myDB', into

pg-pool supports a fully promise-based api for acquiring clients

  client.query('select $1::text as name', ['pg-pool']).then(res => {

    console.log('hello from', res.rows[0].name)

    console.error('query error', e.message, e.stack)

      return console.error('query error', e.message, e.stack)

      return console.error('query error', err.message, err.stack)

When you are finished with the pool if all the clients are idle the pool will close them after `config.idleTimeoutMillis` and your app

will shutdown gracefully.  If you don't want to wait for the timeout you can end the pool as follows:

console.log(await client.query('select now()'))

The pool should be a __long-lived object__ in your application.  Generally you'll want to instantiate one pool when your app starts up and use the same instance of the pool throughout the lifetime of your application.  If you are frequently creating a new pool within your code you likely don't have your pool initialization code in the correct place.  Example:

// assume this is a file in your program at ./your-app/lib/db.js

// correct usage: create the pool and let it live

// 'globally' here, controlling access to it through exported methods

// this is the right way to export the query method

module.exports.query = (text, values) => {

// this would be the WRONG way to export the connect method

  // notice how we would be creating a pool instance here

  // every time we called 'connect' to get a new client?

  // that's a bad thing & results in creating an unbounded

  // number of pools & therefore connections

Every instance of a `Pool` is an event emitter.  These instances emit the following events:

Emitted whenever an idle client in the pool encounters an error.  This is common when your PostgreSQL server shuts down, reboots, or a network partition otherwise causes it to become unavailable while your pool has connected clients.

// attach an error handler to the pool for when a connected, idle client

// receives an error by being disconnected, etc

pool.on('error', function(error, client) {

  // handle this in the same way you would treat process.on('uncaughtException')

  // it is supplied the error as well as the idle client which received the error

Fired whenever the pool creates a __new__ `pg.Client` instance and successfully connects it to the backend.

      .query('SELECT $1::int AS "clientCount"', [client.count])

      .then(res => console.log(res.rows[0].clientCount)) // outputs 0

Fired whenever the a client is acquired from the pool

// This test is meant to be spawned from idle-timeout.js

  const allowExitOnIdle = process.env.ALLOW_EXIT_ON_IDLE === '1'

  const pool = new Pool({ maxLifetimeSeconds: 2, idleTimeoutMillis: 200, ...(allowExitOnIdle ? { allowExitOnIdle: true } : {}) })

    ...(allowExitOnIdle ? { allowExitOnIdle: true } : {}),

  pool.query('SELECT NOW()', (err, res) => console.log('completed first'))

    pool.query('SELECT * from generate_series(0, 1000)', (err, res) => console.log('completed second'))

		@@ -42,7 +42,7 @@ 'use strict'
		rej = reject
		}).catch(err => {
		}).catch((err) => {
		// replace the stack trace that leads to `TCP.onStreamRead` with one that leads back to the
		// application that created the query
		Error.captureStackTrace(err);
		throw err;
		Error.captureStackTrace(err)
		throw err
		})
		@@ -49,0 +49,0 @@ return { callback: cb, result: result }

		@@ -168,3 +168,3 @@ # pg-pool
		if (err) {
		return console.error('query error', e.message, e.stack)
		return console.error('query error', err.message, err.stack)
		}
		@@ -171,0 +171,0 @@ console.log('hello from', res.rows[0].name)

		{
		"name": "pg-pool",
		"version": "3.6.1",
		"version": "3.6.2",
		"description": "Connection pool for node-postgres",
		@@ -40,3 +40,3 @@ "main": "index.js",
		},
		"gitHead": "eaafac36dc8f4a13f1fecc9e3420d35559fd8e2b"
		"gitHead": "b03c071d2d15af259e1e008e9628191c865e58fa"
		}

		@@ -6,3 +6,7 @@ // This test is meant to be spawned from idle-timeout.js

		const pool = new Pool({ maxLifetimeSeconds: 2, idleTimeoutMillis: 200, ...(allowExitOnIdle ? { allowExitOnIdle: true } : {}) })
		const pool = new Pool({
		maxLifetimeSeconds: 2,
		idleTimeoutMillis: 200,
		...(allowExitOnIdle ? { allowExitOnIdle: true } : {}),
		})
		pool.query('SELECT NOW()', (err, res) => console.log('completed first'))
		@@ -9,0 +13,0 @@ pool.on('remove', () => {

Improved metrics