web-dev-qa-db-fra.com

Comment se connecter à Postgres via Node.js

Je me trouve en train de créer une base de données postgres. J'ai donc installé postgres et démarré un serveur avec initdb /usr/local/pgsql/data, puis j'ai démarré cette instance avec postgres -D /usr/local/pgsql/data maintenant, comment puis-je interagir avec ce noeud? Par exemple, que serait la connectionstring ou comment puis-je savoir ce que c'est?.

postgresqlnode.js
119
Doboy

Voici un exemple de connexion de node.js à ma base de données Postgres.

L’interface dans node.js que j’ai utilisée se trouve ici https://github.com/brianc/node-postgres

var pg = require('pg');
var conString = "postgres://YourUserName:YourPassword@localhost:5432/YourDatabase";

var client = new pg.Client(conString);
client.connect();

//queries are queued and executed one after another once the connection becomes available
var x = 1000;

while (x > 0) {
    client.query("INSERT INTO junk(name, a_number) values('Ted',12)");
    client.query("INSERT INTO junk(name, a_number) values($1, $2)", ['John', x]);
    x = x - 1;
}

var query = client.query("SELECT * FROM junk");
//fired after last row is emitted

query.on('row', function(row) {
    console.log(row);
});

query.on('end', function() {
    client.end();
});



//queries can be executed either via text/parameter values passed as individual arguments
//or by passing an options object containing text, (optional) parameter values, and (optional) query name
client.query({
    name: 'insert beatle',
    text: "INSERT INTO beatles(name, height, birthday) values($1, $2, $3)",
    values: ['George', 70, new Date(1946, 02, 14)]
});

//subsequent queries with the same name will be executed without re-parsing the query plan by postgres
client.query({
    name: 'insert beatle',
    values: ['Paul', 63, new Date(1945, 04, 03)]
});
var query = client.query("SELECT * FROM beatles WHERE name = $1", ['john']);

//can stream row results back 1 at a time
query.on('row', function(row) {
    console.log(row);
    console.log("Beatle name: %s", row.name); //Beatle name: John
    console.log("Beatle birth year: %d", row.birthday.getYear()); //dates are returned as javascript dates
    console.log("Beatle height: %d' %d\"", Math.floor(row.height / 12), row.height % 12); //integers are returned as javascript ints
});

//fired after last row is emitted
query.on('end', function() {
    client.end();
});

UPDATE: - LA fonction query.on est maintenant obsolète et le code ci-dessus ne fonctionnera donc pas comme prévu. Pour résoudre ce problème, consultez: - query.on n'est pas une fonction

309
Kuberchaun

Une approche simple: pg-promise , si vous connaissez les promesses, c’est;)

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

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

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

// select and return user name from id:
db.one('SELECT name FROM users WHERE id = $1', 123)
    .then(user => {
        console.log(user.name); // print user name;
    })
    .catch(error => {
        console.log(error); // print the error;
    });

Voir aussi: Comment déclarer correctement votre module de base de données .

28
vitaly-t

Juste pour ajouter une option différente - j’utilise Node-DBI pour me connecter à PG, mais aussi à cause de la possibilité de parler à MySQL et à sqlite. Node-DBI inclut également des fonctionnalités permettant de créer une instruction select, ce qui est pratique pour effectuer des tâches dynamiques à la volée.

Exemple rapide (utilisant les informations de configuration stockées dans un autre fichier):

var DBWrapper = require('node-dbi').DBWrapper;
var config = require('./config');

var dbConnectionConfig = { Host:config.db.Host, user:config.db.username, password:config.db.password, database:config.db.database };
var dbWrapper = new DBWrapper('pg', dbConnectionConfig);
dbWrapper.connect();
dbWrapper.fetchAll(sql_query, null, function (err, result) {
  if (!err) {
    console.log("Data came back from the DB.");
  } else {
    console.log("DB returned an error: %s", err);
  }

  dbWrapper.close(function (close_err) {
    if (close_err) {
      console.log("Error while disconnecting: %s", close_err);
    }
  });
});

config.js:

var config = {
  db:{
    Host:"plop",
    database:"musicbrainz",
    username:"musicbrainz",
    password:"musicbrainz"
  },
}
module.exports = config;
12
mlaccetti

Une solution peut être d'utiliser pool de clients comme suit:

const { Pool } = require('pg');
var config = {
    user: 'foo', 
    database: 'my_db', 
    password: 'secret', 
    Host: 'localhost', 
    port: 5432, 
    max: 10, // max number of clients in the pool
    idleTimeoutMillis: 30000
};
const pool = new Pool(config);
pool.on('error', function (err, client) {
    console.error('idle client error', err.message, err.stack);
});
pool.query('SELECT $1::int AS number', ['2'], function(err, res) {
    if(err) {
        return console.error('error running query', err);
    }
    console.log('number:', res.rows[0].number);
});

Vous pouvez voir plus de détails sur cette ressource .

2
OmG

Slonik est une alternative aux réponses proposées par Kuberchaun et Vitaly.

Slonik implémente gestion de la connexion sécurisée ; vous créez un pool de connexions et l’ouverture/le traitement des connexions est géré pour vous.

import {
  createPool,
  sql
} from 'slonik';

const pool = createPool('postgres://user:password@Host:port/database');

return pool.connect((connection) => {
  // You are now connected to the database.
  return connection.query(sql`SELECT foo()`);
})
  .then(() => {
    // You are no longer connected to the database.
  });

"postgres: // utilisateur: mot de passe @ hôte: port/base de données" est votre chaîne de connexion (plus canoniquement un URI ou DSN de connexion).

L'avantage de cette approche est que votre script garantit que vous ne laissez jamais accidentellement des connexions en suspens.

Les autres avantages de l’utilisation de Slonik sont les suivants:

1
Gajus