Qual é a maneira correta de usar o módulo postgresql node.js?

Estou escrevendo um aplicativo node.js no Heroku e usando o módulo pg . Não consigo descobrir a maneira "certa" de obter um objeto cliente para cada solicitação de consulta ao banco de dados.

A documentação usa código como este:

pg.connect(conString, function(err, client) {
  // Use the client to do things here
});

Mas certamente você não precisa chamar pg.connectdentro de todas as funções que usam o banco de dados, certo? Eu vi outro código que faz isso:

var conString = process.env.DATABASE_URL || "tcp://postgres:1234@localhost/postgres";
var client = new pg.Client(conString);
client.connect();
// client is a global so you can use it anywhere now

Estou inclinado para a segunda opção, pois acredito que a instância de banco de dados gratuita para Heroku é limitada a uma conexão de qualquer maneira, mas há alguma desvantagem em fazer isso dessa maneira? Preciso verificar se meu objeto cliente ainda está conectado antes de usá-lo?

Eu sou o autor de node-postgres . Em primeiro lugar, peço desculpas porque a documentação não deixou clara a opção certa: a culpa é minha. Vou tentar melhorar. Escrevi um Síntese agora para explicar isso porque a conversa ficou muito longa para o Twitter.

Usar pg.connecté o caminho a seguir em um ambiente web.

O servidor PostgreSQL só pode lidar com 1 consulta por vez por conexão. Isso significa que se você tiver 1 global new pg.Client()conectado ao seu back-end, seu aplicativo inteiro será controlado com base na rapidez com que o postgres pode responder às consultas. Ele literalmente alinhará tudo, enfileirando cada consulta. Sim, é assíncrono e está tudo bem ... mas você não prefere multiplicar sua taxa de transferência por 10x? Use pg.connect definir o pg.defaults.poolSizepara algo lógico (fazemos 25-100, não temos certeza do número certo ainda).

new pg.Clienté para quando você sabe o que está fazendo. Quando você precisa de um único cliente de longa duração por algum motivo ou precisa controlar com muito cuidado o ciclo de vida. Um bom exemplo disso é durante o uso LISTEN/NOTIFY. O cliente de escuta precisa estar por perto, conectado e não compartilhado para que possa lidar com as NOTIFYmensagens de maneira adequada . Outro exemplo seria ao abrir um cliente único para eliminar algumas coisas travadas ou em scripts de linha de comando.

Uma coisa muito útil é centralizar todo o acesso ao seu banco de dados em seu aplicativo em um arquivo. Não espalhe pg.connectchamadas ou novos clientes o tempo todo. Tenha um arquivo parecido db.jscom este:

module.exports = {
   query: function(text, values, cb) {
      pg.connect(function(err, client, done) {
        client.query(text, values, function(err, result) {
          done();
          cb(err, result);
        })
      });
   }
}

Dessa forma, você pode alterar sua implementação de pg.connectpara um pool personalizado de clientes ou o que for e só precisa alterar as coisas em um lugar.

Dê uma olhada no módulo node-pg-query que faz exatamente isso.

Eu sou o autor de pg-promessa , que simplifica o uso de node-postgres por meio de promessas.

Ele aborda as questões sobre a maneira correta de se conectar e desconectar do banco de dados, usando o pool de conexão implementado por node-postgres , entre outras coisas, como transações automatizadas.

Uma solicitação individual na pg-Promessa se resume apenas ao que é relevante para a sua lógica de negócios:

db.any('SELECT * FROM users WHERE status = $1', ['active'])
    .then(data => {
        console.log('DATA:', data);
    })
    .catch(error => {
        console.log('ERROR:', error);
    });

ou seja, você não precisa lidar com a lógica de conexão ao executar consultas, porque você configura a conexão apenas uma vez, globalmente, assim:

const pgp = require('pg-promise')(/*options*/);

const cn = {
    host: 'localhost', // server name or IP address;
    port: 5432,
    database: 'myDatabase',
    user: 'myUser',
    password: 'myPassword'
};
// alternative:
// const cn = 'postgres://username:password@host:port/database';

const db = pgp(cn); // database instance;

Você pode encontrar muitos outros exemplos no tutorial Aprenda por Exemplo ou na página inicial do projeto .

A piscina é o caminho a seguir. Algo como este

const { Pool } = require('pg');

    const pool = new Pool({
      connectionString: DATABASE_URL,
      ssl: false,
      max: 20,
      idleTimeoutMillis: 30000,
      connectionTimeoutMillis: 2000,
    });
    module.exports = {
        query: (text, params) => pool.query(text, params)
      }

pode ser usado como db.query('<BEGIN,COMMIT,ROLLBACK,your query,anything')

É melhor criar um pool de pg globalmente e cada vez que você precisar fazer uma operação de banco de dados, use o cliente e depois libere-o de volta para o pool. Assim que todas as operações de banco de dados forem concluídas, finalize o pool usandopool.end()

Código de amostra -

let pool = new pg.Pool(dbConfig);
pool.connect(function(err, client, done) {

if (err) {
    console.error('Error connecting to pg server' + err.stack);
    callback(err);
} else {
    console.log('Connection established with pg db server');

    client.query("select * from employee", (err, res) => {

            if (err) {
                console.error('Error executing query on pg db' + err.stack);
                callback(err);
            } else {
                console.log('Got query results : ' + res.rows.length);


               async.each(res.rows, function(empRecord) {   
                        console.log(empRecord.name);
                });
            }
            client.release();

        });
}

});  

Para obter mais detalhes, você pode consultar minha postagem do blog - Fonte

Como você pode ver na documentação, ambas as opções são válidas, então escolha a que preferir. Como você, eu escolheria a segunda opção.

Eu estava interessado em um manipulador muito simples para isso, então fiz o meu próprio sem torná-lo muito complicado. Não tenho ilusões de que seja super básico, mas pode ajudar algumas pessoas a começar. Basicamente, ele se conecta, executa consultas e trata os erros para você.

function runQuery(queryString, callback) {
  // connect to postgres database
  pg.connect(postgresDatabase.url,function(err,client,done) {
    // if error, stop here
    if (err) {console.error(err); done(); callback(); return;}
    // execute queryString
    client.query(queryString,function(err,result) {
      // if error, stop here
      if (err) {console.error(err+'\nQuery: '+queryString); done(); callback(); return;}
      // callback to close connection
      done();
      // callback with results
      callback(result.rows);
    });
  });
}

Então você usaria chamando-o desta forma:

runQuery("SELECT * FROM table", function(result) {
  // Whatever you need to do with 'result'
}

É assim que eu faço, uma espécie de "abordagem de todas as opções acima"

Promise = require 'bluebird'
pg = module.exports = require 'pg'

Promise.promisifyAll pg.Client.prototype
Promise.promisifyAll pg.Client
Promise.promisifyAll pg.Connection.prototype
Promise.promisifyAll pg.Connection
Promise.promisifyAll pg.Query.prototype
Promise.promisifyAll pg.Query
Promise.promisifyAll pg

connectionString = process.env.DATABASE_URL

module.exports.queryAsync = (sql, values) ->
  pg.connectAsync connectionString
  .spread (connection, release) ->
    connection.queryAsync sql, values
    .then (result) ->
      console.log result.rows[0]
    .finally ->
      release()