Aller au contenu

API Rest avec PostgreSQL

Il est très simple de migrer nos API vers une BD PostgreSQL.

PostgreSQL et Devilbox

Devilbox à déjà une instance de PostgreSQL qui est lancé quand on le démarre, pratique si on veut effectuer des tests. Elle est accessible via le port 5432 en localhost.

Par défaut le nom d'utilisateur est postgres et le mot de passe est vide. Il y a aussi une base de données appelée postgres où vous allez créer vos table.

À l'aide de votre IDE préféré créez une connexion vers l'instance PostgreSQL. Dans DBeaver, quand vous créer une nouvelle connexion vous devez choisir PostgreSQL au lieu de MariaDB. Vous devrez surement installer des pilotes, juste à suivre les indications.

postgres_01.png

Exemple avec DBeaver

Migration des données MySQL vers une BD PostgreSQL

Le plus simple à notre niveau est de refaire un script sql de création de tables. Les instructions et les types de données sont sensiblement les mêmes à quelques exceptions prêt. Voici un exemple de création de la table pokemon qu'on a utilisé à l'exercice 04.

create_table_pokemon.sql
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
drop table if exists public.pokemon;
CREATE TABLE public.pokemon (
    id SERIAL PRIMARY KEY,
    nom VARCHAR(50),
    type_primaire VARCHAR(50),
    type_secondaire VARCHAR(50),
    pv INTEGER,
    attaque INTEGER,
    defense INTEGER
);

Dans PosgreSQL il existe un concept de schemas qu'on ne couvrira pas (dans mon exemple public est le nom du schema). Le seul autre changement qu'on peut remarquer ici est au niveau du champ id qui est de type SERIAL, c'est l'équivalent du champs auto-increment.

Manuel

Connexion depuis un projet Express.js

Nous allons conserver la même structure de projet qu'on a utilisé jusqu'à maintenant. Dans le fichier .env ajoutez les entrées suivantes :

.env
PG_USER="postgres"
PG_HOST="localhost"
PG_DATABASE="postgres"
PG_PASSWORD=""
PG_PORT=5432

Les valeurs ci-dessus correspondent à une connexion à l'instance PostgreSQL de Devilbox.

Ensuite installer le module PG avec npm.

npm i pg

Maintenant créer un nouveau fichier nommé db_pg.js dans le répertoire ./src/config et copiez le code suivant :

dp_pg.js
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
const Pool = require('pg').Pool
const dotenv = require("dotenv");
dotenv.config();

const pool = new Pool({
  user: process.env.PG_USER,
  host: process.env.PG_HOST,
  database: process.env.PG_DATABASE,
  password: process.env.PG_PASSWORD,
  port: process.env.PG_PORT,
})

module.exports = pool;

Le fonctionnement est similaire à ce qu'on faisait avec MySQL, on créé un pool de connexion qui va être utilisé à chaque fois qu'on veut faire une requête.

La dernière chose à faire est d'utilisé le fichier db_pg.js au lieu de db.js dans vos modèles.

script.js
1
2
3
4
// Ancienne connexion à MySQL
// const sql = require("../config/db");
// Nouvelle connexion à PostGreSQL
const sql = require("../config/pg_db");

Modification des requètes préparées

La syntaxe pour passer des paramêtres à une requête préparée avec le module PG est un peu différente, vous allez devoir les modifier. Au lieu d'utiliser le caractère ? pour indiquer un paramêtre vous devez utiliser le signe de dollar suivi d'un nombre incrémenté à partir de 1.

const requete = 'SELECT id, nom, type_primaire, type_secondaire, pv, attaque, defense FROM public.pokemon WHERE type_primaire LIKE $1;';
// un autre exemple
const requete = 'INSERT INTO pokemon (nom, type_primaire, type_secondaire, pv, attaque, defense) VALUES ($1, $2, $3, $4, $5, $6)';

Vous devez aussi modifier la façon dont vous récupérez les résultats. Auparavant quand on lançait la requête avec sql.query on recevait un objet resultat qui contenait un tableau de toutes les lignes du résultat de la requête. Avec PG vous devez faire resultat.rows pour obtenir les résultats.

model.js
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
static trouverUnPokemon(id) {
        return new Promise((resolve, reject) => {
            const requete = 'SELECT id, nom, type_primaire, type_secondaire, pv, attaque, defense FROM pokemon WHERE id = $1';
            const parametres = [id];

            sql.query(requete, parametres, (erreur, resultat) => {
                if (erreur) {
                    console.log('Erreur sqlState : ' + erreur);
                    console.log(`Erreur sqlState ${erreur.sqlState} : ${erreur.sqlMessage}`);
                    reject(erreur);
                }

                resolve(resultat.rows);
            });
        });
    }

Et voilà! Vous êtes maintenant prêt à utiliser PostgreSQL