MemFire Cloud之微信小程序开发小游戏推箱子

# pg-pool [](https://travis-ci.org/brianc/node-pg-pool) A connection pool for node-postgres ## install ```sh npm i pg-pool pg ``` ## use ### create to use pg-pool you must first create an instance of a pool ```js var Pool = require('pg-pool') // by default the pool uses the same // configuration as whatever `pg` version you have installed var pool = new Pool() // you can pass properties to the pool // 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 var pool2 = new Pool({ database: 'postgres', user: 'brianc', password: 'secret!', port: 5432, ssl: true, max: 20, // set pool max size to 20 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 }) ``` ##### Note: 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. ```js const Pool = require('pg-pool'); const url = require('url') const params = url.parse(process.env.DATABASE_URL); const auth = params.auth.split(':'); const config = { user: auth[0], password: auth[1], host: params.hostname, port: params.port, database: params.pathname.split('/')[1], ssl: true }; const pool = new Pool(config); /* Transforms, 'postgres://DBuser:secret@DBHost:#####/myDB', into config = { user: 'DBuser', password: 'secret', host: 'DBHost', port: '#####', database: 'myDB', ssl: true } */ ``` ### acquire clients with a promise pg-pool supports a fully promise-based api for acquiring clients ```js var pool = new Pool() pool.connect().then(client => { client.query('select $1::text as name', ['pg-pool']).then(res => { client.release() console.log('hello from', res.rows[0].name) }) .catch(e => { client.release() console.error('query error', e.message, e.stack) }) }) ``` ### plays nice with async/await this ends up looking much nicer if you're using [co](https://github.com/tj/co) or async/await: ```js // with async/await (async () => { var pool = new Pool() var client = await pool.connect() try { var result = await client.query('select $1::text as name', ['brianc']) console.log('hello from', result.rows[0]) } finally { client.release() } })().catch(e => console.error(e.message, e.stack)) // with co co(function * () { var client = yield pool.connect() try { var result = yield client.query('select $1::text as name', ['brianc']) console.log('hello from', result.rows[0]) } finally { client.release() } }).catch(e => console.error(e.message, e.stack)) ``` ### your new favorite helper method because its so common to just run a query and return the client to the pool afterward pg-pool has this built-in: ```js var pool = new Pool() var time = await pool.query('SELECT NOW()') var name = await pool.query('select $1::text as name', ['brianc']) console.log(name.rows[0].name, 'says hello at', time.rows[0].now) ``` you can also use a callback here if you'd like: ```js var pool = new Pool() pool.query('SELECT $1::text as name', ['brianc'], function (err, res) { console.log(res.rows[0].name) // brianc }) ``` __pro tip:__ unless you need to run a transaction (which requires a single client for multiple queries) or you have some other edge case like [streaming rows](https://github.com/brianc/node-pg-query-stream) or using a [cursor](https://github.com/brianc/node-pg-cursor) you should almost always just use `pool.query`. Its easy, it does the right thing :tm:, and wont ever forget to return clients back to the pool after the query is done. ### drop-in backwards compatible pg-pool still and will always support the traditional callback api for acquiring a client. This is the exact API node-postgres has shipped with for years: ```js var pool = new Pool() pool.connect((err, client, done) => { if (err) return done(err) client.query('SELECT $1::text as name', ['pg-pool'], (err, res) => { done() if (err) { return console.error('query error', err.message, err.stack) } console.log('hello from', res.rows[0].name) }) }) ``` ### shut it down 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: ```js var pool = new Pool() var client = await pool.connect() console.log(await client.query('select now()')) client.release() await pool.end() ``` ### a note on instances 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: ```js // 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 var pool = new pg.Pool() // this is the right way to export the query method module.exports.query = (text, values) => { console.log('query:', text, values) return pool.query(text, values) } // this would be the WRONG way to export the connect method module.exports.connect = () => { // 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 var aPool = new pg.Pool() return aPool.connect() } ``` ### events Every instance of a `Pool` is an event emitter. These instances emit the following events: #### error 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. Example: ```js const Pool = require('pg-pool') const pool = new Pool() // 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 }) ``` #### connect Fired whenever the pool creates a __new__ `pg.Client` instance and successfully connects it to the backend. Example: ```js const Pool = require('pg-pool') const pool = new Pool() var count = 0 pool.on('connect', client => { client.count = count++ }) pool .connect() .then(client => { return client .query('SELECT $1::int AS "clientCount"', [client.count]) .then(res => console.log(res.rows[0].clientCount)) // outputs 0 .then(() => client) }) .then(client => client.release()) ``` #### acquire Fired whenever the a client is acquired from the pool Example: This allows you to count the number of clients which have ever been acquired from the pool. ```js var Pool = require('pg-pool') var