Comment se connecter à Postgres via Node.js

Je me surprends à essayer de créer une base de données postgres, alors j'ai 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/datamaintenant comment puis-je interagir avec cela via le nœud? Par exemple, quel serait le connectionstringproblème, ou comment puis-je savoir ce que c'est.

Voici un exemple que j'ai utilisé pour connecter node.js à ma base de données Postgres.

L'interface de node.js que j'ai utilisée peut être trouvée 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();
});

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

Une approche moderne et simple: pg-promise :

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

const 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';

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

// select and return a single 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;
    });

// alternative - new ES7 syntax with 'await':
// await db.one('SELECT name FROM users WHERE id = $1', [123]);

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

Juste pour ajouter une option différente - j'utilise Node-DBI pour me connecter à PG, mais aussi en raison de la possibilité de parler à MySQL et sqlite. Node-DBI inclut également des fonctionnalités pour créer une instruction select, ce qui est pratique pour faire des choses dynamiques à la volée.

Exemple rapide (en 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;

Une solution peut utiliser pooldes clients comme les suivants:

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 .

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

Slonik met en œuvre une gestion sûre des connexions ; vous créez un pool de connexions et l'ouverture / la gestion des connexions est gérée 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://user:password@host:port/database est votre chaîne de connexion (ou 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 suspendues.

Les autres avantages de l'utilisation de Slonik incluent:

• Assertions intégrées et sécurité de type.
• Traitement sécurisé des transactions.
• Interpolation de valeur sûre.
• Imbrication des transactions.
• Journalisation des détails.
• Résolution de trace de pile asynchrone.

Nous pouvons également utiliser postgresql-easy . Il est construit sur node-postgres et sqlutil . Remarque: pg_connection.js et your_handler.js sont dans le même dossier. db.js se trouve dans le dossier de configuration placé.

pg_connection.js

const PgConnection = require('postgresql-easy');
const dbConfig = require('./config/db');
const pg = new PgConnection(dbConfig);
module.exports = pg;

./config/db.js

module.exports =  {
  database: 'your db',
  host: 'your host',
  port: 'your port',
  user: 'your user',
  password: 'your pwd',
}

your_handler.js

  const pg_conctn = require('./pg_connection');

  pg_conctn.getAll('your table')
    .then(res => {
         doResponseHandlingstuff();
      })
    .catch(e => {
         doErrorHandlingStuff()     
      })