---
url: /articles/fonction-gs.md
description: >-
  Différentes cas d'utilisations de la fonction generate_series avec nombre,
  date, date heure
---

# Fonction generate\_series

## Introduction

Cette fonction est très polyvalente et permet de générer des séries de valeurs, ce qui est utile dans de nombreux scénarios

* Générateur de ligne avec incrément de 1 ou au choix,
* Générateur de plage de dates, mois, années, en spécifiant un interval (jours, mois, année, etc.),
* Générateur de date / heure, en spécifiant un interval (heure, minutes, seondes, etc.)

## Générer une série de nombres entiers

La forme la plus courante de `generate_series` permet de génèrer une série de nombres entiers.

### Syntaxe:

```sql
generate_series(start, stop[, step])
```

::: tip
Par defaut si le pas (step) n'est pas renseigné, celui-ci vaut `1`
:::

### Exemple:

Nous voulons un générateur de nombre impair, ci-dessous la requête de génération

```sql
SELECT * FROM generate_series(1, 10, 2);
```

### Résultat:

```
1
3
5
7
9
```

on peut également utilisé un pas négatif, dans ce cas il faut aboslument sur le `start`soit plus grand que le `stop`

```sql
SELECT * FROM generate_series(10, 1, -2);
```

### Résultat:

```
10
8
6
4
2
```

Vous remarquez dans ce cas que les nombres sont pairs, cela est du au fait que la valeur de `start` est pair.

## Générer une série de dates

`generate_series` peut aussi générer une série de dates, ce qui est utile pour créer des calendriers ou des rapports temporels.

### Syntaxe:

```sql
generate_series(start_date, end_date, interval)
```

### Exemple:

```sql
SELECT generate_series(
    '2025-10-01'::date,
    '2025-10-10'::date,
    '1 day'::interval
)::date AS date;
```

### Résultat:

```
2025-10-01
2025-10-02
2025-10-03
...
2025-10-10
```

## Générer une série de timestamps

Vous pouvez également générer des séries de timestamps, par exemple pour des analyses temporelles précises.

### Exemple:

```sql
SELECT generate_series(
    '2025-10-01 00:00:00'::timestamp,
    '2025-10-01 12:00:00'::timestamp,
    '1 hour'::interval
)::timestamp AS timestamp;
```

### Résultat:

```
2025-10-01 00:00:00
2025-10-01 01:00:00
...
2025-10-01 11:00:00
2025-10-01 12:00:00
```

## Utilisation avec une clause WITH (CTE)

`generate_series` est souvent utilisé dans une Common Table Expression (CTE) pour créer des jeux de données temporaires.

### Exemple:

```sql
WITH series AS (
    SELECT generate_series(1, 5) AS num
)
SELECT num as nombre, num * 2 AS double FROM series;
```

### Résultat:

```
nombre | double
-------|-------
1      | 2
2      | 4
3      | 6
4      | 8
5      | 10
```

## Générer des lignes manquantes dans un jeu de données

Si vous avez un jeu de données avec des valeurs manquantes, `generate_series` peut être utilisé pour combler les trous.

Pour cela nous allons utiliser le resultat du `generate_series` comme table principal, puis faire un `LEFT JOIN` pour récupérer
les données de ventes, le montant retourne `NULL` quand il n'y a pas de valeur, mais ici on utilise la fonction `COALESCE`
pour mettre  `0` si `NULL`

### Exemple:

Supposons une table `ventes` avec des dates manquantes:

```sql
WITH all_dates AS (
    SELECT generate_series(
        '2025-10-01'::date,
        '2025-10-05'::date,
        '1 day'::interval
    )::date AS date
)
SELECT
    a.date,
    COALESCE(v.montant, 0) AS montant
FROM all_dates a
LEFT JOIN ventes v ON a.date = v.date;
```

## Générer des séries personnalisées avec des fonctions

Vous pouvez combiner `generate_series` avec d'autres fonctions pour créer des séries personnalisées.

### Exemple:

```sql
SELECT
    generate_series(1, 5) AS num,
    chr(64 + generate_series(1, 5)) AS lettre;
```

### Résultat:

```
num | lettre
----|-------
1   | A
2   | B
3   | C
4   | D
5   | E
```

::: info

La requête ci-dessus peut également s'écrire

```sql
  SELECT
    generate_series(1, 5) AS num,
    chr(generate_series(65, 69)) AS lettre;
```

:::

La fonction `chr` permet d'obtenir la caractère à partir de la valeur décimale de la table `ASCII`

## Utilisation avec des jointures

`generate_series` peut être utilisé pour créer des jointures avec des tables existantes, par exemple pour générer des rapports par période.

### Exemple:

```sql
SELECT
    d.date,
    COUNT(o.id) AS nombre_commandes
FROM generate_series(
    '2025-10-01'::date,
    '2025-10-07'::date,
    '1 day'::interval
) AS d(date)
LEFT JOIN commandes o ON d.date = o.date_commande::date
GROUP BY d.date;
```

## Générer des séries de nombres décimaux

Vous pouvez aussi générer des séries de nombres décimaux en utilisant des valeurs de type `numeric`.

### Exemple:

```sql
SELECT generate_series(0.1, 1.0, 0.1) AS decimal_value;
```

### Résultat:

```
0.1
0.2
0.3
...
1.0
```

## Résumé des cas d'utilisation

| Cas d'utilisation                     | Exemple de syntaxe                                                                   |
|:--------------------------------------|:-------------------------------------------------------------------------------------|
| Série d'entiers                       | `SELECT * FROM generate_series(1, 10);`                                              |
| Série de dates                        | `SELECT generate_series('2025-10-01'::date, '2025-10-10'::date, '1 day'::interval);` |
| Série de timestamps                   | `SELECT generate_series('2025-10-01 00:00:00'::timestamp, ...);`                     |
| Combler des valeurs manquantes        | Utilisation avec `LEFT JOIN` et `COALESCE`                                           |
| Générer des séries personnalisées     | Combinaison avec d'autres fonctions                                                  |

---

---
url: /articles/sauvegarde.md
description: >-
  Cette page regroupe des séries d'article sur PostgreSQL en français concernant
  la sauvegarde et la restauration de la base de données
---

# Sauvegarde et restauration

## Introduction

La sauvegarde et la restauration font référence aux technologies et
pratiques permettant de réaliser des copies périodiques de données et
d'applications sur un périphérique secondaire distinct, puis
d'utiliser ces copies pour récupérer les données et les applications,
ainsi que les opérations commerciales dont elles dépendent.

La sauvegarde et la restauration sont utilisées si les données et les
applications d'origine sont perdues ou endommagées en raison d'une
panne de courant, d'une cyberattaque, d'une erreur humaine, d'une
catastrophe ou de tout autre événement imprévu.

## Sous PostgreSQL

Sous PostgreSQL par défaut il existe 3 type de sauvegarde.

* Sauvegarde de type SQL (Dump)
* Sauvegarde au niveau du système de fichier
* Sauvegarde en archivage continue

### Sauvegarde

La sauvegarde SQL (également appelé Dump) se réalise avec le programme
founit en standard
[pg\_dump](https://docs.postgresql.fr/current/app-pgdump.html).

### Restauration

la restauration de cette sauvegarde se fera avec le programme
[pg\_restore](https://docs.postgresql.fr/current/app-pgrestore.html)

## pg\_dump – Sauvegarde de bases PostgreSQL

### Description

pg\_dump est un outil en ligne de commande qui permet de sauvegarder une base de données PostgreSQL.

Avantages :

* Ne bloque pas les autres connexions.
* Plusieurs formats de sortie possibles.
* Permet de sauvegarder tout ou partie d’une base.

### Formats de sorties

| Format | Description | Extension |
|:------:|:------------|:---------:|
| SQL | Script SQL lisible et portable. | .sql |
| Custom | Format binaire optimisé pour pg\_restore. | .dump |
| Directory | Un fichier par table, idéal pour les grosses BDD. | /dir/ |
| Tar | Format binaire compressé, compatible avec tar. | .tar |

### Options courantes

| Option | Description |
|--------|-------------|
| -U utilisateur | Nom de l’utilisateur PostgreSQL |
| -h hôte | Adresse du serveur PostgreSQL |
| -p port | Port de connexion (par défaut : 5432) |
| -d base | Nom de la base à sauvegarder |
| -F format | Format de sortie (p, c, d, t) |
| -f fichier | Fichier de sortie |
| -W | Demande le mot de passe |
| --clean | Nettoie les objets avant recréation |
| --if-exists | Utilise IF EXISTS pour éviter les erreurs |

### Exemples d’utilisation

#### Sauvegarde complète en SQL

```shell
pg_dump -U mon_user -h localhost -p 5432 -d ma_base -F p -f sauvegarde.sql
```

#### Sauvegarde en format custom (binaire)

```shell
pg_dump -U mon_user -d ma_base -F c -f sauvegarde.dump
```

#### Sauvegarde en format directory

```shell
pg_dump -U mon_user -d ma_base -F d -f sauvegarde_dir/
```

#### Sauvegarde avec compression

```shell
pg_dump -U mon_user -d ma_base -F c -f - | gzip > sauvegarde.dump.gz
```

#### Sauvegarde d’un schéma spécifique

```shell
pg_dump -U mon_user -d ma_base -n mon_schema -f schema.sql
```

#### Sauvegarde des données uniquement

```shell
pg_dump -U mon_user -d ma_base -a -f données.sql
```

## pg\_restore – Restauration de bases PostgreSQL

### Description

pg\_restore permet de restaurer une base de données PostgreSQL à partir d’un fichier créé par pg\_dump (surtout en formats custom, directory ou tar).

Avantages :

* Restauration sélective (tables, schémas, etc.).
* Contrôle fin sur les options de restauration.
* Optimisé pour les gros volumes.

#### Formats supportés

| Format | Description |
|:------:|-------------|
| Custom | Format binaire optimisé pour pg\_restore |
| Directory | Un fichier par table, idéal pour les grosses BDD |
| Tar | Format binaire compressé, compatible avec tar |

::: warning
Ne fonctionne pas avec les sauvegardes en format SQL pur (.sql)

utiliser la commande [psql](https://docs.postgresql.fr/17/app-psql.html "terminal interactif PostgreSQL") dans ce cas
:::

#### Options courantes

| Option | Description |
|:------:|-------------|
| -U utilisateur | Nom de l’utilisateur PostgreSQL |
| -h hôte | Adresse du serveur PostgreSQL |
| -p port | Port de connexion (par défaut : 5432) |
| -d base | Base cible pour la restauration |
| -F format | Format de la sauvegarde (c, d, t) |
| -j nombre | Nombre de jobs parallèles (accélère la restauration) |
| --clean | Nettoie les objets avant recréation |
| --if-exists | Utilise IF EXISTS pour éviter les erreurs |
| --no-owner | Ignore les propriétaires des objets |
| --no-privileges | Ne restaure pas les permissions |
| -v | Mode verbeux |
| -l | Liste le contenu de la sauvegarde |

### Exemples d’utilisation

#### Restauration complète (format custom)

```shell
pg_restore -U mon_user -d ma_base -F c sauvegarde.dump
```

#### Restauration avec jobs parallèles (4 jobs)

```shell
pg_restore -U mon_user -d ma_base -j 4 -F c sauvegarde.dump
```

#### Restauration sélective (une seule table)

```shell
pg_restore -U mon_user -d ma_base -t ma_table -F c sauvegarde.dump
```

#### Restauration en mode "clean" (nettoyage avant)

```shell
pg_restore -U mon_user -d ma_base --clean --if-exists -F c sauvegarde.dump
```

#### Lister le contenu d’une sauvegarde

```shell
pg_restore -l -F c sauvegarde.dump
```

#### Restauration depuis un format directory

```shell
pg_restore -U mon_user -d ma_base -F d sauvegarde_dir/
```

#### Depuis un script SQL

```shell
psql -U mon_user -d ma_base -f sauvegarde.sql
```

::: warning

Dans cet exemple on utilise [psql](https://docs.postgresql.fr/17/app-psql.html "terminal interactif PostgreSQL") au lieu de [pg\_restore](https://docs.postgresql.fr/17/app-pgrestore.html "terminal de restauration")
:::

## pgBackRest – Sauvegarde et Restauration PostgreSQL

### Description

[pgBackRest](https://pgbackrest.org/ "Sauvegarde et restauration PostgreSQL fiables") est un outil open source conçu pour gérer les sauvegardes fiables, performantes et automatisées des bases de données PostgreSQL.

Avantages :

* Sauvegardes incrémentielles et différentielles.
* Compression et chiffrement natifs.
* Restauration rapide et flexible (PITR, tablespaces, etc.).
* Intégration facile avec les environnements de production.
* Support des clusters et réplications.

### Concepts clés

| Concept | Description |
|:-------:|:------------|
| Full Backup | Sauvegarde complète de la base |
| Incremental Backup | Sauvegarde uniquement les changements depuis la dernière sauvegarde |
| Differential Backup | Sauvegarde les changements depuis la dernière sauvegarde complète |
| PITR | Restauration à un point précis dans le temps (Point-In-Time Recovery) |
| Stanza | Configuration logique d’une base ou d’un cluster à sauvegarder |
| Repository | Emplacement de stockage des sauvegardes (local, S3, SFTP, etc.) |

### Installation

Sur Debian/Ubuntu

```shell
sudo apt-get install pgbackrest
```

Sur RHEL/CentOS

```shell
sudo yum install pgbackrest
```

### Configuration minimale

```ini
[global]
repo1-path=/var/lib/pgbackrest
repo1-retention-full=2
log-level-console=info

[ma_stanza]
pg1-path=/var/lib/postgresql/17/main
```

### Commandes de base

#### Initialiser une stanza

```shell
pgbackrest --stanza=ma_stanza stanza-create
```

#### Sauvegarde complète

```shell
pgbackrest --stanza=ma_stanza --type=full backup
```

#### Sauvegarde incrémentielle

```shell
pgbackrest --stanza=ma_stanza --type=incr backup
```

#### Vérifier l’état des sauvegardes

```shell
pgbackrest info
```

#### Restauration complète

```shell
pgbackrest --stanza=ma_stanza restore
```

#### Restauration PITR (Point-In-Time Recovery)

```shell
pgbackrest --stanza=ma_stanza --type=time --target="2025-09-13 12:00:00+00" restore
```

### Exemples avancés

#### Sauvegarde avec compression et chiffrement

```ini
[global]
repo1-cipher-type=aes-256-cbc
repo1-cipher-pass=mon_mot_de_passe
compress-level=3
```

#### Sauvegarde vers un repository distant (S3)

```ini
[global]
repo1-type=s3
repo1-s3-bucket=mon-bucket-pgbackrest
repo1-s3-endpoint=s3.eu-west-3.amazonaws.com
repo1-s3-region=eu-west-3
repo1-s3-key=ma_clé
repo1-s3-key-secret=ma_clé_secrète
```

#### Restauration vers un nouvel emplacement

```shell
pgbackrest --stanza=ma_stanza --pg1-path=/nouveau/chemin/data restore
```

### Documentation officielle

* [Site officiel pgBackRest](https://pgbackrest.org/ "Site officiel")
* [Guide utilisateur](https://pgbackrest.org/user-guide-index.html "Guide utilisateur en Anglais")
* [Guide des commandes en ligne](https://pgbackrest.org/command.html "Liste des commandes")
* [Guide de la configuration](https://pgbackrest.org/configuration.html "Guide de la configuration")

## Articles divers

### Sauvegarde

* [Faire une sauvegarde avec
  pgBackRest](http://laetitia-avrot.blogspot.fr/2017/02/faire-une-sauvegarde-avec-pgbackrest.html)

### Restauration

* [Restaurer avec
  pgBackRest](http://laetitia-avrot.blogspot.fr/2017/02/restaurer-avec-pgbackrest.html)

---

---
url: /articles/replication.md
description: >-
  Cette page regroupe des séries d'article sur PostgreSQL en français concernant
  la réplication de la base de données
---

# Réplication

## Introduction

La réplication de base de données consiste à copier électroniquement et
fréquemment des données d'une base de données d'un ordinateur ou d'un
serveur vers une base de données d'un autre, de sorte que tous les
utilisateurs partagent le même niveau d'informations.

Le résultat est une base de données distribuée dans laquelle les
utilisateurs peuvent accéder r apidement aux données pertinentes pour
leurs tâches sans interférer avec le travail des autres. De nombreux
éléments contribuent au processus global de création et de gestion de la
réplication de base de données.

Voici les principales méthodes de **réplication** disponibles sous **PostgreSQL**, classées par type et usage :

## Réplication Physique (binaire)

* **Fonctionnement** : Copie exacte des fichiers de données (WAL - Write-Ahead Log).
* **Méthodes** :
  * **Réplication continue (Streaming Replication)** :
    * Le serveur principal envoie les WAL en temps réel aux réplicas.
    * Utilisé pour la haute disponibilité et la tolérance aux pannes.
  * **Réplication par archive (Log Shipping)** :
    * Les WAL sont archivés et restaurés sur le réplica.
    * Moins temps réel, mais plus simple à mettre en place.

## Réplication Logique

* **Fonctionnement** : Copie des données au niveau logique (tables, lignes).
* **Méthodes** :
  * **Publication/Souscription (Publishing/Subscribing)** :
    * Permet de répliquer des tables spécifiques entre bases, même de versions différentes.
    * Idéal pour la synchronisation partielle ou la migration.
  * **Extensions tierces** :
    * `pglogical`, `Londiste`, `Bucardo` : pour des besoins avancés ou multi-maîtres.

## Réplication Multi-Maître

* **Fonctionnement** : Plusieurs nœuds acceptent les écritures.
* **Solutions** :
  * **PostgreSQL natif** : Limité, nécessite des outils externes.
  * **Extensions** : `BDR`, `Citus` (pour le sharding et la réplication distribuée).
  * **Solutions externes** : `pgpool-II` (avec gestion de conflit).

## Réplication par Trigger

* **Fonctionnement** : Utilisation de triggers pour copier les modifications vers une autre base.
* **Avantages/Inconvénients** : Flexible mais complexe et moins performant.

## Réplication via Outils Externes

* **Exemples** :
  * `pgpool-II` : Gestion de pool de connexions et réplication.
  * `Slony` : Réplication asynchrone multi-maître.
  * `Barman` : Sauvegarde et restauration, utile pour la réplication de secours.

## Résumé des cas d’usage

| Type de réplication         | Cas d’usage principal                       | Complexité |
|-----------------------------|---------------------------------------------|------------|
| Streaming Replication       | Haute disponibilité, failover               | Moyenne    |
| Log Shipping                | Sauvegarde à distance, PRA                  | Faible     |
| Publication/Souscription    | Synchronisation partielle, migration        | Faible     |
| Multi-Maître                | Écritures distribuées, tolérance aux pannes | Élevée     |
| Trigger                     | Synchronisation personnalisée               | Élevée     |

## Articles DIvers

* [PostgreSQL 10 et la réplication logique -- Fonctionnement](https://blog.anayrat.info/2017/07/29/postgresql-10-et-la-replication-logique-fonctionnement/)
* [PostgreSQL 10 et la réplication logique -- Mise en oeuvre](https://blog.anayrat.info/2017/08/05/postgresql-10-et-la-replication-logique-mise-en-oeuvre/)
* [PostgreSQL 10 et la réplication logique -- Restrictions](https://blog.anayrat.info/2017/08/27/postgresql-10-et-la-replication-logique-restrictions/)
* [PostgreSQL et la réplication logique](http://www.loxodata.com/post/replicationlogique/)

---

---
url: /articles/maintenance.md
description: >-
  Cette page regroupe des séries d'article sur PostgreSQL en français concernant
  les opérations de maintenance de la base de données
---

# Maintenance

Voici les principales opérations de maintenance possibles sous **PostgreSQL** pour assurer la performance,
la fiabilité et la durabilité de votre base de données:

## VACUUM

* **But** : Nettoyer les lignes mortes (tuples) laissées par les mises à jour ou suppressions, libérer de l’espace et éviter le gonflement des tables.
* **Variantes** :
  * `VACUUM` : Nettoyage standard.
  * `VACUUM FULL` : Réorganise physiquement la table, plus lent mais plus efficace.
  * `VACUUM ANALYZE` : Nettoie et met à jour les statistiques pour l’optimiseur de requêtes.

## ANALYZE

* **But** : Mettre à jour les statistiques utilisées par l’optimiseur de requêtes pour générer des plans d’exécution optimaux.
* **Utilisation** : Souvent combiné avec `VACUUM` (`VACUUM ANALYZE`).

## REINDEX

* **But** : Reconstruire les index corrompus ou fragmentés.
* **Utilisation** : `REINDEX TABLE ma_table;` ou `REINDEX DATABASE ma_base;`

## CLUSTER

* **But** : Réorganiser physiquement une table selon un index pour améliorer les performances de lecture.
* **Utilisation** : `CLUSTER ma_table USING mon_index;`

## Maintenance des logs et archives WAL

* **But** : Gérer les fichiers de journalisation (WAL) pour la réplication et la récupération après incident.
* **Actions** :
  * Archiver les WAL (`archive_command`).
  * Nettoyer les anciens WAL (`pg_archivecleanup`).

## Gestion des connexions et verrous

* **But** : Identifier et résoudre les blocages ou connexions bloquantes.
* **Outils** :
  * `pg_stat_activity` : Voir les connexions actives.
  * `pg_locks` : Voir les verrous.

## Mise à jour des statistiques système

* **But** : Assurer que PostgreSQL dispose des informations les plus récentes sur la distribution des données.
* **Utilisation** : `ANALYZE;` ou `VACUUM ANALYZE;`

## **Gestion de l’autovacuum**

* **But** : Configurer le processus automatique de nettoyage (`autovacuum`) pour éviter les interventions manuelles.
* **Paramètres** : `autovacuum`, `autovacuum_vacuum_threshold`, etc.

## Vérification de l’intégrité des données

* **But** : Détecter les corruptions de données.
* **Outils** : `pg_checksums` (si activé), `pg_verifybackup`.

## Quand les utiliser ?

* **Régulièrement** : `VACUUM`, `ANALYZE`, surveillance des logs.
* **Après des opérations massives** : `REINDEX`, `CLUSTER`.
* **En cas de problème** : Vérification des verrous, intégrité des données.

## Articles Divers

* [Analyse du
  VACUUM](https://web.archive.org/web/20181129020959/http://blog.guillaume.lelarge.info/index.php/category/Postgresql)
* [Comment quantifier le
  maintenance\_work\_mem](https://web.archive.org/web/20181128143819/http://blog.guillaume.lelarge.info/index.php/post/2015/07/14/Comment-quantifier-le-maintenance_work_mem)
* [Liste et taille des bases, des schémas et des tables en
  postgreSQL](http://laetitia-avrot.blogspot.fr/2011/04/psql.html)

---

---
url: /articles.md
description: Articles divers sur PostgreSQL
---

# Articles sur PostgreSQL

Cette page regroupe des séries d'articles sur PostgreSQL en français,
cela couvre les différentes thématiques comme:

* utilisation **psql**
* les journaux de transactions
* les types de données telles que JSON et JSONB
* l'utilisation des VACUUM et AUTOVACUUM
* les extensions
* [Les coûts](./cout.md "Coûts d'acquisition de PostgreSQL")
* [Généralité](./generalite.md "Généralité")
* [Types](./types.md "Les Types")
* [Les index](./indexes.md "Les index")
* [Les langages de procédures](./plangages.md "Les langages de procédures")
* [Maintenance](./maintenance.md "Maintenance")
* [Réplication](./replication.md "Réplication PostgreSQL")
* [Sauvegarde et restauration](./sauvegarde.md "Sauvegarde PostgreSQL")
* [Fonction generate\_series](./fonction-gs.md "Fonction generate_series")

---

---
url: /clients.md
description: Listes de clients graphiques et lignes de commande pour PostgreSQL
---

# Clients graphiques et ligne de commande

`PostgreSQL` possède une multitude de clients graphique ou en ligne de commande. Parmi ces clients, certains sont davantage des outils d’administration,
tandis que d’autres offrent des fonctionnalités utiles aux développeurs, certains proposent un mix des deux.

Voici une liste des principaux clients pour interagir avec PostgreSQL, classés en deux catégories : **clients graphiques** et **clients en ligne de commande**.

## Clients Graphiques (GUI)

| Nom | Description | Plateformes supportées |
|:---:|:------------|:----------------------:|
| [pgAdmin 4](https://www.pgadmin.org) | L’outil officiel, riche en fonctionnalités, idéal pour l’administration. | Windows, macOS, Linux, Web |
| [DBeaver](https://dbeaver.io) | Client universel supportant PostgreSQL et bien d’autres bases de données. | Windows, macOS, Linux  |
| [TablePlus](https://tableplus.com/)  | Interface moderne, légère et intuitive. | Windows, macOS, Linux |
| [DataGrip](https://www.jetbrains.com/fr-fr/datagrip/) | IDE puissant de JetBrains pour les bases de données. | Windows, macOS, Linux  |
| **OmniDB**                | Client open source, orienté développement et administration. | Windows, macOS, Linux |
| [SQLPro for PostgreSQL](https://macpostgresclient.com/) | Client natif pour macOS, simple et efficace. | macOS |
| [pgweb](https://sosedoff.github.io/pgweb/) | Client web mais compilé poru les différentes plateformes | Windows, macOS, Linux, Web     |
| [Adminer](https://www.adminer.org) | Gestionnaire de base de données pour administation à distance | Web |
| [Navicat for PostgreSQL](https://www.navicat.com/en/products/navicat-for-postgresql) | Outil de gestion de base de données facile à utiliser conçu pour simplifier les complexités de la gestion des serveurs PostgreSQL |  Windows macOS Linux iOS |
| [PostgreSQL Maestro](https://www.sqlmaestro.com/products/postgresql/maestro/) | PostgreSQL Tools Family contient des outils d'interface graphique pour l'administration et le développement du serveur PostgreSQL | Windows |

## Clients en Ligne de Commande (CLI)

| Nom  | Description                                                                 | Plateformes supportées         |
|:----:|-----------------------------------------------------------------------------|--------------------------------|
| [psql](https://docs.postgresql.fr/17/app-psql.html) | Client officiel de PostgreSQL, puissant et scriptable. | Windows, macOS, Linux  |
| [pgcli](https://www.pgcli.com/) | Alternative à psql avec autocomplétion et syntaxe colorée. | Windows, macOS, Linux  |
| [usql](https://github.com/xo/usql) | universal command-line interface for PostgreSQL and other databases | Windows, macOS, Linux |

::: info Remarque

* **psql** est installé par défaut avec PostgreSQL.
* Pour les outils tiers, vérifie toujours la compatibilité avec ta version de PostgreSQL.
  :::

## Outil de modélisation

| Nom  | Description | Plateformes supportées |
|:----:|-------------|:----------------------:|
| [pgModeler](http://www.pgmodeler.com.br/) | pgModeler est un modeleur de base de données open source et multiplateforme conçu spécifiquement pour PostgreSQL | Linux, macOS, Windows |
| [DbVisualizer](https://www.dbvis.com/database/postgresql/features/) | DbVisualizer a été conçu pour vous offrir un contrôle maximal sur votre base de données PostgreSQL | Linux, macOS, Windows |

## Monitoring

| Nom  | Description | Plateformes supportées |
|:----:|-------------|:----------------------:|
| [temBoard](https://github.com/dalibo/temboard) | PostgreSQL Remote Control | |
| [pgwatch](https://github.com/cybertec-postgresql/pgwatch/) | Monitoring / tableau de bord pour PostgreSQL | |

## Agent

| Nom  | Description | Plateformes supportées |
|:----:|-------------|:----------------------:|
| [pg\_listen](https://github.com/begriffs/pg_listen) | Utilise Listen/Notify pour executer des commandes shell | Linux, macOS, Windows |
| [pgAgent](https://www.pgadmin.org/docs/pgadmin4/development/pgagent.html) | Planificateur de tâche sous PostgreSQL | Linux, macOS, Windows |

---

---
url: /commun.md
---

to be deleted

---

---
url: /programmation/powershell.md
description: Connexion à une base de données PostgreSQL en powershell
---

# Powershell avec PostgreSQL

## Qu’est-ce que PowerShell ?

Avant d'attaquer avec des exemples en Powershell, il convient de faire un explication rapide
sur ce qu'est PowerShell

### Introduction

**PowerShell** est un **shell de ligne de commande** et un **langage de script** développé par Microsoft, principalement utilisé pour l’automatisation des tâches,
la gestion des systèmes et l’administration des environnements Windows (mais aussi Linux et macOS depuis 2016).

Il permet aux administrateurs et aux développeurs d’automatiser des processus répétitifs, de gérer des configurations, et d’interagir avec le système d’exploitation, les applications et les services de manière efficace.

#### Version de PowerShell

| Version,Plateforme | Basé sur | Multiplateforme | Compatibilité modules Windows |
| :----------------: | :---: | :---: | :---: |
|1.0 à 5.1|Windows|.NET Framework|Non|Oui|
|Core 6.0+|Windows/Linux/mac|.NET Core|Oui|Partielle|
|7.0+|Windows/Linux/mac|.NET 5/6/7/8|Oui|Très bonne|

::: info Quelle version utiliser ?

* Pour les environnements Windows traditionnels : PowerShell 5.1 (stable et complet).
* Pour les environnements multiplateformes ou modernes : PowerShell 7.4 (ou la dernière version disponible).
  :::

#### Points clés

* **Shell interactif** : Permet d’exécuter des commandes en temps réel.
* **Langage de script** : Permet d’écrire des scripts (.ps1) pour automatiser des tâches complexes.
* **Basé sur des objets** : Contrairement aux shells traditionnels (comme cmd.exe) qui manipulent du texte, PowerShell manipule des **objets** (instances de classes .NET),
  ce qui facilite la gestion des données et l’intégration avec d’autres technologies Microsoft.
* **Extensible** : Grâce à des **modules** et des **cmdlets** (commandes spécialisées), il est possible d’étendre ses fonctionnalités.

### Briques technologiques de PowerShell

PowerShell repose sur plusieurs technologies clés:

| Brique technologique                  | Rôle                                                                                           |
|---------------------------------------|------------------------------------------------------------------------------------------------|
| **.NET Framework/.NET Core**          | PowerShell est construit sur .NET, ce qui lui permet de manipuler des objets .NET directement. |
| **Cmdlets**                           | Commandes spécialisées (ex: `Get-Process`, `Set-Service`) écrites en .NET.                     |
| **Modules**                           | Regroupent des cmdlets et des fonctions pour étendre PowerShell.                               |
| **Pipeline**                          | Permet de chaîner des commandes et de transmettre des objets entre elles.                      |
| **WS-Management (WinRM)**             | Protocole utilisé pour la gestion à distance des machines.                                     |
| **PowerShell Remoting**               | Permet d’exécuter des commandes sur des machines distantes.                                    |
| **Desired State Configuration (DSC)** | Outil de gestion de configuration basé sur PowerShell.                                         |

### En résumé

PowerShell est un outil puissant pour l’automatisation et l’administration système,
construit sur **.NET** et enrichi par des **cmdlets**,
des **modules** et des protocoles de gestion à distance.

Il est largement utilisé par les administrateurs système, les DevOps et les développeurs pour gérer des infrastructures locales ou cloud.

Et comme il est basé sur **.NET** on peut utiliser le driver ODBC ou tout autre bibliothèque qui permet de se connecter à PostgreSQL comme [Npgsql](https://www.npgsql.org/ ".NET Access to PostgreSQL")

## Accès avec le driver ODBC

Pour notre exemple de script PowerShell qui utilise le driver `ODBC` officiel pour se connecter à une base de données PostgreSQL. Ce script suppose que le driver ODBC pour PostgreSQL est déjà installé sur votre machine (par exemple, [psqlODBC](https://odbc.postgresql.org/ "Driver ODBC for Windows") en version 32 ou 64 bits).

La documentation d'installation en français se trouve dans [cette partie](../installation/odbc-windows.md "Installation driver ODBC").

### Prérequis

* PowerShell 5.1 et 7.0+
* Le driver ODBC pour PostgreSQL doit être installé (de préférence utiliser la version 64 bits).
* Une source de données ODBC (DSN) doit être configurée, ou vous pouvez utiliser une chaîne de connexion directe.

### Exemple de script PowerShell

```powershell
# Paramètres de connexion
$server = "localhost"          # ou l'adresse IP/nom du serveur PostgreSQL
$port = "5432"                 # port par défaut de PostgreSQL
$database = "nom_de_votre_base"
$username = "votre_utilisateur"
$password = "votre_mot_de_passe"

# Chaîne de connexion ODBC (sans DSN)
$connectionString = "Driver={PostgreSQL Unicode};Server=$server;Port=$port;Database=$database;Uid=$username;Pwd=$password;"

try {
    # Création de l'objet de connexion ODBC
    $connection = New-Object System.Data.Odbc.OdbcConnection($connectionString)

    # Ouverture de la connexion
    $connection.Open()

    Write-Host "Connexion à PostgreSQL réussie !" -ForegroundColor Green

    # Récupération de la version de PostgreSQL
    $query = "SELECT version();"
    $command = New-Object System.Data.Odbc.OdbcCommand($query, $connection)
    $reader = $command.ExecuteReader()

    # Affichage du résultat
    while ($reader.Read()) {
        Write-Host "Version de PostgreSQL : " $reader[0]
    }

    # Fermeture de la connexion
    $reader.Close()
    $connection.Close()
}
catch {
    Write-Host "Erreur lors de la connexion ou de l'exécution de la requête : $_" -ForegroundColor Red
}
finally {
    # Même si c'est un script, on ferme la connexion pour que les ressources cotés serveur soient récupérées
    if ($connection.State -eq 'Open') {
        $connection.Close()
    }
}
```

### Explications

* **Driver={PostgreSQL Unicode}** : Spécifie le driver ODBC à utiliser. Assurez-vous que le nom correspond exactement à celui installé sur votre système.
* **Server, Port, Database, Uid, Pwd** : Remplacez par vos informations de connexion.
* **System.Data.Odbc** : Utilise la classe .NET pour les connexions ODBC.

### Configuration du DSN (optionnel)

Si vous préférez utiliser un DSN, configurez-le via l'outil "ODBC Data Source Administrator" (version 32 ou 64 bits), puis remplacez la chaîne de connexion par :

```powershell
$connectionString = "DSN=nom_de_votre_dsn;Uid=$username;Pwd=$password;"
```

### Remarques

* Assurez-vous que le module .NET `System.Data` est disponible (il l'est par défaut sous Windows).
* Pour tester, exécutez le script dans une session PowerShell avec les droits nécessaires.

## Accès avec Npgsql

Voici un exemple complet d’utilisation de **Npgsql** avec **PowerShell** pour interagir avec une base de données PostgreSQL, incluant l’installation de la bibliothèque.

### Prérequis

* PowerShell >= 7.0+
* Driver Npgsql et toute ses dépendances.

### Installation de Npgsql

Pour utiliser Npgsql dans PowerShell, il faut d’abord installer le package NuGet. Celui-ci n'est pas disponible pour PowerShell directement,
quelques manipulations supplémentaires vont être nécessaire.

#### Méthode 1 : Creation d'un projet Dotnet

Je vous ai préparé un dépôt contenant un projet minimal, pour la génération et le test de la librairie.

::: warning

Pour pouvoir compiler le projet il faut que vous ayez installer le SDK dotnet, pour cela utiliser winget dans un terminal.

La commande ci-dessous installera la version 8.0 de dotnet

```shell
winget install --id Microsoft.DotNet.SDK.8 -e
```

:::

```shell
git clone https://github.com/5432-fr/powershell-npgsql.git
```

puis executer les commandes suivantes

```shell
dotnet restore
dotnet build
dotnet publish -c Release --sc true -o .\build
Compress-Archive -Path .\build\*.dll -DestinationPath .\PowerShell-Npgsql-9.0.4.zip
```

Tous le nécessaire est disponible dans le fichier ZIP `PowerShell-Npgsql-9.0.4.zip`

#### Méthode 2 : Téléchargement fichier ZIp

La méthode 1 nécessite quelques connaissances en programmation Dotnet,
je vous ai donc préparé un fichier ZIP disponible à cette [adresse](https://github.com/5432-fr/powershell-npgsql/releases)

### Exemple d’utilisation de Npgsql avec PowerShell

Voici un script PowerShell qui se connecte à une base PostgreSQL, exécute une requête et affiche les résultats :

```powershell
# Charger l'assembly Npgsql
Add-Type -Path "C:\Chemin\Vers\Npgsql.dll"  # Remplacez par le chemin réel

# Paramètres de connexion
$connectionString = "Host=localhost;Username=postgres;Password=votre_mot_de_passe;Database=nom_de_votre_base"

# Créer et ouvrir la connexion
$connection = New-Object Npgsql.NpgsqlConnection($connectionString)
$connection.Open()

# Créer une commande SQL
$command = $connection.CreateCommand()
$command.CommandText = "SELECT version();"

# Exécuter la commande et récupérer les résultats
$reader = $command.ExecuteReader()

# Afficher les résultats
while ($reader.Read()) {
    Write-Host "Version de PostgreSQL : " $reader[0]
}

# Fermer la connexion
$reader.Close()
if ($connection.State -eq 'Open') {
    $connection.Close()
}
```

### Exemple complet avec gestion des erreurs

```powershell
try {
    Add-Type -Path "C:\Chemin\Vers\Npgsql.dll"

    $connectionString = "Host=localhost;Username=postgres;Password=votre_mot_de_passe;Database=nom_de_votre_base"
    $connection = New-Object Npgsql.NpgsqlConnection($connectionString)
    $connection.Open()

    $command = $connection.CreateCommand()
    $command.CommandText = "SELECT version();"

    $reader = $command.ExecuteReader()

    while ($reader.Read()) {
        Write-Host "Version de PostgreSQL : " $reader[0]
    }

    $reader.Close()
    $connection.Close()
}
catch {
    Write-Error "Une erreur est survenue : $_"
}
finally {
    if ($connection.State -eq 'Open') {
        $connection.Close()
    }
}
```

### Remarques importantes

* Remplacez `Host`, `Username`, `Password` et `Database` par vos propres valeurs.
* Si vous utilisez PowerShell 7+, vous pouvez aussi installer Npgsql via `dotnet add package Npgsql` dans un projet .NET et référencer la DLL générée.

## Affichage d'une fenêtre de saisie

Si l'on souhaite afficher une fenêtre demandant de saisir un login et un mot de passe avant d'établir la connexion,
nous pouvons utiliser les Windows Forms

```powershell
# Chargement de Windows Forms 
Add-Type -AssemblyName System.Windows.Forms

# Création du formulaire
$form = New-Object System.Windows.Forms.Form
$form.Text = "Authentification"
$form.Size = New-Object System.Drawing.Size(300,200)
$form.StartPosition = "CenterScreen"

# Label et TextBox pour le login
$labelLogin = New-Object System.Windows.Forms.Label
$labelLogin.Location = New-Object System.Drawing.Point(10,20)
$labelLogin.Size = New-Object System.Drawing.Size(80,20)
$labelLogin.Text = "Login :"
$form.Controls.Add($labelLogin)

$textBoxLogin = New-Object System.Windows.Forms.TextBox
$textBoxLogin.Location = New-Object System.Drawing.Point(100,20)
$textBoxLogin.Size = New-Object System.Drawing.Size(150,20)
$form.Controls.Add($textBoxLogin)

# Label et TextBox pour le mot de passe
$labelPass = New-Object System.Windows.Forms.Label
$labelPass.Location = New-Object System.Drawing.Point(10,50)
$labelPass.Size = New-Object System.Drawing.Size(80,20)
$labelPass.Text = "Mot de passe :"
$form.Controls.Add($labelPass)

$textBoxPass = New-Object System.Windows.Forms.TextBox
$textBoxPass.Location = New-Object System.Drawing.Point(100,50)
$textBoxPass.Size = New-Object System.Drawing.Size(150,20)
$textBoxPass.PasswordChar = "*"
$form.Controls.Add($textBoxPass)

# Bouton de validation
$buttonOK = New-Object System.Windows.Forms.Button
$buttonOK.Location = New-Object System.Drawing.Point(100,90)
$buttonOK.Size = New-Object System.Drawing.Size(75,23)
$buttonOK.Text = "OK"
$buttonOK.DialogResult = [System.Windows.Forms.DialogResult]::OK
$form.AcceptButton = $buttonOK
$form.Controls.Add($buttonOK)

# Affichage du formulaire
$result = $form.ShowDialog()

# Récupération des valeurs saisies
if ($result -eq [System.Windows.Forms.DialogResult]::OK) {
    $login = $textBoxLogin.Text
    $password = $textBoxPass.Text
    Write-Host "Login : $login"
    Write-Host "Mot de passe : $password"
}
```

**Explications :**

* Ce script crée une fenêtre avec deux champs (login et mot de passe).
* Le champ mot de passe masque les caractères saisis.
* Le bouton "OK" valide la saisie et affiche les valeurs dans la console PowerShell.

## Affichage des données

Pour afficher les données, nous avons la possibilité d'utiliser le composant `DataGridView` de `Windows.Forms`
Ci dessous le script permet de créer une fenêtre contenant un tableau modifiable, idéal pour visualiser et éditer des données.

```powershell
Add-Type -AssemblyName System.Windows.Forms

# Création du formulaire
$form = New-Object System.Windows.Forms.Form
$form.Text = "Tableau de données"
$form.Size = New-Object System.Drawing.Size(600, 400)
$form.StartPosition = "CenterScreen"

# Création du DataGridView
$dataGridView = New-Object System.Windows.Forms.DataGridView
$dataGridView.Location = New-Object System.Drawing.Point(10, 10)
$dataGridView.Size = New-Object System.Drawing.Size(560, 300)
$dataGridView.AutoSizeColumnsMode = [System.Windows.Forms.DataGridViewAutoSizeColumnsMode]::Fill
$form.Controls.Add($dataGridView)

# Exemple de données
$data = @(
    [PSCustomObject]@{ Nom = "Alice"; Âge = 30; Ville = "Paris" },
    [PSCustomObject]@{ Nom = "Bob"; Âge = 25; Ville = "Lyon" },
    [PSCustomObject]@{ Nom = "Charlie"; Âge = 35; Ville = "Marseille" }
)

# Ajout des données au DataGridView
$dataGridView.DataSource = $data

# Bouton de fermeture
$buttonClose = New-Object System.Windows.Forms.Button
$buttonClose.Location = New-Object System.Drawing.Point(250, 330)
$buttonClose.Size = New-Object System.Drawing.Size(100, 30)
$buttonClose.Text = "Fermer"
$buttonClose.DialogResult = [System.Windows.Forms.DialogResult]::Cancel
$form.CancelButton = $buttonClose
$form.Controls.Add($buttonClose)

# Affichage du formulaire
$form.ShowDialog()
```

**Explications :**

* Ce script crée une fenêtre avec un contrôle `DataGridView`.
* Les données sont définies sous forme de tableau d’objets PowerShell.
* Le tableau est automatiquement rempli et les colonnes s’adaptent à la taille de la fenêtre.
* Les données directement dans la table sont modifiables.

**Personnalisation :**

* Remplace `$data` par les données récupérés.
* Tu peux ajouter des colonnes, changer les titres, ou ajouter des boutons pour exporter les données.

## Sécurisation

Il n'est pas conseillé de stocker les identifiants en clair dans les scripts, nous pouvons soit:

* Demander les identifiants à l'utilisateur lors du lancement du script
* Récupérer les informations dans le fichier `pgpass`

### Méthode interactive

Lors de l'exécution d'un script, la fonction
[Get-Credential](https://learn.microsoft.com/fr-fr/powershell/module/microsoft.powershell.security/get-credential?view=powershell-7.5 "PowerShell Get-Credential")
permet de demander un identifiant et mot de passe à l'utilisateur.

```powershell
# Demander les identifiants à l'utilisateur
$credential = Get-Credential -Message "Veuillez entrer vos identifiants PostgreSQL"

# Paramètres de connexion
$server = "localhost"  # ou l'adresse IP/nom du serveur
$port = "5432"        # port par défaut de PostgreSQL
$database = "nom_de_ta_base"  # remplace par le nom de ta base

# Créer la chaîne de connexion
$connectionString = "Server=$server;Port=$port;Database=$database;UserId=$($credential.UserName);Password=$($credential.GetNetworkCredential().Password);"
```

### Méthode automatique

Pour la méthode automatique, il est préférable d'utiliser des solutions qui ont fait leurs preuves

PostgreSQL possèdent un fichier spécial (pgpass) qui permet de stocker les informations de connexions aux différentes serveurs bases de données

::: tip
Sous windows ce fichier est stocké dans le dossier utilisateur APPDATA sous le chemin `%APPDATA%\postgresql\pgpass.conf`

il s'agit d'un fichier dont le séparateur entre les champs est le `:` et les colonnes suivantes

* Nom hôte ou IP
* Port d'écoute
* base de données
* Nom d'utilisateur
* Mot de passe
  :::

Un exemple de fichier `pgpass.conf`

```ini [pgpass.conf]
# Première connexion
localhost:5432:postgres:demo:demo1234
```

::: warning Avertissement
Si vous lancez le script avec un autre utilisateur, il faudra que le fichier `pgpass` se trouve dans son `APPDATA`
:::

Pour l'utiliser dans vos scripts, laisser le mot de passe vide

---

---
url: /programmation/rust.md
---

# Rust et PostgreSQL

Pour utiliser [Rust](https://rust-lang.org/ "Langage Rust") avec PostgreSQL, nous avons plusieurs bibliothèques disponibles.

Pour cette article, nous allons utiliser la crate [`postgres`](https://crates.io/crates/postgres) en mode synchrone
(ou plus souvent [`tokio-postgres`](https://crates.io/crates/tokio-postgres) pour les applications asynchrones)
en Rust pour interagir avec une base de données PostgreSQL.

Je ne détaille pas ici la création d'un nouveau projet, je vous laisse regarder la commande `cargo new` que vous trouverez
dans la [documentation officielle](https://doc.rust-lang.org/cargo/getting-started/first-steps.html "cargo new")

## Configuration de base

Le premier point est de déclarer les dépendances dans le fichier `Cargo.toml`.

### Ajouter les dépendances

Dans votre `Cargo.toml`:

```toml
[dependencies]
tokio = { version = "1.0", features = ["full"] }
tokio-postgres = { version = "0.7", features = ["with-uuid-1"] }
```

::: tip Astuces
La liste des `features` activable est disponible dans la documentation.
:::

## Connexion à la base de données

ensuite dans le fichier `main.rs`

### Exemple synchrone (avec `postgres`)

```rust
use postgres::{Client, NoTls, Error};

fn main() -> Result<(), Error> {
    // Chaîne de connexion
    let conn_str = "host=localhost user=postgres dbname=mydb password=1234";
    let mut client = Client::connect(conn_str, NoTls)?;

    // Exécution d'une requête simple pour récupérer la PK et le nom de l'utilisateur
    for row in client.query("SELECT id, name FROM users", &[])? {
        let id: i32 = row.get(0);
        let name: String = row.get(1);
        println!("id: {}, name: {}", id, name);
    }

    Ok(())
}
```

::: tip Remarques
Ici les informations de connexion sont connectés en dur, vous pouvez par exemple les transmettre en variables d'environnement
et utiliser le [module standard](https://doc.rust-lang.org/std/env/index.html "std::env") `std::env`
:::

### Exemple asynchrone (avec `tokio-postgres`)

```rust
use tokio_postgres::{NoTls, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Chaîne de connexion
    let conn_str = "host=localhost user=postgres dbname=mydb password=1234";
    let (client, connection) = tokio_postgres::connect(conn_str, NoTls).await?;

    // Exécution de la connexion en arrière-plan
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Erreur de connexion: {}", e);
        }
    });

    // Exécution d'une requête simple
    let rows = client.query("SELECT id, name FROM users", &[]).await?;
    for row in rows {
        let id: i32 = row.get(0);
        let name: String = row.get(1);
        println!("id: {}, name: {}", id, name);
    }

    Ok(())
}
```

## Requêtes paramétrées

Les requêtes paramétrés sont el moyen le plus sur d'éviter les failles d'injections SQL.

### Insertion de données

```rust
let name = "Alice";
let age = 30;
client.execute(
    "INSERT INTO users (name, age) VALUES ($1, $2)",
    &[&name, &age],
).await?;
```

### Sélection avec filtre

```rust
let min_age = 25;
let rows = client.query(
    "SELECT name FROM users WHERE age > $1",
    &[&min_age],
).await?;
```

## Transactions

```rust
let transaction = client.transaction().await?;
transaction.execute("INSERT INTO users (name) VALUES ($1)", &[&"Bob"]).await?;
transaction.execute("UPDATE users SET age = $1 WHERE name = $2", &[&40, &"Bob"]).await?;
transaction.commit().await?;

// Ou utiliser transaction.rollback().await?; (ou savepoint)
```

::: tip Remarques
Pour plus d'informations concernant les transactions, vous pouvez consulter la [documentation](https://docs.rs/tokio-postgres/latest/tokio_postgres/struct.Transaction.html "Transaction PostgreSQL en Rust").
:::

## Gestion des erreurs

Il ne faut pas non plus oublier la gestion des erreurs.

```rust
match client.query_one("SELECT name FROM users WHERE id = $1", &[&1]).await {
    Ok(row) => {
        let name: String = row.get(0);
        println!("Nom: {}", name);
    }
    Err(e) => eprintln!("Erreur: {}", e),
}
```

## Utilisation de types personnalisés

Si vous utilisez des types PostgreSQL spécifiques (comme `UUID`), assurez-vous d'activer les features appropriées dans `Cargo.toml` :

```toml
tokio-postgres = { version = "0.7", features = ["with-uuid-1"] }
```

Exemple d'utilisation :

```rust
use uuid::Uuid;

let id = Uuid::new_v4();
client.execute(
    "INSERT INTO users (id, name) VALUES ($1, $2)",
    &[&id, &"Charlie"],
).await?;
```

## Pool de connexions (avec `bb8`)

Pour gérer un pool de connexions, nous allons ajouter les crates `bb8` et `bb8-postgres` à nos dépendances, ajouter ceci dans le fichier `Cargo.toml`

```toml
bb8 = "0.8"
bb8-postgres = "0.8"
```

Exemple :

```rust
use bb8_postgres::PostgresConnectionManager;
use bb8::Pool;

type PgPool = Pool<PostgresConnectionManager<NoTls>>;

#[tokio::main]
async fn main() -> Result<(), Error> {
    let manager = PostgresConnectionManager::new_from_stringlike(
        "host=localhost user=postgres dbname=mydb password=1234",
        NoTls,
    )?;
    let pool = Pool::builder().build(manager).await?;

    let conn = pool.get().await?;
    let rows = conn.query("SELECT id, name FROM users", &[]).await?;
    // ...
    Ok(())
}
```

## Exemple complet (asynchrone)

```rust
use tokio_postgres::{NoTls, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let (client, connection) = tokio_postgres::connect(
        "host=localhost user=postgres dbname=mydb password=1234",
        NoTls,
    ).await?;

    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Erreur de connexion: {}", e);
        }
    });

    // Création d'une table
    client.execute(
        "CREATE TABLE IF NOT EXISTS users (
            id SERIAL PRIMARY KEY,
            name VARCHAR NOT NULL,
            age INTEGER
        )",
        &[],
    ).await?;

    // Insertion
    client.execute(
        "INSERT INTO users (name, age) VALUES ($1, $2)",
        &[&"Alice", &30],
    ).await?;

    // Sélection
    let rows = client.query("SELECT id, name, age FROM users", &[]).await?;
    for row in rows {
        let id: i32 = row.get(0);
        let name: String = row.get(1);
        let age: i32 = row.get(2);
        println!("id: {}, name: {}, age: {}", id, name, age);
    }

    Ok(())
}
```

## Correspondance

Ci dessous vous trouverez un tableau de correspondance des types entre PostgreSQL et Rust (avec les crates `postgres`/`tokio-postgres`)

::: warning
Si vous utiliser d'autres bibliothèques, il se peut que certains type puisse différé légèrement
:::

| Type PostgreSQL       | Type Rust (crate `postgres`/`tokio-postgres`) | Remarques                                                                 |
|:---------------------:|:---------------------------------------------:|---------------------------------------------------------------------------|
| `SMALLINT`            | `i16`                                         | Entier 16 bits                                                            |
| `INTEGER`             | `i32`                                         | Entier 32 bits                                                            |
| `BIGINT`              | `i64`                                         | Entier 64 bits                                                            |
| `SERIAL`              | `i32`                                         | Auto-incrément (entier 32 bits)                                           |
| `BIGSERIAL`           | `i64`                                         | Auto-incrément (entier 64 bits)                                           |
| `REAL`                | `f32`                                         | Nombre à virgule flottante 32 bits                                        |
| `DOUBLE PRECISION`    | `f64`                                         | Nombre à virgule flottante 64 bits                                        |
| `NUMERIC`             | `rust_decimal::Decimal`                       | Requiert la crate `rust_decimal` pour une précision arbitraire            |
| `BOOLEAN`             | `bool`                                        | Vrai/Faux                                                                 |
| `CHAR(N)`/`VARCHAR(N)`| `String`                                      | Chaîne de caractères                                                      |
| `TEXT`                | `String`                                      | Chaîne de caractères de taille illimitée                                  |
| `BYTEA`               | `Vec<u8>`                                     | Tableau d'octets                                                          |
| `DATE`                | `chrono::NaiveDate`                           | Requiert la crate `chrono`                                                |
| `TIME`                | `chrono::NaiveTime`                           | Requiert la crate `chrono`                                                |
| `TIMESTAMP`           | `chrono::NaiveDateTime`                       | Requiert la crate `chrono`                                                |
| `TIMESTAMPTZ`         | `chrono::DateTime<Utc>`                       | Requiert la crate `chrono`                                                |
| `INTERVAL`            | `postgres_types::Interval`                    | Type spécifique à PostgreSQL                                              |
| `UUID`                | `uuid::Uuid`                                  | Requiert la feature `with-uuid-1` et la crate `uuid`                      |
| `JSON`/`JSONB`        | `serde_json::Value`                           | Requiert la feature `with-serde_json-1` et la crate `serde_json`          |
| `ARRAY`               | `Vec<T>`                                      | Où `T` est le type des éléments du tableau                                |
| `INET`/`CIDR`         | `std::net::IpAddr`/`std::net::IpNet`          | Pour les adresses IP et réseaux                                           |
| `POINT`               | `(f64, f64)` ou structure personnalisée       | Coordonnées géométriques                                                  |
| `ENUM`                | `String` ou enum Rust                         | Nécessite une conversion manuelle                                         |

***

### Remarques importantes :

* **Types temporels** : La crate `chrono` est couramment utilisée pour manipuler les dates et heures.
* **Types décimaux** : Pour `NUMERIC`, utilisez `rust_decimal::Decimal` pour éviter les problèmes de précision.
* **UUID** : Activez la feature `with-uuid-1` dans `tokio-postgres` pour supporter les UUID.
* **JSON** : Activez la feature `with-serde_json-1` pour manipuler les types JSON/JSONB.
* **Types géométriques** : Les types comme `POINT` peuvent être mappés à des tuples ou des structures Rust.

## Points clés à retenir

* **Sécurité** : Utiliser le plus fréquement possible des requêtes paramétrées pour éviter les injections SQL.
* **Asynchrone** : Préférez `tokio-postgres` pour les applications asynchrones.
* **Pool de connexions** : Utilisez `bb8` pour gérer efficacement les connexions en production.
* **Types personnalisés** : Activez les features nécessaires pour les types comme `UUID`.

---

---
url: /cookbook.md
description: Liste de recette PostgreSQL
---

# Cookbook

Cette partie regroupe des recettes

* [Modelisation](./modelisation.md "Modelisation")
* [psql](./psql.md "Teminal en ligne de commande psql")

---

---
url: /cookbook/modelisation.md
description: Livre de recettes sur la modélisation sous POstgreSQL
---

# Modélisation

Lors de la modélisation

## Clé primaire int ou bigint

Lors de la création d'un table, il est préférable d'utiliser un entier en tant que clé primaire.

::: info
Vous pouvez utiliser d'autres types comme UUID par exemple, et en particulier UUIDv7 qui est apparu dans PostgreSQL 18.
:::

PostgreSQL possède 3 types d'entier :

* `smallint`: 2 octets soit de **-32 768** to **+32 767**
* `integer`: 4 octets soit **-2 147 483 648** to **+2 147 483 647**
* `bigint`: 8 octets soit **-9 223 372 036 854 775 808** to **+9 223 372 036 854 775 807**

::: tip Remarques
les types `smallint`, `integer`, `bigint` sous PostgreSQL n'existe qu'en version signé.

il n'est donc pas possible d'utiliser une version non signé pour doubler la valeur à stocker.
:::

## Longueur champ Email

Lorsque l'on veut stocker le champ email (courriel pour les français), on se pose toujours la question de la longueur maximale du champ.

La réponse se trouve dans la [RFC 3696 Section 3](https://datatracker.ietf.org/doc/html/rfc3696#section-3 "RFC3996 Section 3")

> That limit is a maximum of 64 characters (octets) in the "local part" (before the "@")
> and a maximum of 255 characters (octets) in the domain part (after the "@")
> for a total length of 320 characters.

Donc un champ email est composé comme suit:

* partie local (avant le @) est composée de 64 caractères au maximum
* le caractère @ qui compte pour 1 caractère
* partie domaine (après le @) est composée de 255 caractères au maximum

Ce qui nous donne une longueur de 64 + 1 + 255 soit 320 caractères.

Ci-dessous un exemple d'utilisation lors de la création d'une table.

```sql
CREATE TABLE utilisateurs (
    id SERIAL PRIMARY KEY,
    nom VARCHAR,
    email VARCHAR(320) UNIQUE,
    passwd VARCHAR
);
```

::: tip Remarques
Lors de la création de la table sur l'exemple ci-dessus, j'ai par exemple utilisé pour les champs `nom` et `passwd`
un `VARCHAR` sans indiqué de longueur, si vous souhaitez en savoir plus sur le pourquoi du comment,
je vous invite a lire la partie [Don't do this](https://wiki.postgresql.org/wiki/Don%27t_Do_This#Don't_use_varchar\(n\)_by_default "Wiki PostgreSQL don't do this")
du wiki de PostgreSQL.
:::

---

---
url: /cookbook/psql.md
description: Livre de recette sur l'utilisation de psql le client PostgreSQL
---

# psql

Petit rappel de ce qu'est psql

::: info
psql est une interface en mode texte pour PostgreSQL. Il vous permet de saisir des requêtes de façon interactive,
de les exécuter sur PostgreSQL et de voir les résultats de ces requêtes.

Alternativement, les entrées peuvent être lues à partir d'un fichier ou à partir des arguments de la ligne de commande.

De plus, il fournit un certain nombre de métacommandes et plusieurs fonctionnalités style shell pour faciliter l'écriture des scripts
et automatiser une grande variété de tâches.
:::

## Pagination

Que vous utilisiez `psql` quotidiennement, ou seulement quand c'est votre dernier espoir de pouvoir vous connecter à votre base de données,
il peut être utile de définir un `pager` surtout si votre requête retourne beaucoup de colonnes.

Vous pouvez utiliser `more` ou `less`, mais le rendu des colonnes est illisible, pour cela un nouvel outil a été développé.

Le développeur [Pavel Stehule](https://github.com/okbob "Pavel Stehule Github profile") nous as écrit [pspg](https://github.com/okbob/pspg "PostgreSQL Pager")
pour résoudre cette problématique.

### Installation

`pspg` est deja packagé pour les distributions les plus utilisés, vous pouvez utiliser vos gestionnaires de paquet pour procéder à l'installation

```shell
# Debian (Ubuntu)
sudo apt-get install pspg

# RedHat (Fedora)
sudo dnf install pspg
```

Ensuite avant de lancer `psql` il suffira d'indiquer quel pager vous souhaitez utiliser

```shell
export PSQL_PAGER='pspg'
```

ou dans votre fichier `~/psqlrc`

```text
\setenv PAGER pspg
\pset border 2
\pset format aligned
```

Ensuite lancer `psql` et écriver une requêtes SQL que vous aller executer.

### Navigation de base

| Commande | Description |
|:-:| - |
| **Flèches haut/bas** | Déplacer le curseur ligne par ligne |
| **Page Up / Page Down** | Déplacer d’une page à la fois |
| **Home / End** | Aller au début/à la fin du résultat |
| **g** | Aller à la première ligne |
| **G** | Aller à la dernière ligne |

### Recherche et filtrage

| Commande | Description |
|:-:| - |
| **/** | Rechercher vers l’avant |
| **?** | Rechercher vers l’arrière |
| **n** | Aller à l’occurrence suivante |
| **N** | Aller à l’occurrence précédente |
| \**\** | Filtrer les lignes (ex: `\d+` pour afficher seulement les lignes contenant "d") |

### Affichage et formatage

| Commande | Description |
|:-:| - |
| **w** | Basculer l’affichage en mode large (sans retour à la ligne) |
| **e** | Exporter les résultats vers un fichier |
| **s** | Changer l’ordre de tri des colonnes |
| **o** | Changer l’ordre des colonnes |
| **c** | Changer la couleur du thème |

### Autres commandes utiles

| Commande | Description |
|:-:| - |
| **q** | Quitter pspg |
| **h** | Afficher l’aide |
| **!** | Exécuter une commande shell |
| **Ctrl+L** | Rafraîchir l’écran |

---

---
url: /programmation/plpgsql/date.md
---

[Rubrique déplacée](../plpgsql-date.md)

---

---
url: /articles/plangages.md
description: Listes des langages procéduraux utilisables avec la base de données PostgreSQL
---

# Langages de procédures

## Introduction

Les langages de procédures permettent d’écrire des fonctions, des déclencheurs (triggers) et des procédures stockées directement dans la base de données.

Actuellement, la distribution standard de PostgreSQL inclut quatre langages de procédures par défaut :

* [PL/pgSQL](https://docs.postgresql.fr/18/plpgsql.html "PL/pgSQL -- Langage de procédures SQL"),
* [PL/Tcl](https://docs.postgresql.fr/18/pltcl.html "PL/Tcl -- Langage de procédures Tcl"),
* [PL/Perl](https://docs.postgresql.fr/18/plperl.html "PL/Perl -- Langage de procédures Perl"),
* [PL/Python](https://docs.postgresql.fr/18/plpython.html "PL/Python -- Langage de procédures Python").

## PL/pgSQL

### Résumé

Langage procédural natif de PostgreSQL, inspiré de PL/SQL (Oracle). Il est le plus utilisé pour écrire des fonctions et des déclencheurs. PL/pgSQL permet de manipuler des données, de gérer des erreurs, et d’utiliser des structures de contrôle (boucles, conditions, etc.).

### Avantages

* Intégration parfaite avec PostgreSQL.
* Performant et optimisé.
* Support complet des fonctionnalités de PostgreSQL.

### Cas d’usage

* Logique métier complexe dans la base de données.
* Déclencheurs (triggers).
* Fonctions personnalisées.

## PL/Tcl

### Résumé

Permet d’utiliser le langage [Tcl](https://www.tcl-lang.org/ "Site web du langage TCL") (Tool Command Language) pour écrire des fonctions et des déclencheurs. Tcl est un langage de script dynamique, souvent utilisé pour des tâches d’automatisation ou de prototypage.

### Avantages

* Flexibilité et simplicité de TCL.
* Accès aux bibliothèques TCL.

### Cas d’usage

* Scripts d’automatisation.
* Traitements nécessitant des expressions régulières ou des manipulations de chaînes avancées.

## PL/Perl

### Résumé

Permet d’écrire des fonctions et des déclencheurs en [Perl](https://www.perl.org/ "Langage Perl"), un langage puissant pour le traitement de texte et les expressions régulières.

### Avantages

* Puissance de Perl pour le traitement de texte.
* Accès aux modules Perl (si autorisé).

### Cas d’usage

* Traitement de données textuelles complexes.
* Parsing et transformation de données.

## PL/Python

### Résumé

Permet d’utiliser [Python](https://www.python.org/ "Langage Python") pour écrire des fonctions et des déclencheurs. Python est un langage populaire pour sa lisibilité et sa richesse en bibliothèques.

### Avantages

* Lisibilité et simplicité de Python.
* Accès à des bibliothèques Python (si autorisé).

### Cas d’usage

* Traitements analytiques ou scientifiques.
* Intégration avec des outils externes en Python.

## PL/Lua

### Résumé

**PL/Lua** est une extension procédurale pour PostgreSQL qui permet d’écrire des **fonctions, procédures et déclencheurs (triggers) directement** en [Lua](https://www.lua.org/ "Langage Lua"). Lua est un langage de script léger, rapide et facile à intégrer, connu pour sa simplicité et sa petite empreinte mémoire.

### Avantages principaux

* **Simplicité et légèreté**: Lua est conçu pour être petit, rapide et facile à embarquer, ce qui en fait un bon choix pour des traitements légers et rapides dans la base de données.
* **Syntaxe claire**: Lua offre une syntaxe minimaliste et intuitive, avec des fonctions de première classe, une portée lexicale et des coroutines pour une gestion avancée du flux d’exécution.
* **Intégration native avec PostgreSQL**: PL/Lua permet d’accéder directement aux types de données PostgreSQL (TEXT, INT, NUMERIC, etc.) sans conversion forcée en chaîne de caractères, et supporte l’interface SPI (Server Programming Interface) pour exécuter des requêtes SQL depuis Lua.
* **Deux modes d’exécution**:
  * **pllua** (mode "trusted" ou sécurisé) : environnement restreint, idéal pour une utilisation sécurisée.
  * **plluau** (mode "untrusted" ou non sécurisé) : accès complet à l’environnement Lua, y compris le chargement de modules et l’accès à la table globale.

### Cas d’usage

* **Traitements légers et rapides**: Scripts simples, transformations de données, logiques métiers légères.
* **Utilisation de coroutines**: Pour gérer des flux d’exécution complexes ou asynchrones.
* **Prototypage rapide**: Grâce à la simplicité de Lua, idéal pour des tests ou des développements rapides.
* **Déclencheurs (triggers)**: Logique personnalisée déclenchée par des événements sur les tables.

## PL/Java

### Résumé

Permet d’écrire des fonctions et des déclencheurs en **Java**, offrant une intégration avec l’écosystème Java.

### Avantages

* Accès aux bibliothèques Java.
* Portabilité et performance.

### Cas d’usage

* Applications nécessitant une intégration avec des systèmes Java.
* Traitements lourds ou parallélisés.

## PL/R

### Résumé

Permet d’utiliser le langage [R](https://www.r-project.org/ "Langage R") pour écrire des fonctions et des déclencheurs, idéal pour l’analyse statistique et la visualisation de données.

### Avantages

* Puissance de R pour l’analyse statistique.
* Intégration avec des outils de data science.

### Cas d’usage

* Analyses statistiques avancées.
* Modélisation et visualisation de données.

## PL/V8 (JavaScript)

### Résumé

Permet d’écrire des fonctions et des déclencheurs en **JavaScript**, en utilisant le moteur V8 de Google.

### Avantages

* Familiarité de JavaScript pour les développeurs web.
* Accès à des fonctionnalités dynamiques.

### Cas d’usage

* Traitements nécessitant des logiques dynamiques ou asynchrones.
* Intégration avec des applications web.

## PL/LOLCODE

### Résumé

Langage procédural humoristique basé sur le [LOLCODE](http://www.lolcode.org/ "Langage LOLCODE"), un langage de programmation esoteric. Peu utilisé en production, mais disponible pour des démonstrations ou des projets ludiques.

### Avantages

* Originalité et aspect ludique.

### Cas d’usage

* Projets expérimentaux ou éducatifs.

## PL/Rust

### Résumé

**PL/Rust** est une extension procédurale pour PostgreSQL qui permet d’écrire des **fonctions, procédures et déclencheurs directement** en [Rust](https://rust-lang.org/fr/ "Langage Rust").

::: warning
Contrairement à la plupart des autres langages procéduraux (comme PL/pgSQL, PL/Python, etc.), les fonctions PL/Rust ne sont pas interprétées.

Elles sont **compilées en code machine natif**, ce qui offre des performances comparables à celles du C, tout en bénéficiant des **garanties de sécurité mémoire de Rust** (pas de fuites mémoire, pas de corruption de mémoire, etc.).
:::

### Avantages

* **Performance** : Les fonctions sont compilées en code natif, ce qui permet d’atteindre des performances optimales, proches de celles du C.
* **Sécurité** : Rust garantit la sécurité mémoire à la compilation, réduisant les risques de plantage ou de corruption de la base de données. PL/Rust est considéré comme un langage "trusted" (de confiance) sur les architectures x86\_64 et aarch64, sous certaines conditions.
* **Accès à l’écosystème Rust** : Possibilité d’utiliser des bibliothèques (crates) Rust, sous réserve de compatibilité avec l’environnement PostgreSQL.
* **Intégration avec PostgreSQL** : Accès complet à l’interface de programmation serveur (SPI) de PostgreSQL, permettant d’exécuter des requêtes dynamiques, des requêtes préparées et des curseurs.

### Cas d’usage

* **Fonctions critiques en termes de performance** : Calculs intensifs, traitements de données complexes, où la vitesse d’exécution est cruciale.
* **Sécurité renforcée** : Environnements où la sécurité mémoire est une priorité (ex. : bases de données exposées à des utilisateurs non privilégiés).
* **Intégration avec des outils Rust** : Réutilisation de code Rust existant ou utilisation de bibliothèques Rust pour des traitements spécifiques.

## PL/Proxy

### Résumé

Permet de créer des fonctions qui appellent des procédures distantes, utile pour la répartition de charge ou l’appels de fonctions sur d’autres serveurs.

### Avantages

* Appels de procédures distantes.
* Partitionnement de données.

### Cas d’usage

* Architectures distribuées.
* Appels de fonctions sur des bases de données distantes.

## SQL (Langage de requête standard)

### Résumé

Bien que ce ne soit pas un langage procédural à part entière, PostgreSQL permet d’écrire des fonctions en **SQL pur**. Ces fonctions sont limitées aux requêtes SQL et ne supportent pas les structures de contrôle avancées.

### Avantages

* Simplicité pour des requêtes basiques.
* Portabilité.

### Cas d’usage

* Fonctions simples de requêtage.
* Agrégations ou calculs basiques.

## Comment activer un langage procédural ?

Pour utiliser un langage procédural, il faut d’abord l’activer dans la base de données avec la commande :

```sql
CREATE EXTENSION IF NOT EXISTS pl<langage>;
```

Exemple pour PL/pgSQL :

```sql
CREATE EXTENSION IF NOT EXISTS plpgsql;
```

## **Quel langage choisir ?**

* **PL/pgSQL**: Pour la plupart des cas, surtout si vous restez dans l’écosystème PostgreSQL.
* **PL/Python** ou **PL/Perl**: Pour des traitements textuels ou analytiques avancés.
* **PL/Java** ou **PL/R**: Pour des intégrations spécifiques avec Java ou R.
* **PL/V8**: Pour des développeurs familiers avec JavaScript.
* **PL/Rust**: Pour des besoins de performances maximales et de sécurité mémoire dans vos fonctions PostgreSQL.

---

---
url: /articles/generalite.md
description: >-
  Explication des clés primaires, clé étrangères, et contrainte unique dans
  PostgreSQL
---

# Généralité

## Base de données Relationnelle

PostgreSQL est une base de données relationnelle, mais qu'est ce que cela veut dire concrètement ?

### Définition et Concepts Clés

#### Qu’est-ce qu’une base de données relationnelle ?

Une **base de données relationnelle** organise les données en **tables** (ou relations), composées de **lignes** (tuples) et de **colonnes** (attributs).

Les relations entre les tables sont établies via des **clés** (primaires, étrangères).

**Exemple :**

* Table `Clients` (id\_client, nom, email)
* Table `Commandes` (id\_commande, id\_client, date, montant)

#### Modèle Relationnel

* **Théorie** : Proposé par Edgar F. Codd en 1970.
* **Objectifs** : Éviter la redondance, garantir l’intégrité des données, et permettre des requêtes complexes.

### Principes Fondamentaux

#### ACID

Les SGBDR respectent les propriétés **ACID**:

* **Atomicité** : Une transaction est soit entièrement exécutée, soit pas du tout.
* **Cohérence** : Les données respectent les contraintes définies (ex : clés étrangères).
* **Isolation** : Les transactions concurrentes ne s’interfèrent pas.
* **Durabilité** : Les données validées persistent même en cas de panne.

#### Langage SQL

* **SQL** (Structured Query Language) est le langage standard pour interagir avec les bases relationnelles.
* **PostgreSQL** étend SQL avec des fonctionnalités avancées (JSON, requêtes récursives, etc.).

### PostgreSQL : Spécificités et Avantages

#### Pourquoi PostgreSQL ?

* **Open Source** : Gratuit et communauté active.
* **Extensible** : Support des types de données personnalisés, extensions (ex : PostGIS pour la géolocalisation).
* **Robuste** : Gestion avancée des transactions, réplication, et haute disponibilité.
* **Standard** : Très conforme à la norme SQL.

#### Fonctionnalités Clés

* **Types de données** : Texte, numérique, date/heure, JSON, réseaux (inet), géométrique, etc.
* **Index** : B-tree, Hash, GiST, GIN, BRIN pour optimiser les requêtes.
* **Partitionnement** : Améliore les performances sur de gros volumes de données.
* **Sécurité** : RBAC (rôles et permissions), chiffrement, audit.

## Clé primaire (Primary key)

### Définition

Une **clé primaire** est une colonne (ou un ensemble de colonnes) qui identifie de manière unique chaque ligne d'une table.

Elle garantit que chaque valeur est unique et non nulle.

### Caractéristiques principales

* **Unicité** : Aucune valeur dupliquée n'est autorisée.
* **Non-nullité** : La clé primaire ne peut pas contenir de valeurs NULL.
* **Une seule par table** : Une table ne peut avoir qu'une seule clé primaire (mais celle-ci peut être composée de plusieurs colonnes).

### Utilisations courantes

* **Identification unique** : Permet de distinguer chaque ligne de manière unique.
* **Relations entre tables** : Utilisée comme référence pour les clés étrangères (foreign keys) dans d'autres tables.
* **Optimisation des requêtes** : Accélère les recherches, les jointures et les tris.
* **Intégrité des données** : Empêche les doublons et les valeurs nulles, assurant la cohérence des données.

### Types de clés primaires

* **Clé primaire simple** : Une seule colonne (ex: `id` de type SERIAL ou INTEGER).
* **Clé primaire composite** : Plusieurs colonnes combinées (ex: `pays` + `code_postal`).

### Syntaxe de création

* **Lors de la création de la table** :
  ```sql
  CREATE TABLE utilisateurs (
      id SERIAL PRIMARY KEY,
      nom VARCHAR(100),
      email VARCHAR(100) UNIQUE
  );
  ```
* **Ajout après la création de la table** :
  ```sql
  ALTER TABLE utilisateurs ADD PRIMARY KEY (id);
  ```

::: info remarques
le type `SERIAL` est composé d'un type integer et d'un séquence.

si l'on sait utiliser un `bigint` il faut utiliser `BIGSERIAL`
:::

### Bonnes pratiques

* Utiliser des colonnes de type `SERIAL` ou `BIGSERIAL` pour les clés primaires auto-incrémentées.
* Les [colonnes identités](https://docs.postgresql.fr/18/ddl-identity-columns.html "Colonne identité") peuvent être utilisées comme clé primaire
* Avec PostgreSQL 18, il est possible d'utiliser `UUID7` comme [clé primaire](https://docs.postgresql.fr/18/functions-uuid.html "UUID7")
* Éviter d'utiliser des données sensibles ou sujettes à modification comme clé primaire.
* Privilégier des clés primaires courtes et simples pour optimiser les performances.

### Exemple concret

```sql
-- Table avec une clé primaire simple
CREATE TABLE clients (
    client_id SERIAL PRIMARY KEY,
    nom VARCHAR(100),
    email VARCHAR(100) UNIQUE
);

-- Table avec une clé primaire composite
CREATE TABLE commandes (
    client_id INTEGER,
    numero_commande INTEGER,
    date_commande DATE,
    PRIMARY KEY (client_id, numero_commande),
    FOREIGN KEY (client_id) REFERENCES clients(client_id)
);
```

En utilisant un colonne identité:

```sql
CREATE TABLE clients (
    client_id INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    nom VARCHAR(100),
    email VARCHAR(100) UNIQUE
);
```

## Clé étrangère (Foreign Key)

Après les clés primaires, les clés étrangères sont l'autre élement essentiel d'une base de données relationnelle.

### Définition

Une **clé étrangère** est une colonne (ou un ensemble de colonnes) qui établit un lien entre les données de deux tables.

Elle fait référence à une clé primaire (ou unique) d'une autre table, assurant ainsi **l'intégrité référentielle** entre les tables.

### Caractéristiques principales

* **Intégrité référentielle** : Garantit que la valeur de la clé étrangère correspond à une valeur existante dans la table référencée.
* **Non-unicité** : Contrairement à une clé primaire, une clé étrangère peut contenir des doublons et des valeurs NULL (sauf si spécifié autrement).
* **Relations entre tables** : Permet de créer des associations entre les tables (un-à-plusieurs, plusieurs-à-plusieurs, etc.).

### Utilisations courantes

* **Lier des tables** : Établir des relations logiques entre les données de différentes tables.
* **Assurer la cohérence** : Empêcher les suppressions ou modifications qui violeraient l'intégrité des données.
* **Simplifier les jointures** : Faciliter les requêtes SQL utilisant des jointures (`JOIN`).
* **Modéliser des hiérarchies** : Représenter des structures complexes (ex: catégories et sous-catégories).

### Syntaxe de création

* **Lors de la création de la table** :
  ```sql
  CREATE TABLE commandes (
      commande_id SERIAL PRIMARY KEY,
      client_id INTEGER,
      date_commande DATE,
      FOREIGN KEY (client_id) REFERENCES clients(client_id)
  );
  ```
* **Ajout après la création de la table** :
  ```sql
  ALTER TABLE commandes ADD FOREIGN KEY (client_id) REFERENCES clients(client_id);
  ```

### Comportements en cas de suppression/mise à jour

* **`ON DELETE CASCADE`** : Supprime automatiquement les lignes dépendantes.
* **`ON DELETE SET NULL`** : Définit la clé étrangère à NULL si la ligne référencée est supprimée.
* **`ON DELETE RESTRICT`** (par défaut) : Empêche la suppression si des lignes dépendantes existent.

::: tip remarques
Il existe aussi le comportement sur le `ON UPDATE` qui permet de définir le comportement lors d'un `UPDATE` sur la primary key en lien avec la Foreign Key concernée.
:::

### Exemple concret

```sql
-- Table référencée (clé primaire)
CREATE TABLE clients (
    client_id SERIAL PRIMARY KEY,
    nom VARCHAR(100)
);

-- Table avec clé étrangère
CREATE TABLE commandes (
    commande_id SERIAL PRIMARY KEY,
    client_id INTEGER,
    date_commande DATE,
    FOREIGN KEY (client_id) REFERENCES clients(client_id) ON DELETE CASCADE
);
```

### Bonnes pratiques

* **Nommage clair** : Utiliser des noms de colonnes explicites pour les clés étrangères (ex: `client_id` plutôt que `id_client`).
* **Indexation** : Créer un index sur les colonnes de clé étrangère pour améliorer les performances des jointures.
* **Gestion des contraintes** : Choisir le comportement (`CASCADE`, `SET NULL`, etc.) en fonction des besoins métiers.

## Contrainte unique

### Définition

Une **contrainte UNIQUE** garantit que toutes les valeurs d'une colonne (ou d'un groupe de colonnes) sont distinctes dans une table.

Elle empêche les doublons, mais autorise les valeurs NULL (sauf si la colonne est aussi marquée `NOT NULL`).

### Caractéristiques principales

* **Unicité** : Aucune valeur dupliquée n'est autorisée (sauf NULL).
* **Applicable à une ou plusieurs colonnes** : Peut être définie sur une seule colonne ou sur un groupe de colonnes.
* **Différence avec une clé primaire** : Une table peut avoir plusieurs contraintes UNIQUE, mais une seule clé primaire.

### Utilisations courantes

* **Éviter les doublons** : Par exemple, pour des adresses e-mail, des numéros de téléphone ou des identifiants utilisateur.
* **Garantir l'intégrité des données** : Assurer que certaines valeurs restent uniques dans la base de données.
* **Améliorer les performances** : Les colonnes avec une contrainte UNIQUE sont souvent indexées automatiquement, ce qui accélère les recherches.

### Syntaxe de création

* **Lors de la création de la table** :
  ```sql
  CREATE TABLE utilisateurs (
      id SERIAL PRIMARY KEY,
      email VARCHAR(100) UNIQUE,  -- Contrainte UNIQUE sur une colonne
      nom_utilisateur VARCHAR(50)
  );
  ```
* **Sur un groupe de colonnes** :
  ```sql
  CREATE TABLE inscriptions (
      id SERIAL PRIMARY KEY,
      utilisateur_id INTEGER,
      evenement_id INTEGER,
      UNIQUE (utilisateur_id, evenement_id)  -- Contrainte UNIQUE sur plusieurs colonnes
  );
  ```
* **Ajout après la création de la table** :
  ```sql
  ALTER TABLE utilisateurs ADD UNIQUE (email);
  ```

### Exemple concret

```sql
-- Table avec une contrainte UNIQUE sur une colonne
CREATE TABLE clients (
    client_id SERIAL PRIMARY KEY,
    email VARCHAR(100) UNIQUE,
    telephone VARCHAR(20)
);

-- Table avec une contrainte UNIQUE sur plusieurs colonnes
CREATE TABLE reservations (
    reservation_id SERIAL PRIMARY KEY,
    client_id INTEGER,
    chambre_id INTEGER,
    date_debut DATE,
    date_fin DATE,
    UNIQUE (chambre_id, date_debut, date_fin)  -- Empêche les réservations en double pour la même chambre aux mêmes dates
);
```

::: warning
Ceci est un exemple très simpliste, qui ne tient pas compte des chevauchements de dates, si vous souhaitez traiter les chevauchements,
il faudra utiliser l'opérateur [OVERLAPS](https://docs.postgresql.fr/18/functions-datetime.html#FUNCTIONS-DATETIME "Opérateur OVERLAPS")
:::

### Bonnes pratiques

* **Utiliser des noms explicites** : Pour les contraintes UNIQUE, surtout si elles sont définies sur plusieurs colonnes.
* **Éviter les contraintes redondantes** : Si une colonne est déjà une clé primaire, elle est implicitement UNIQUE.
* **Indexation automatique** : PostgreSQL crée automatiquement un index pour chaque contrainte UNIQUE, ce qui améliore les performances des requêtes.

## Articles divers

* [Les processus de PostgreSQL](http://www.dalibo.org/glmf112_les_processus_de_postgresql)
* [PostgreSQL et ses journaux de transactions](https://public.dalibo.com/archives/publications/glmf108_postgresql_et_ses_journaux_de_transactions.pdf)
* [Utilisation de Psql](http://laetitia-avrot.blogspot.fr/2011/04/psql.html)

---

---
url: /extensions.md
description: Diverses exetnsions pour PostgreSQL
---

# Extensions

## Apache AGE

Apache AGE® est une extension PostgreSQL qui fournit des fonctionnalités
de base de données graphiques.

L'objectif d'Apache AGE® est de fournir des capacités de traitement et
d'analyse de données graphiques à toutes les bases de données relationnelles.

Grâce à Apache AGE, les utilisateurs de PostgreSQL auront accès à la
modélisation de requêtes graphiques au sein de la base de données
relationnelle existante.

Les utilisateurs peuvent lire et écrire des données graphiques dans les
nœuds et les arêtes. Ils peuvent également utiliser divers algorithmes
tels que la longueur variable et la traversée des bords lors de l'analyse des données.

Lien vers [Apache AGE](https://age.apache.org/)

## Citus

Citus est une extension PostgreSQL qui transforme Postgres en une base
de données distribuée afin que vous puissiez atteindre des performances
élevées à n'importe quelle échelle.

Avec Citus, vous étendez votre base de données PostgreSQL avec de
nouveaux super pouvoirs :

* **Les tables distribuées** sont réparties sur un cluster de nœuds
  PostgreSQL pour combiner leur capacité CPU, mémoire, stockage et E/S.
* **Les tables de références** sont répliquées sur tous les nœuds pour
  les jointures et les clés étrangères des tables distribuées et des
  performances de lecture maximales.
* **Le moteur de requête** distribué achemine et parallélise SELECT, DML
  et d'autres opérations sur les tables distribuées à travers le
  cluster.
* **Le stockage en colonnes** compresse les données, accélère les
  analyses et prend en charge des projections rapides, à la fois sur des
  tables régulières et distribuées.
* **Les requêtes** à partir de n'importe quel nœud vous permettent
  d'utiliser toute la capacité de votre cluster pour les requêtes
  distribuées

Lien vers [Citus](https://github.com/citusdata/citus)

## PLpgSQL Checker

::: index
PLpgSQL Checker, PLpgSQL
:::

Cette extension est un linter complet pour plpgsql pour PostgreSQL.

Il exploite uniquement l'analyseur/évaluateur interne de PostgreSQL
afin que vous voyiez exactement les erreurs qui se produiraient au
moment de l'exécution. De plus, il analyse le SQL à l'intérieur de vos
routines et trouve des erreurs que l'on ne trouve généralement pas lors
de la commande **CREATE PROCEDURE/FUNCTION**.

Vous pouvez contrôler les niveaux de nombreux avertissements et astuces.

Enfin, vous pouvez ajouter des marqueurs de type PRAGAMA pour
activer/désactiver de nombreux aspects vous permettant de masquer les
messages que vous connaissez déjà, ou pour vous rappeler de revenir pour
un nettoyage plus approfondi plus tard.

Lien vers [PLpgSQL Checker](https://github.com/okbob/plpgsql_check/)

## Orafce

Ce module contient quelques fonctions utiles qui peuvent aider au
portage de l'application Oracle vers PostgreSQL ou qui peuvent être
généralement utiles.

Les fonctions de date Oracle intégrées ont été testées par rapport à
Oracle 10 pour vérifier leur conformité.

Les plages de dates de 1960 à 2070 fonctionnent correctement. Les dates
antérieures au 01/03/1100 ne peuvent pas être vérifiées en raison d'un
bug dans Oracle.

Toutes les fonctions sont entièrement compatibles avec Oracle et
respectent toutes les chaînes de format connues.

Des descriptions détaillées peuvent être trouvées sur Internet. Utilisez
des mots-clés tels que: oracle round trunc date iyyy.

Lien vers [Orafce](https://github.com/orafce/orafce)

## PostgreSQL semantic versioning extension

**pg\_text\_semver** est une extension Postgres qui implémente la
spécification Semantic Versioning 2.0.0, ce qui distingue cette
extension, c'est qu'elle offre un simple DOMAIN semver basé sur le
type de texte intégré de Postgres.

Lien vers [pg\_text\_semver](https://github.com/bigsmoke/pg_text_semver)

## pgTAP

pgTAP est un framework de tests unitaires pour PostgreSQL écrit en PL/pgSQL et PL/SQL.
il repose sur le protocole [TAP](https://testanything.org/)

Il comprend une collection complète de fonctions d'assertion émettant
des TAP, ainsi que la possibilité de s'intégrer à d'autres frameworks
de tests émettant des TAP.

Il peut également être utilisé dans le style de test xUnit

Lien vers [pgTAP](https://pgtap.org/)

---

---
url: /services/hebergeurs.md
description: Liste d'hébergeur proposant la solution PostgreSQL
---

# Hebergeurs PostgreSQL {#hosting}

Liste des sociétés offrant des hébergements pour PostgreSQL, pour des
sites web ou des applicatifs metiers

## OVH

[OVH](https://www.ovhcloud.com/fr/public-cloud/postgresql/) propose
PostgreSQL à son catalogue.

Accélérez votre activité en déployant un cluster managé PostgreSQL en
quelques clics. Bénéficiez d'un moteur de bases de données
relationnelles open-source capable de gérer de lourdes charges de
travail. Concentrez-vous ainsi sur le développement de vos
fonctionnalités applicatives, nous nous chargeons de la gestion du
service : configuration, maintenance, backup, haute disponibilité et
mises à jour.

## IONOS

[IONOS (ex 1&1)](https://cloud.ionos.fr/managed/dbaas/postgresql) vous
propose des bases de données puissantes et évolutives

Créez facilement vos propres bases de données PostgreSQL personnalisées
et confiez-nous la gestion des bases de données pour vos applications et
charges de travail complexes.

## Clever Cloud

[Clever Cloud](https://www.clever-cloud.com/postgresql-hosting) vous
propose un service PostgreSQL entièrement managé avec des outils de
supervision, de sauvegarde et de migration.

## Scalingo

[Scalingo](https://scalingo.com/fr/databases/postgresql) vous propose un
hébergement PostgreSQL managée

Provisionnez une base PostgreSQL en moins de temps qu'il n'en faut
pour chercher un café. Complètement administré, hautement disponible &
prêt pour la production.

## Kinsta

[Kinsta](https://kinsta.com/fr/hebergement-bases-de-donnees/postgresql/)
vosu propose un hébergement PostgreSQL facile et puissant

Rejoignez plus de 55.000 développeurs et entrepreneurs sur le PaaS de
Kinsta. Notre hébergement PostgreSQL vous permet de vous concentrer sur
d'autres tâches.

## Gandi

[Gandi](https://docs.gandi.net/fr/hebergement_web/gestion_base_donnees/postgresql.html)

## Ikoula

[Ikoula](https://www.ikoula.com/fr/cloud-public/oneclick/postgresql)

## Bearstech

[Bearstech](https://bearstech.com/technologies-expertises/postgresql/)
vous propose son expertise autour de PostgreSQL

---

---
url: /installation.md
description: installation des PostgreSQL et de ses divers composants sous Windows
---

# installation PostgreSQL

* [Installation PostgreSQL 18 sous Windows](./pg-18-windows.md "Installation PostgreSQL 18 sous Windows")
* [Installation PostgreSQL 17 sous Windows](./pg-17-windows.md "Installation PostgreSQL 17 sous Windows")
* [Installation Driver ODBC sous Windows](./odbc-windows.md "Installation Driver ODBC sous Windows")

---

---
url: /installation/odbc-windows.md
description: >-
  Installation des drivers ANSI et Unicode sous Windows en version standard ou
  minimalloc
---

# Installation driver ODBC sous Windows

## Introduction

Lors de l'installation du driver `ODBC` sous `Windows`, hormis le fait de devoir choisir entre la version 32 bits ou la version 64 bits, nous avons la possibilitée
de choisir entre la version original et la version [mimalloc](https://github.com/microsoft/mimalloc "mimalloc is a compact general purpose allocator with excellent performance")

::: tip Explications
La différence principale entre le driver ODBC original de PostgreSQL et celui utilisant l'allocateur mimalloc réside dans la gestion de la mémoire, surtout dans les environnements multi-threadés :

* Le driver original utilise l'allocateur mémoire par défaut du système (généralement malloc/free), ce qui peut entraîner des problèmes de contention de verrous (lock contention) lors d'allocation mémoire simultanée par plusieurs threads. Cela peut ralentir les applications multi-threadées, notamment sur Windows, en raison de la synchronisation nécessaire pour gérer les allocations mémoire.

* Le driver utilisant mimalloc remplace l'allocateur par défaut par mimalloc, un allocateur mémoire moderne conçu pour réduire la contention de verrous et améliorer les performances, surtout dans les applications multi-threadées. Les tests montrent que cela élimine les délais liés à la contention mémoire, sans impact sur la stabilité, et est utilisé en [production](https://postgrespro.com/list/thread-id/2689876 "performance and reduce memory allocation lock contention") depuis plusieurs mois sans problème.

En résumé, la version avec [mimalloc](https://github.com/postgresql-interfaces/psqlodbc/pull/6 "Use mimalloc to improve performance and reduce memory allocation lock contention") offre une meilleure performance et une réduction de la contention mémoire,
ce qui est particulièrement utile pour les applications multi-threadées.

L'utilisation de mimalloc est optionnelle et doit être activée lors de la compilation du driver.
:::

## Installation

La première étape consite à télécharger le driver `ODBC`.

### Téléchargement

Pour télécharger l'installeur, rendez vous sur \[la page de téléchargement(https://www.postgresql.org/ftp/odbc/releases/ "Téléchargement driver Windows")] du driver `ODBC` pour windows, cliquer sur la denrière version contenant **mimalloc** dans le nom de dossier, puis sélectionner la version 64 bits au format **MSI**

![Téléchargement](/assets/odbc-17-download-step_1.C4HdxYbV.png "Téléchargement fichier d'installation Windows")

Lorsque le téélchargement est terminé, rendez vous dans votre dossier téléchargement

![Dossier Téléchargement](/assets/odbc-17-download-step_2.DQu7WD4j.png)

Ensuite fait eun clic droit, puis executer en tant qu'administrateur (les droits administrateur sont nécessaires pour installer les pilote ODBC).

![Ecran d'accueil](/assets/odbc-17-install-step_1.BCE1bgFm.png "Ecran d'accueil")

Dans cet écran cliquer seulement sur `Next`

![Licence](/assets/odbc-17-install-step_2.DyHmGr9m.png)

Sur l'écran de licence, cocher la case pour l'accepter, puis cliquer sur `Next`

![Choix des composants](/assets/odbc-17-install-step_3.7SUJziok.png)

Cet écran permet de choisir si l'on souhaite installer la documentation (en Anglais) en plus des **Drivers ODBC**, valider avec `Next`

![Récapitulatif](/assets/odbc-17-install-step_4.CM1t2Qbo.png)

A partir de cet écran, nosu somme prêt a installer les drivers, il faut les droits administrateur pour pouvoir continuer. cliquer sur `Install`

![Fin d'installation](/assets/odbc-17-install-step_5.DlWIj-dB.png)

L'installation est terminée, cliquer sur `Finish`.

## Vérification

Pour vérifier que les drivers `ODBC` de PostgreSQL sont bien installés, rendez vous dans `Source de données ODBC 64 bits` (ou `Source de données ODBC 32 bits` si vous avez installé une version 32 bits), a partir du menu Windows, rechercher **odbc 64** puis cliquer sur ouvrir.

![Source de données ODBC](/assets/odbc_source_donnees_64-step_1.CgCz8vrt.png "Source de données ODBC 64 bits")

L'outil `Administrateur de souce de données ODBC (64 bits)` s'ouvre, ensuite rendez vous dans l'onglet **Pilotes ODBC**.

![Source de données ODBC](/assets/odbc_source_donnees_64-step_2.BwMqgB8j.png "Source de données ODBC 64 bits")

Dnas le tableau, vous devez voir apparaîtres les drivers ODBC AINSI et Unicode, si vous le svoyez , votre installation est terminée.

## Source de données utilisateur

Une source de données utilisateur n'est visible que par l'utilisateur connecté (session ouverte actuelle), elle ne sera donc pas visible des autres utilisateurs de la station de travail.

![Source de données utilisateur](/assets/odbc_source_donnees_util-step_1.DzJU3Fyv.png "Onglet source de données utilisateur")

![Selectionner un driver](/assets/odbc_source_donnees_util-step_2.BVT2mI19.png "Sélection du driver ODBC")

![Configuration](/assets/odbc_source_donnees_util-step_3.CoBdCoHT.png)

1. Nom de la source de données, sera utilisé lros des appels à cette source.
2. Libellé de cette source de données
3. Nom de la base de données PostgreSQL
4. Sélectionné le mode SSL, par défaut c'est désactivé.
5. Le nom ou l'adresse IP du serveur PostgreSQL
6. Port du serveur PostgreSQL, (par défaut 5432)
7. Nom de l'utilisateur POstgreSQL
8. Mot de passe de l'utilisateur
9. Bouton pour tester la connexion
10. Sauvegarde de cette configuration

Lors de l'appuis sur le bouton test, vous devez obtenir le message suivant

![Test de connexion](/assets/odbc_source_donnees_util-step_4.HMR28csZ.png "Connexion effectué avec succès")

Notre source utilisateur apparaît dans notre liste à présent.

![Test de connexion](/assets/odbc_source_donnees_util-step_5.CQRwflwt.png "Liste des connexion utilisateurs")

## Source de données système

Une source de données système, contrairement à une source de données utilisateur, est visible par tous les utilisateurs de la station de travail.

![Source de données système](/assets/odbc_source_donnees_syst-step_1.BkMimo2N.png "Onglet source de données utilisateur")

![Selectionner un driver](/assets/odbc_source_donnees_util-step_2.BVT2mI19.png "Sélection du driver ODBC")

![Configuration](/assets/odbc_source_donnees_util-step_3.CoBdCoHT.png)

1. Nom de la source de données, sera utilisé lros des appels à cette source.
2. Libellé de cette source de données
3. Nom de la base de données PostgreSQL
4. Sélectionné le mode SSL, par défaut c'est désactivé.
5. Le nom ou l'adresse IP du serveur PostgreSQL
6. Port du serveur PostgreSQL, (par défaut 5432)
7. Nom de l'utilisateur POstgreSQL
8. Mot de passe de l'utilisateur
9. Bouton pour tester la connexion
10. Sauvegarde de cette configuration

Lors de l'appuis sur le bouton test, vous devez obtenir le message suivant

![Test de connexion](/assets/odbc_source_donnees_util-step_4.HMR28csZ.png "Connexion effectué avec succès")

Notre source utilisateur apparaît dans notre liste à présent.

![Test de connexion](/assets/odbc_source_donnees_syst-step_2.B11uIJNs.png "Liste des connexion utilisateurs")

---

---
url: /installation/pg-17-windows.md
description: Installation de la version 17 de PostgreSQL sous Windows Server et Desktop
---

# Installation PostgreSQL 17 sous Windows

## Compatibilité

Ci dessous le tableau de compatibilité des versions de PostgreSQL et Windows (Server et Desktop)

| Version PostgreSQL | Version Windows  |
|:-:|:- |
| PostgreSQL 18 |  Windows Server 2025 64 bitsWindows Server 2022 64 bitsWindows Server 2019 64 bits Windows 11 64 BitsWindows 10 64 Bits|
| PostgreSQL 17 |  Windows Server 2025 64 bitsWindows Server 2022 64 bitsWindows Server 2019 64 bits Windows 11 64 BitsWindows 10 64 Bits|
| PostgreSQL 16 |  Windows Server 2022 64 bitsWindows Server 2019 64 bitsWindows 11 64 BitsWindows 10 64 Bits|
| PostgreSQL 15 |  Windows Server 2019 64 bitsWindows Server 2016 64 bitsWindows 10 64 Bits|
| PostgreSQL 14 |  Windows Server 2019 64 bitsWindows Server 2016 64 bitsWindows 10 64 Bits|
| PostgreSQL 13 |  Windows Server 2019 64 bitsWindows Server 2016 64 bitsWindows 10 64 Bits|

::: info Cycle de vie
Le cycle de vie des versions de PostgreSQL est défini dans la partie [information](../information.md#cycle-de-vie "Cycle de vie PostgreSQL")
:::

## Téléchargement

Après avoir téléchargé l'installeur, vous devez avoir un fichier similaire dans votre dossier **Téléchargements**

![Fichier téléchargement windows](/assets/pg-17-windows-step_1.BHcUAN52.png "Fichier téléchargement windows")

::: warning
Les droits administrateur seront requis pour l'installation de PostgreSQL en tant que service Windows
:::

## Exécution en mode administrateur

Selectionner votre installeur puis faite un clic droit

![Execution en administrateur](/assets/pg-17-windows-step_2.DdSoUOom.png "Execution en mode administrateur")

Puis sélectionner **Exécuter en tant qu'administrateur**

![Ecran de bienvenue PG 17](/assets/pg-17-windows-step_3.C4RKLROl.png "Ecran de bienvenue PG 17")

Nous arrivons sur l'écran de bienvenue, rien à faire de particulier, cliquer sur **Suivant**

## Dossier d'installation

![Dossier d'installation](/assets/pg-17-windows-step_4.ih50Kroe.png "Dossier d'installation")

Cet écran nous propose de sélectionner le dossier d'installation, vous pouvez laisser le dossier par défaut,
ou bien le changer pour utiliser un autre lecteur (D:, E:).

L'utilisation d'un autre lecteur que le C permet :

* Séparer la partition système de la partition des données, au cas ou vous auirez besoin de restaurer la partition système,
* Si votre lecteur C est de petite taille,
* Si vos lecteurs sont sur des disques distincts, pour améliorer les performances de lecture/écriture.

Puis valider sur **Suivant**

## Sélection des composants

![Sélection des composants](/assets/pg-17-windows-step_5.DixYLWs9.png "Sélection des composants")

Ensuite nous allons sélectionner les composants a installer.

* **PostgreSQL Server**: Le sevreur PostgreSQL lui même
* **PgAdmin 4**: le client graphique permettant la gestion de la base de données PostgreSQL
* **Stack Builder**: Programme et extension suppélmentaire pour PostgreSQL
* **Command Line Tools**: Utilitaire PostgreSQL en ligne de commande (utilitaire psql par exemple)

Décocher les composants que vous ne souhaitez pas installer, puis cliquer sur **Suivant**

## Dossier de données

![Dossier des données de PostgreSQL](/assets/pg-17-windows-step_6.DUoP39PE.png "Dossier des données de PostgreSQL")

Sélectionner un dossier ou seront conservés les données des base de données créées.

Vous pouvez laisser le dossier par défaut, ou choisir un emplacement sur une autre lecteur.

::: warning
N'utiliser pas de lecteurs réseaux pour des questions de performances et de stabilité.
:::

Valider ensuite en cliquant sur **Suivant**

## Mot de passe

![Mot de passe utilisateur postgres](/assets/pg-17-windows-step_7.DeX5QPfQ.png "Mot de passe utilisateur postgres")

Vous devez définir ensuite le mot de passe de l'utilisateur **postgres**, cet utilisteur est le super utilisateur de la
base de données, mais également l'utilisateur windows qui lancera des service additionnel comme pgAgent par exemple.

Choisissez un mot de passe robuste pour cette utilisateur.

## Port d'écoute

![Port d'écoute](/assets/pg-17-windows-step_8.BrHhZ0aa.png "Port d'écoute")

Le port par défaut de PostgreSQL est 5432, vous pouvez bien sur le changer

::: info
Sous Windows vous pouvez installer plusieurs versions de PostgreSQL, dans ce cas, il faudra un port différent pour chacun des services
:::

Valider en cliquant sur **Suivant**

## Locale

![Locale du cluster de base de données](/assets/pg-17-windows-step_9.DFjcqVTd.png "Locale du cluster de base de données")

Vous pouvez sélectionner la locale par défaut de votre cluster

![Locale French France, locale du cluster](/assets/pg-17-windows-step_10.CXKu-ip3.png "Locale French France, locale du cluster")

Si votre base de données contiendra des données exclusivement en français, je vous conseille de sélectionner **French, France** (ou tout autre variante de French)

Sinon je vous invite à lire la documentation à ce sujet.

## Résumé

![Résumé de l'installation](/assets/pg-17-windows-step_11.Di3mywR3.png "Résumé de l'installation")

Cliquer sur **Suivant** pour débuter l'installation, ou **Retour** si vous souhaitez changer certaines options.

![Démarrage de l'installation](/assets/pg-17-windows-step_12.Cx4jANKB.png "Démarrage de l'installation")

Confimer le lancement de l'installation en cliquant sur **Suivant**

![Progression de l'installation](/assets/pg-17-windows-step_13.gZa53BLM.png "Progression de l'installation")

Cet écran vous affiche la progression de l'installation.

## Fin d'installation

![Fin d'installation de PostgreSQL](/assets/pg-17-windows-step_14.BJiAP1cz.png "Fin d'installation de PostgreSQL")

Ecran final d'installation.

Celui-ci vous demande si vous souhaitez lancer Stack Builder pour installer des composants additionnels.

Vous pourrez lancer le Stack Builder depuis le menu Windows ultérieurement.

## Sécurisation

Même si on est sous Windows, la sécurité à son importance. Il convient donc d'ajouter une règle entrante
pour autoriser le port 5432 (ou celui que vous avez mis) en TCP

::: warning
Le parefeu de Windows Server 2025 bloque les connexions par défaut, il faut par conséquent ouvrir le port
que vous avez définit pendant l'installation de PostgreSQL

Et comme on est pas à l'abri qu'une MAJ Windows force la fermeture des ports par défaut si aucune règle n'est définie
il vaut mieux explicitement ajouter une règle dans le pare feu.
:::

Rendez vous dans le parefeu Windows, sélectonner `Règles de traffic entrant`, puis clic droit et `Nouvelle règle`

![Selectionner le mode](/assets/parefeu-windows-step_1.CT1RsW9x.png "Parefeu - Selectionner le mode")

Selection le type de règle en sélectionnant `Port`, puis faite **suivant**

![Protocole et ports](/assets/parefeu-windows-step_2.BC1Fc9cB.png "Parefeu - Protocole et ports")

Sélectionner `TCP` puis `Ports locaux spécifiques` en indiquant `5432`.

::: tip Astuces
Si vous voulez indiquer plusieurs port, car vous avez plusieurs versions de PostgreSQL,
Vous séparez les différents ports par une virgule.
:::

Puis cliquer sur **Suivant**

![Action](/assets/parefeu-windows-step_3.UJ-GBds5.png "Parefeu - Action")

Sélectionner `Autoriser la connexion`, puis faite **Suivant**

![Profil](/assets/parefeu-windows-step_4.BTqaU0If.png "Parefeu - profil")

Selectionner les profils.

::: warning Avertissement
Si vous cocher `Public`, celui veux dire que vous autorisez l'éventuelle connexion
depuis des hotspots ou connexion grand public (Gares, Hotels, Bars, Restaurants, etc.).

Ce mode n'est pas recommandé par défaut.
:::

Puis faite **Suivant**

![Nommage règle](/assets/parefeu-windows-step_5.Cqbt4wLZ.png "Parefeu - Nommage règle")

Dernière étapes, on nomme explicitement la règle poru la retoruver plus facilement dans la liste

Puis faite **Terminer**

![Visualisation de la règle](/assets/parefeu-windows-step_6.DliV2tFv.png "Parefeu - Visualisation de la règle")

Vous pouvez également ajouter cette règle via Powershell, si vous souhaitez automatiser cette étape via la commande [New-NetFirewallRule](https://learn.microsoft.com/fr-fr/powershell/module/netsecurity/new-netfirewallrule "Commande Powershell New-NetFirewallRule")

```powershell
New-NetFirewallRule -Name "PostgreSQL Server Port" -DisplayName "PostgreSQL Server Port" -Description 'Ouverture port PostgreSQL' `
    -Profile Any -Direction Inbound -Action Allow -Protocol TCP -Program Any -LocalAddress Any -LocalPort 5432
```

---

---
url: /installation/pg-18-windows.md
description: Installation de la version 18 de PostgreSQL sous Windows Server et Desktop
---

# Installation PostgreSQL 18 sous Windows

## Compatibilité

Ci dessous le tableau de compatibilité des versions de PostgreSQL et Windows (Server et Desktop)

| Version PostgreSQL | Version Windows  |
|:-:|:- |
| PostgreSQL 18 |  Windows Server 2025 64 bitsWindows Server 2022 64 bitsWindows Server 2019 64 bits Windows 11 64 BitsWindows 10 64 Bits|
| PostgreSQL 17 |  Windows Server 2025 64 bitsWindows Server 2022 64 bitsWindows Server 2019 64 bits Windows 11 64 BitsWindows 10 64 Bits|
| PostgreSQL 16 |  Windows Server 2022 64 bitsWindows Server 2019 64 bitsWindows 11 64 BitsWindows 10 64 Bits|
| PostgreSQL 15 |  Windows Server 2019 64 bitsWindows Server 2016 64 bitsWindows 10 64 Bits|
| PostgreSQL 14 |  Windows Server 2019 64 bitsWindows Server 2016 64 bitsWindows 10 64 Bits|
| PostgreSQL 13 |  Windows Server 2019 64 bitsWindows Server 2016 64 bitsWindows 10 64 Bits|

::: info Cycle de vie
Le cycle de vie des versions de PostgreSQL est défini dans la partie [information](../information.md#cycle-de-vie "Cycle de vie PostgreSQL")
:::

Installation des version précédentes

* [PostgreSQL version 17 sous Windows](./pg-17-windows.md "PostgreSQL version 17 sous Windows")

## Téléchargement

Après avoir téléchargé l'installeur, vous devez avoir un fichier similaire dans votre dossier **Téléchargements**

![Fichier téléchargement windows](/assets/pg-18-windows-step_1.CsSsS42N.png)

::: warning
Les droits administrateur seront requis pour l'installation de PostgreSQL en tant que service Windows
:::

## Exécution en mode administrateur

Selectionner votre ficher de l'installeur puis faite un clic droit

![Execution en administrateur](/assets/pg-18-windows-step_2.Dnr7R8Ej.png "Execution en administrateur")

Puis sélectionner **Exécuter en tant qu'administrateur**

![Ecran de bienvenue PG 18](/assets/pg-18-windows-step_3.C7FFZGUz.png "Ecran de bienvenue PG 18")

Nous arrivons sur l'écran de bienvenue, rien à faire de particulier, cliquer sur **Suivant**

## Dossier d'installation

![Dossier d'installation](/assets/pg-18-windows-step_4.BiZCWRIa.png "Dossier d'installation")

Cet écran nous propose de sélectionner le dossier d'installation, vous pouvez laisser le dossier par défaut,
ou bien le changer pour utiliser un autre lecteur (D:, E:).

L'utilisation d'un autre lecteur que le C permet :

* Séparer la partition système de la partition des données, au cas ou vous auirez besoin de restaurer la partition système,
* Si votre lecteur C est de petite taille,
* Si vos lecteurs sont sur des disques distincts, pour améliorer les performances de lecture/écriture.

Puis valider sur **Suivant**

## Sélection des composants

![Sélection des composants](/assets/pg-18-windows-step_5.Dk131QZ6.png "Sélection des composants")

Ensuite nous allons sélectionner les composants a installer.

* **PostgreSQL Server**: Le serveur PostgreSQL lui même
* **PgAdmin 4**: le client graphique permettant la gestion de la base de données PostgreSQL
* **Stack Builder**: Programmes et extensions suppélmentaires pour PostgreSQL
* **Command Line Tools**: Utilitaire PostgreSQL en ligne de commande (utilitaire psql par exemple)

Décocher les composants que vous ne souhaitez pas installer, puis cliquer sur **Suivant**

## Dossier de données

![Dossier des données de PostgreSQL](/assets/pg-18-windows-step_6.bWazED2p.png "Dossier des données de PostgreSQL")

Sélectionner un dossier ou seront conservés les données des base de données créées.

Vous pouvez laisser le dossier par défaut, ou choisir un emplacement sur une autre lecteur.

::: warning
N'utiliser pas de lecteurs réseaux pour des questions de performance et de stabilité.
:::

Valider ensuite en cliquant sur **Suivant**

## Mot de passe

![Mot de passe utilisateur postgres](/assets/pg-18-windows-step_7.UKV85P4m.png "Mot de passe utilisateur postgres")

Vous devez définir ensuite le mot de passe de l'utilisateur **postgres**, cet utilisteur est le super utilisateur de la
base de données, mais également l'utilisateur windows qui lancera des service additionnel comme pgAgent par exemple.

Choisissez un mot de passe robuste pour cette utilisateur.

## Port d'écoute

!\[Port d'écoute]\(pg-18-windows-step\_8.png Port d'écoute)

Le port par défaut de PostgreSQL est 5432, vous pouvez bien sur le changer

::: info
Sous Windows vous pouvez installer plusieurs versions de PostgreSQL, dans ce cas, il faudra un port différent
pour chacun des services
:::

Valider en cliquant sur **Suivant**

## Locale

Vous pouvez sélectionner la locale par défaut de votre cluster

![Locale French France, locale du cluster](/assets/pg-18-windows-step_9.BDFAIzLm.png "Locale French France, locale du cluster")

Si votre base de données contiendra des données exclusivement en français, je vous conseille de sélectionner **French, France** (ou tout autre variante de French)

Sinon je vous invite à lire la documentation à ce sujet.

## Résumé

![Résumé de l'installation](/assets/pg-18-windows-step_10.DmF532bm.png "Résumé de l'installation de PG 18")

Cliquer sur **Suivant** pour débuter l'installation, ou **Retour** si vous souhaitez changer certaines options.

![Démarrage de l'installation](/assets/pg-18-windows-step_11.IxG5VIDU.png "Démarrage de l'installation de PG 18")

Confimer le lancement de l'installation en cliquant sur **Suivant**

![Progression de l'installation](/assets/pg-18-windows-step_12.C2eJG0dg.png "Progression de l'installation")

Cet écran vous affiche la progression de l'installation.

## Fin d'installation

![Fin d'installation de PostgreSQL](/assets/pg-18-windows-step_13.CiiJWWfg.png "Fin d'installation de PostgreSQL")

Ecran final d'installation.

Celui-ci vous demande si vous souhaitez lancer Stack Builder pour installer des composants additionnels.

Vous pourrez lancer le Stack Builder depuis le menu Windows ultérieurement.

## Sécurisation

Même si on est sous Windows, la sécurité à son importance. Il convient donc d'ajouter une règle entrante
pour autoriser le port 5432 (ou celui que vous avez mis) en TCP

::: warning
Le parefeu de Windows Server 2025 bloque les connexions par défaut, il faut par conséquent ouvrir le port
que vous avez définit pendant l'installation de PostgreSQL

Et comme on est pas à l'abri qu'une MAJ Windows force la fermeture des ports par défaut si aucune règle n'est définie
il vaut mieux explicitement ajouter une règle dans le pare feu.
:::

Rendez vous dans le parefeu Windows, sélectonner `Règles de traffic entrant`, puis clic droit et `Nouvelle règle`

![Selectionner le mode](/assets/parefeu-windows-step_1.CT1RsW9x.png "Parefeu - Selectionner le mode")

Selection le type de règle en sélectionnant `Port`, puis faite **suivant**

![Protocole et ports](/assets/parefeu-windows-step_2.BC1Fc9cB.png "Parefeu - Protocole et ports")

Sélectionner `TCP` puis `Ports locaux spécifiques` en indiquant `5432`.

::: tip Astuces
Si vous voulez indiquer plusieurs port, car vous avez plusieurs versions de PostgreSQL,
Vous séparez les différents ports par une virgule.
:::

Puis cliquer sur **Suivant**

![Action](/assets/parefeu-windows-step_3.UJ-GBds5.png "Parefeu - Action")

Sélectionner `Autoriser la connexion`, puis faite **Suivant**

![Profil](/assets/parefeu-windows-step_4.BTqaU0If.png "Parefeu - profil")

Selectionner les profils.

::: warning Avertissement
Si vous cocher `Public`, celui veux dire que vous autorisez l'éventuelle connexion
depuis des hotspots ou connexion grand public (Gares, Hotels, Bars, Restaurants, etc.).

Ce mode n'est pas recommandé par défaut.
:::

Puis faite **Suivant**

![Nommage règle](/assets/parefeu-windows-step_5.Cqbt4wLZ.png "Parefeu - Nommage règle")

Dernière étapes, on nomme explicitement la règle poru la retoruver plus facilement dans la liste

Puis faite **Terminer**

![Visualisation de la règle](/assets/parefeu-windows-step_6.DliV2tFv.png "Parefeu - Visualisation de la règle")

Vous pouvez également ajouter cette règle via Powershell, si vous souhaitez automatiser cette étape via la commande [New-NetFirewallRule](https://learn.microsoft.com/fr-fr/powershell/module/netsecurity/new-netfirewallrule "Commande Powershell New-NetFirewallRule")

```powershell
New-NetFirewallRule -Name "PostgreSQL Server Port" -DisplayName "PostgreSQL Server Port" -Description 'Ouverture port PostgreSQL' `
    -Profile Any -Direction Inbound -Action Allow -Protocol TCP -Program Any -LocalAddress Any -LocalPort 5432
```

---

---
url: /articles/cout.md
description: >-
  Cette page décrit les couts d'acquisition de PostgreSQL quelle que soit le
  mode d'hébergement
---

# Coûts

PostgreSQL est un système de gestion de base de données relationnelle open source,
ce qui signifie que son acquisition et son utilisation de base sont gratuites.

Vous pouvez télécharger, installer et utiliser PostgreSQL sans frais de licence, que ce soit pour un usage personnel, professionnel ou même à grande échelle.

Cependant, des coûts peuvent survenir si vous choisissez d’utiliser des services gérés (comme OVH, Amazon RDS for PostgreSQL, Google Cloud SQL, ou d’autres hébergeurs spécialisés).

Dans ce cas, les coûts dépendent principalement de la consommation de ressources (vCPU, mémoire, stockage, transfert de données, etc.) et des options de support étendu pour les versions obsolètes.

Par exemple, AWS facture environ 0,10 $ par vCPU-heure pour certaines configurations en 2025, et Google Cloud propose des calculateurs pour estimer vos coûts selon vos besoins.

En résumé :

* `PostgreSQL` lui-même est gratuit et open source.
* Les coûts proviennent de l’hébergement, de la gestion et des services associés si vous passez par un fournisseur cloud ou un hébergeur spécialisé.

## Auto hébergement (On Premise)

L’auto-hébergement (aussi appelé On Prémise dans les offres) de PostgreSQL implique que vous gérez vous-même l’infrastructure (serveur physique, machine virtuelle, ou conteneur) sur laquelle la base de données s’exécute.

Voici les principaux coûts à prévoir dans ce cas :

### Coût du matériel

* **Serveur physique** : Achat ou location d’un serveur dédié (coût variable selon la puissance : de quelques centaines à plusieurs milliers d’euros).
* **Machine virtuelle (VPS/Cloud)** : Si vous utilisez un fournisseur comme OVH, DigitalOcean, Linode, AWS EC2, ou Google Compute Engine, les coûts dépendent de la taille de l’instance (vCPU, RAM, stockage). Par exemple, une petite instance peut coûter entre 5 € et 20 €/mois, tandis qu’une instance plus puissante peut atteindre 100 €/mois ou plus.

### Coût du stockage

* **Disques durs/SSD** : Le coût dépend de la capacité et du type de stockage (SSD plus cher mais plus performant). Comptez quelques euros à plusieurs dizaines d’euros par mois pour du stockage cloud, ou un investissement initial pour du stockage local.

### Coût du système d'exploitation

En fonction du système d'exploitation choisi, des coûts supplémentaires seront à prévoir comme:

* Licence de l'OS (Ex Windows)
* Contrat de maintenance et/ou de support

### Coût de la maintenance et de l’administration

* **Temps humain** : Si vous gérez vous-même l’administration (installation, mises à jour, sauvegardes, sécurité, monitoring), cela représente un coût en temps (ou en salaire si vous externalisez).
* **Outils de monitoring/sauvegarde** : Certains outils (comme pgBackRest, Prometheus, Grafana) sont gratuits, mais d’autres solutions professionnelles peuvent avoir un coût.

### Coût de la bande passante et de l’électricité

* **Bande passante** : Si vous hébergez chez un fournisseur cloud, la bande passante sortante peut être facturée (souvent quelques centimes par Go).
* **Électricité et refroidissement** : Pour un serveur physique en local, il faut compter le coût énergétique et éventuellement la climatisation.

### Coût des sauvegardes externes

* **Stockage externe** : Sauvegarder vos données sur un autre site ou dans le cloud (S3, Backblaze, etc.) peut engendrer des coûts supplémentaires (quelques euros à quelques dizaines d’euros par mois selon le volume).

### Exemple de budget mensuel pour un auto-hébergement cloud (VPS) :

| Poste de coût                   | Coût estimé (par mois) |
|---------------------------------|:----------------------:|
| Instance VPS (2 vCPU, 4 Go RAM) | 10 € – 30 €            |
| Stockage (50 Go SSD)            | 2 € – 10 €             |
| Bande passante                  | 0 € – 5 €              |
| Sauvegardes externes            | 2 € – 10 €             |
| **Total estimé**                | **14 € – 55 €**        |

### En résumé

* **PostgreSQL lui-même est gratuit** (pas de licence).
* **Les coûts viennent de l’infrastructure, de la maintenance et des services associés**.
* **L’auto-hébergement est souvent moins cher que les solutions gérées**, mais demande plus de compétences techniques.

## Hébergement distant

Pour un hébergement distant de PostgreSQL, les coûts à prévoir dépendent principalement du type d’hébergement choisi (cloud, dédié, managé) et des ressources nécessaires (stockage, RAM, CPU, trafic réseau).

Voici une synthèse des principaux postes de coûts et des fournisseurs populaires en 2025 :

### Hébergement Cloud (PaaS/DBaaS)

Les solutions cloud sont les plus flexibles et facturées à l’usage.

| Fournisseur         | Offre de base (2025)         | Coût mensuel estimé (EUR) | Remarques                                                                 |
|---------------------|------------------------------|:-------------------------:|---------------------------------------------------------------------------|
| **AWS RDS**         | db.t4g.micro (1 vCPU, 1 GiB) | ~15-25 €                  | Facturation à l’heure, stockage supplémentaire payant                     |
| **Google Cloud SQL**| 1 vCPU, 3.75 Go RAM          | ~20-30 €                  | Inclut 10 Go de stockage, sauvegardes automatiques                        |
| **Azure Database**  | Basic (1 vCPU, 2 Go RAM)     | ~25-35 €                  | Intégration avec l’écosystème Microsoft                                   |
| **DigitalOcean**    | 1 vCPU, 1 Go RAM, 10 Go SSD  | ~15 €                     | Simple, adapté aux petits projets                                         |
| **Scaleway**        | Startup (2 vCPU, 4 Go RAM)   | ~20 €                     | Prix compétitifs, hébergé en Europe                                       |

***

### Hébergement VPS/Dédié

Si vous préférez gérer vous-même l’instance PostgreSQL sur un serveur virtuel ou dédié:

| Fournisseur         | Offre de base (2025)         | Coût mensuel estimé (EUR) | Remarques                                                                 |
|---------------------|------------------------------|:-------------------------:|---------------------------------------------------------------------------|
| **OVHcloud**        | VPS (2 vCPU, 4 Go RAM)       | ~10-20 €                  | Installation manuelle de PostgreSQL, coût variable selon la configuration |
| **Hetzner**         | CX21 (2 vCPU, 4 Go RAM)      | ~5-10 €                   | Très économique, idéal pour les développeurs                              |
| **Linode**          | 2 vCPU, 4 Go RAM             | ~12-15 €                  | Bonne réputation pour la stabilité                                        |

***

### Coûts supplémentaires à prévoir

* **Stockage supplémentaire** : ~0,10-0,30 €/Go/mois selon le fournisseur.
* **Sauvegardes automatiques** : Souvent incluses, sinon ~5-10 €/mois.
* **Trafic réseau** : Généralement gratuit jusqu’à un certain seuil, puis ~0,05-0,10 €/Go.
* **Support technique** : Option payante chez certains fournisseurs (ex : AWS Support Business ~100 €/mois).

### Exemple de budget mensuel

* **Petit projet** : 10-20 €/mois (VPS ou DBaaS basique)
* **Projet moyen** : 30-60 €/mois (DBaaS avec sauvegardes et monitoring)
* **Gros projet** : 100 € et plus (instances dédiées, haute disponibilité)

### Conseils pour optimiser les coûts

* **Choisir un fournisseur européen** si vos utilisateurs sont en Europe (latence, RGPD).
* **Utiliser des instances “serverless”** (ex : AWS Aurora Serverless) pour des coûts proportionnels à l’usage.
* **Surveiller la consommation** et ajuster les ressources régulièrement.

## La licence

PostgreSQL est publié sous la licence PostgreSQL, une licence Open Source libérale, similaire aux licences BSD ou MIT.

PostgreSQL, Système de gestion de base de données (également connu sous le nom de Postgres, anciennement Postgres95).

* Des parties du logiciel protégées par le droit d'auteur © 1996-2025, The PostgreSQL Global Development Group
* Des parties du logiciel protégées par le droit d'auteur © 1994, The Regents of the University of California

L'utilisation, la copie, la modification et la distribution de ce logiciel et de sa documentation à quelque fin que ce soit, sans frais ni accord écrit, sont autorisées par les présentes, sous réserve que la mention de droit d'auteur ci-dessus, ce paragraphe et les deux paragraphes suivants figurent sur toutes les copies.

::: warning Avertissement
L'UNIVERSITÉ DE CALIFORNIE NE POURRA EN AUCUN CAS ÊTRE TENUE RESPONSABLE ENVERS QUICONQUE DES DOMMAGES DIRECTS, INDIRECTS, SPÉCIAUX, ACCESSOIRES OU CONSÉCUTIFS, Y COMPRIS LA PERTE DE PROFITS, DÉCOULANT DE L'UTILISATION DE CE LOGICIEL ET DE SA DOCUMENTATION, MÊME SI L'UNIVERSITÉ DE CALIFORNIE A ÉTÉ AVISÉE DE LA POSSIBILITÉ DE TELS DOMMAGES.

L'UNIVERSITÉ DE CALIFORNIE DÉCLINE EXPRESSÉMENT TOUTE GARANTIE, Y COMPRIS, MAIS SANS S'Y LIMITER, LES GARANTIES IMPLICITES DE QUALITÉ MARCHANDE ET D'ADÉQUATION À UN USAGE PARTICULIER. LE LOGICIEL FOURNI CI-DESSOUS EST « EN L'ÉTAT » ET L'UNIVERSITÉ DE CALIFORNIE N'A AUCUNE OBLIGATION DE FOURNIR DE LA MAINTENANCE, DU SUPPORT, DES MISES À JOUR, DES AMÉLIORATIONS OU DES MODIFICATIONS.
:::

---

---
url: /articles/types.md
description: Descriptif des types de données géré par de PostgreSQL
---

# Types de données PostgreSQL

PostgreSQL propose une grande variété de types de données. Voici une liste exhaustive des principaux types disponibles, classés par catégorie.

## 1. Types numériques

| Type                | Description                                                                          | Exemple de valeur         |
|---------------------|--------------------------------------------------------------------------------------|---------------------------|
| `smallint`          | Entier sur 2 octets (plage : -32 768 à 32 767)                                       | `42`                      |
| `integer`           | Entier sur 4 octets (plage : -2 147 483 648 à 2 147 483 647)                         | `42`                      |
| `bigint`            | Entier sur 8 octets (plage : -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807) | `9223372036854775807`     |
| `decimal`           | Nombre décimal exact, précision variable (ex: `decimal(10,2)`)                       | `12345678.90`             |
| `numeric`           | Équivalent à `decimal`                                                               | `12345678.90`             |
| `real`              | Nombre à virgule flottante sur 4 octets                                              | `3.14159`                 |
| `double precision`  | Nombre à virgule flottante sur 8 octets                                              | `3.141592653589793`       |
| `smallserial`       | Auto-incrément sur 2 octets (1 à 32 767)                                             | `42`                      |
| `serial`            | Auto-incrément sur 4 octets (1 à 2 147 483 647)                                      | `42`                      |
| `bigserial`         | Auto-incrément sur 8 octets (1 à 9 223 372 036 854 775 807)                          | `9223372036854775807`     |

::: tip

* serial est un type integer associé à une séquence
* bigserial est un type bigint associé à une séquence

La séquence associé est créé automatiquement lors de la création ou modification de la table
:::

## 2. Types monétaires

| Type      | Description                                      | Exemple de valeur |
|-----------|--------------------------------------------------|-------------------|
| `money`   | Montant monétaire (avec symbole de devise)       | `$1234.56`        |

::: warning
Attention ce type est fortement dépendant de la locale du serveur de base de données.

Si vous utilsier ce type, et que vous avez besoin de faire une sauvegarde et restauration, il faut vous assurer que
lc\_monetary est la même entre le serveur ou a été faite la sauvegarde et celui ou la base de données est restaurée.
:::

## 3. Types de caractères

| Type               | Description                                                                 | Exemple de valeur         |
|--------------------|-----------------------------------------------------------------------------|---------------------------|
| `character(n)`     | Chaîne de longueur fixe (rempli d'espaces si nécessaire)                    | `'PostgreSQL'`            |
| `varchar(n)`       | Chaîne de longueur variable (limite `n`)                                    | `'PostgreSQL'`            |
| `text`             | Chaîne de longueur illimitée                                                | `'PostgreSQL'`            |
| `char(n)`          | Équivalent à `character(n)`                                                 | `'SQL'`                   |
| `character varying`| Équivalent à `varchar`                                                      | `'PostgreSQL'`            |

## 4. Types binaires

| Type          | Description                                      | Exemple de valeur         |
|---------------|--------------------------------------------------|---------------------------|
| `bytea`       | Chaîne binaire (octets bruts)                    | `'\xDEADBEEF'`            |

## 5. Types date/heure

| Type                      | Description                                                                 | Exemple de valeur         |
|---------------------------|-----------------------------------------------------------------------------|---------------------------|
| `date`                    | Date (sans heure)                                                           | `'2025-09-12'`            |
| `time`                    | Heure (sans date)                                                           | `'14:30:00'`              |
| `time with time zone`     | Heure avec fuseau horaire                                                   | `'14:30:00+02'`           |
| `timestamp`               | Date et heure (sans fuseau horaire)                                         | `'2025-09-12 14:30:00'`   |
| `timestamp with time zone`| Date et heure avec fuseau horaire                                           | `'2025-09-12 14:30:00+02'`|
| `interval`                | Durée ou intervalle de temps                                                | `'1 day 2 hours'`         |

## 6. Types booléens

| Type      | Description                                      | Exemple de valeur         |
|-----------|--------------------------------------------------|---------------------------|
| `boolean` | Vrai ou faux                                     | `true`, `false`, `1`, `0` |

### Valeur vrai

Vrai peut être représenté avec les valeurs suivantes

* true
* yes
* on
* t
* 1

```sql
SELECT 'true'::boolean as true_boolean, 'yes'::boolean as yes_boolean, 
       'on'::boolean as on_boolean, 1::boolean as int_boolean, 
       't'::boolean as t_boolean;
```

Résultat

|true\_boolean|yes\_boolean|on\_boolean|int\_boolean|t\_boolean|
|:----------:|:---------:|:--------:|:---------:|:-------:|
|:heavy\_check\_mark:|:heavy\_check\_mark:|:heavy\_check\_mark:|:heavy\_check\_mark:|:heavy\_check\_mark:|

### Valeur faux

Faux peut être représenté avec les valeurs suivantes

* false
* no
* off
* f
* 0

```sql
SELECT 'false'::boolean as false_boolean, 'no'::boolean as no_boolean, 
       'off'::boolean as off_boolean, 0::boolean as int_boolean,
       'f'::boolean as f_boolean;
```

Résultat

|false\_boolean|no\_boolean|off\_boolean|int\_boolean|f\_boolean|
|:-----------:|:--------:|:---------:|:---------:|:-------:|
|:x:|:x:|:x:|:x:|:x:|

## 7. Types énumérés

| Type      | Description                                       | Exemple de valeur         |
|-----------|---------------------------------------------------|---------------------------|
| `enum`    | Type personnalisé avec valeurs prédéfinies        | `'rouge'`, `'vert'`       |

## 8. Types géométriques

| Type         | Description                                      | Exemple de valeur          |
|--------------|--------------------------------------------------|----------------------------|
| `point`      | Point géométrique (x, y)                         | `(10.0, 20.0)`             |
| `line`       | Ligne infinie                                    | `{(10.0,20.0),(30.0,40.0)}`|
| `lseg`       | Segment de ligne                                 | `[(10.0,20.0),(30.0,40.0)]`|
| `box`        | Rectangle                                        | `((10.0,20.0),(30.0,40.0))`|
| `path`       | Chemin (ligne brisée)                            | `[(10.0,20.0),(30.0,40.0)]`|
| `polygon`    | Polygone                                         | `((10.0,20.0),(30.0,40.0))`|
| `circle`     | Cercle                                           | `<(10.0,20.0),5.0>`        |

## 9. Types réseau

| Type         | Description                                      | Exemple de valeur           |
|--------------|--------------------------------------------------|-----------------------------|
| `cidr`       | Adresse IP réseau (CIDR)                         | `'192.168.1.0/24'`          |
| `inet`       | Adresse IP (IPv4 ou IPv6)                        | `'192.168.1.1'`             |
| `macaddr`    | Adresse MAC                                      | `'08:00:2b:01:02:03'`       |
| `macaddr8`   | Adresse MAC  (format EUI-64)                     | `'00:00:08:00:2b:01:02:03'` |

## 10. Types de bits

| Type         | Description                                      | Exemple de valeur         |
|--------------|--------------------------------------------------|---------------------------|
| `bit(n)`     | Chaîne de bits de longueur fixe                  | `B'1010'`                 |
| `bit varying`| Chaîne de bits de longueur variable              | `B'101010'`               |

## 11. Types de texte et recherche

| Type         | Description                                      | Exemple de valeur         |
|--------------|--------------------------------------------------|---------------------------|
| `tsvector`   | Vecteur de texte pour recherche full-text        | `'fat' 'cat' 'rat'`       |
| `tsquery`    | Requête de recherche full-text                   | `'fat & cat'`             |

## 12. Types UUID

| Type         | Description                                      | Exemple de valeur                        |
|--------------|--------------------------------------------------|------------------------------------------|
| `uuid`       | Identifiant unique universel                     | `'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'` |

## 13. Types JSON

| Type         | Description                                      | Exemple de valeur         |
|--------------|--------------------------------------------------|---------------------------|
| `json`       | Données JSON (texte brut)                        | `'{"nom": "PostgreSQL"}'` |
| `jsonb`      | Données JSON binaires (indexables)               | `'{"nom": "PostgreSQL"}'` |

## 14. Types XML

| Type         | Description                                      | Exemple de valeur         |
|--------------|--------------------------------------------------|---------------------------|
| `xml`        | Données XML                                      | `'<nom>PostgreSQL</nom>'` |

## 15. Types composites

| Type         | Description                                      | Exemple de valeur         |
|--------------|--------------------------------------------------|---------------------------|
| `composite`  | Type personnalisé (créé avec `CREATE TYPE`)      | `(valeur1, valeur2)`      |

### Création d’un type composite

Supposons que l'on veut créer un type pour représenter une adresse, et stocker:

* le nom de la rue
* la ville
* le code postal
* le pays
* le numéro de la rue

Nous allons donc créer le type ci-dessous

```sql
CREATE TYPE adresse_type AS (
    rue VARCHAR(100),
    ville VARCHAR(50),
    code_postal CHAR(5),
    pays VARCHAR(50),
    numero INTEGER
);
```

### Utilisation dans une table

On peut utiliser ce type comme colonne d’une table

```sql
CREATE TABLE clients (
   id SERIAL PRIMARY KEY,
   nom VARCHAR(100) NOT NULL,
   adresse adresse_type
);
```

### Insertion de données

Pour insérer une valeur de type composite, on utilise la syntaxe (val1, val2, ...):

```sql
INSERT INTO clients (nom, adresse)
VALUES (
    'Jean Dupont',
    ('Rue de Paris', 'Paris', '75000', 'France', 123)::adresse_type
);
```

### Accès aux champs d’un type composite

Pour accéder à un champ spécifique:

```sql
SELECT nom, (adresse).ville FROM clients;
```

Résultat

|id|nom|adresse|
|--|---|-------|
|1|Jean Dupont|(Rue de Paris,Paris,75000,France,123)|

### Mise à jour d’un champ composite

Pour mettre à jour un seul champ de la colonne du type composite :

```sql
UPDATE clients
SET adresse.pays = 'Espagne'
WHERE nom = 'Jean Dupont';
```

::: tip
Vous remarquerez que dans le cas de l'UPDATE, nous n'avons pas mis de parenthèse à adresse
:::

Nous avons maintenant le résultat dans la table

|id|nom|adresse|
|--|---|-------|
|1|Jean Dupont|(Rue de Paris,Paris,75000,Espagne,123)|

par contre si l'on avait besoin de faire une incrémentation d'un élement du type composite par exemple, nous aurions du utiliser la syntaxe suivante.

```sql
UPDATE clients
SET adresse.numero = (adresse).numero + 1
WHERE nom = 'Jean Dupont';
```

::: tip
Dans la partie gauche du SET (entre le SET et le =), nous avons la colonne de la table donc les parenthères ne sont pas nécéssaire,
par contre dans la partie nous pourrions avoir le nom d'un table (Voir UPDATE ... FROM ...), donc il faut indiquer
que l'on est sur une colonne
:::

Nous avons maintenant le résultat dans la table

|id|nom|adresse|
|--|---|-------|
|1|Jean Dupont|(Rue de Paris,Paris,75000,Espagne,124)|

## 16. Types de plage

| Type         | Description                                      | Exemple de valeur              |
|--------------|--------------------------------------------------|--------------------------------|
| `int4range`  | Plage d'entiers                                  | `[1, 10]`                      |
| `int8range`  | Plage de bigint                                  | `[1, 10000000000]`             |
| `numrange`   | Plage de nombres                                 | `[1.0, 10.0]`                  |
| `tsrange`    | Plage de timestamp (sans fuseau horaire)         | `['2025-01-01', '2025-12-31']` |
| `tstzrange`  | Plage de timestamp avec fuseau horaire           | `['2025-01-01', '2025-12-31']` |
| `daterange`  | Plage de dates                                   | `['2025-01-01', '2025-12-31']` |

## 17. Types d'identifiants d'objet

| Type         | Description                                      | Exemple de valeur         |
|--------------|--------------------------------------------------|---------------------------|
| `oid`        | Identifiant d'objet PostgreSQL                   | `12345`                   |
| `regproc`    | Nom de fonction (avec surcharge)                 | `'foobar(integer)'`       |
| `regclass`   | Nom de table                                     | `'ma_table'`              |

## 18. Types pseudo-types

| Type         | Description                                      | Exemple de valeur         |
|--------------|--------------------------------------------------|---------------------------|
| `any`        | Peut correspondre à n'importe quel type          | (utilisé dans les fonctions) |
| `anyarray`   | Peut correspondre à n'importe quel tableau       | (utilisé dans les fonctions) |
| `anyelement` | Peut correspondre à n'importe quel élément       | (utilisé dans les fonctions) |

## 19. Types de tableau

| Type         | Description                                      | Exemple de valeur         |
|--------------|--------------------------------------------------|---------------------------|
| `array`      | Tableau d'un type de base                        | `ARRAY[1, 2, 3]`          |

## 20. Types spécifiques à PostgreSQL

| Type            | Description                                      | Exemple de valeur         |
|-----------------|--------------------------------------------------|---------------------------|
| `pg_lsn`        | Position dans le journal de transactions (WAL)   | `'0/16B19F8'`             |
| `txid_snapshot` | Instantané de transaction                        | `'100:101:...'`           |

::: warning Informations complémentaires

* Certains types nécessitent des extensions (`uuid-ossp`, `pgcrypto`, etc.).
* PostgreSQL permet de créer des **types personnalisés** avec `CREATE TYPE`.
* Pour plus de détails, consultez la \[documentation officielle de PostgreSQL]\(https://docs.postgresql.fr/17/datatype.html type de données).
  :::

## Articles sur le net

* \[PostgreSQL - JSONB et
  Statistiques]\(https://blog.anayrat.info/2017/11/26/postgresql-jsonb-et-statistiques/ PostgreSQL jsonb et statistiques)

---

---
url: /logiciel.md
---

[Rubrique déplacée](../logiciels.md)

---

---
url: /logiciels.md
description: Liste de logiciels utilisant PostgreSQL comme base de données
---

# Logiciels

## Dolibarr

### Résumé détaillé de Dolibarr

**Qu’est-ce que Dolibarr ?**

Dolibarr est un logiciel open source de gestion d’entreprise (ERP) et de relation client (CRM), conçu pour les TPE, PME, grandes entreprises, freelancers et associations. Il permet de centraliser et d’automatiser la gestion des activités professionnelles : devis, commandes, factures, stocks, agenda, contacts, projets, comptabilité, etc. Dolibarr est particulièrement apprécié pour sa flexibilité, sa simplicité d’utilisation et son approche modulaire, qui permet d’activer uniquement les fonctionnalités nécessaires à chaque entreprise.

**Origine et communauté**

Créé en 2003, Dolibarr est développé et maintenu par une large communauté internationale de bénévoles et de partenaires. Le logiciel est distribué sous licence GNU GPL v3, garantissant sa gratuité et sa liberté d’utilisation, de modification et de redistribution.

**Fonctionnalités principales**

* Gestion commerciale (devis, commandes, factures)
* Gestion des stocks et des produits
* Gestion des contacts et des relations clients (CRM)
* Gestion de projets et des tâches
* Gestion comptable et financière
* Agenda partagé et gestion des ressources humaines
* Point de vente (POS)
* Intégration avec d’autres outils via API
* Multi-utilisateurs avec différents niveaux de permissions
* Multi-devises et multi-langues

**Avantages**

* **Open Source** : Gratuit, personnalisable, indépendant des éditeurs propriétaires.
* **Modulaire** : Activation des fonctionnalités selon les besoins.
* **Web-based** : Accessible depuis n’importe quel navigateur, sans installation lourde.
* **Communauté active** : Support, documentation, modules complémentaires.
* **Intégration** : API pour connecter Dolibarr à d’autres logiciels.
* **Conformité légale** : En cours de certification pour la loi française sur les logiciels de caisse (2025).

**Inconvénients**

* Courbe d’apprentissage pour les utilisateurs non techniques.
* Certaines fonctionnalités avancées nécessitent des modules payants ou l’intervention d’un prestataire.
* Performances à surveiller en cas de bases de données très volumineuses ou de nombreux modules activés.

### Technologies utilisées par Dolibarr

#### Langages et frameworks

* **PHP** : Dolibarr est développé en PHP natif, sans framework lourd, ce qui facilite la prise en main par les développeurs et la personnalisation.
* **JavaScript** : Utilisé pour les interactions côté client (AJAX, interfaces dynamiques).
* **HTML/CSS** : Pour la structure et le style des interfaces web.

#### Base de données

* **MySQL** ou **PostgreSQL** : Dolibarr supporte ces deux systèmes de gestion de base de données, offrant ainsi une grande flexibilité selon l’infrastructure existante.

#### Architecture

* **Application web** : Fonctionne sur un serveur web (Apache, Nginx) avec PHP.
* **Auto-installation** : Des packages sont disponibles pour Windows, Mac, Linux, Docker et Cloud, simplifiant le déploiement.

#### Intégrations et API

* Dolibarr propose une API REST pour l’intégration avec d’autres logiciels (comptabilité, e-commerce, etc.).
* Possibilité de connecter des modules tiers pour étendre les fonctionnalités.

#### Environnement de développement

* Développement collaboratif via GitHub.
* Documentation et wiki officiels pour les développeurs et utilisateurs.

### **Conclusion et perspectives**

Dolibarr s’impose comme une solution ERP/CRM open source mature, adaptée aux besoins variés des entreprises, avec une communauté active et une roadmap d’évolution régulière. Son approche modulaire, sa simplicité et son indépendance technologique en font un choix privilégié pour les organisations cherchant à maîtriser leurs coûts et leur infrastructure.

## Odoo

### Résumé détaillé d’Odoo

#### Qu’est-ce qu’Odoo ?

[Odoo](https://www.odoo.com "ERP Odoo") est une suite logicielle open source de gestion d’entreprise (ERP) et de relation client (CRM), conçue pour répondre aux besoins des entreprises de toutes tailles, des TPE aux grands groupes. Il se distingue par son approche modulaire, permettant d’activer uniquement les fonctionnalités nécessaires, et par son évolutivité, s’adaptant à la croissance et aux besoins changeants des organisations.

#### Origine et modèle économique

Développé initialement en Belgique sous le nom de TinyERP puis d’OpenERP, Odoo a été renommé en 2014. Le logiciel est disponible en deux éditions :

* **Community** : Open source, gratuite, idéale pour les utilisateurs autonomes.
* **Enterprise** : Payante (à partir de ~25 €/utilisateur/mois), avec support officiel, hébergement cloud, fonctionnalités avancées et mises à jour simplifiées.

#### Fonctionnalités principales

Odoo couvre un large éventail de besoins métiers grâce à ses applications intégrées :

* Gestion commerciale (CRM, ventes, facturation, e-commerce)
* Gestion des stocks et de la logistique
* Comptabilité et finance
* Gestion de projets et des tâches
* Ressources humaines (recrutement, congés, évaluations)
* Fabrication et gestion de la production
* Site web et CMS (création de sites vitrines ou e-commerce)
* Point de vente (POS)
* Marketing automation et emailing
* Gestion de la flotte automobile et des services sur le terrain
* Intégration avec des outils tiers via API.

#### Avantages

* **Modularité** : Activation des modules selon les besoins, sans surcharge inutile.
* **Intégration totale** : Tous les modules communiquent entre eux, assurant une circulation fluide des données.
* **Personnalisation** : Interface intuitive, constructeur glisser-déposer, et possibilité de développement sur mesure.
* **Communauté active** : Plus de 100 000 développeurs collaborent à l’évolution du logiciel.
* **Localisation** : Adapté à plus de 70 pays, avec des règles comptables et fiscales spécifiques.
* **Innovation continue** : Mises à jour annuelles, intégration de l’IA et du machine learning pour automatiser les tâches et améliorer la prise de décision.

#### Inconvénients

* La version Community nécessite des compétences techniques pour l’installation et la maintenance.
* Certains modules avancés ou spécifiques sont réservés à la version Enterprise.
* Le coût peut augmenter avec le nombre d’utilisateurs et de modules activés.

#### Adoption et marché

Odoo est utilisé par plus de 8 millions d’utilisateurs dans le monde, dans des secteurs variés (industrie, services, retail, etc.). La société Odoo S.A. connaît une forte croissance, avec une valorisation atteignant 7 milliards d’euros en 2025 et une présence internationale (États-Unis, Inde, Moyen-Orient, etc.).

### Technologies utilisées par Odoo

#### Langages et frameworks

* **Python** : Langage principal pour le développement du cœur d’Odoo, réputé pour sa sécurité et sa stabilité.
* **JavaScript** : Utilisé pour les interfaces utilisateur dynamiques (framework Owl, successeurs de Backbone.js).
* **XML** : Pour la définition des vues et des rapports.
* **HTML/CSS** : Pour la structure et le style des interfaces web.

#### Base de données

* **PostgreSQL** : Système de gestion de base de données relationnelle open source, garantissant la pérennité et l’indépendance des données.
  PostgreSQL etant le seul moteur possible, on peut exploiter toute sa puissance et fonctionnalité native.

#### Architecture

* **Application web** : Fonctionne sur un serveur web (Nginx, Apache) avec un backend Python et un frontend JavaScript.
* **Modèle MVVM** (Model-View-ViewModel) : Pour une séparation claire entre la logique métier et l’interface utilisateur.
* **API REST** : Permet l’intégration avec d’autres logiciels et services externes.

#### Environnement de développement

* **Open source** : Code source disponible sur GitHub, encourageant les contributions de la communauté.
* **Odoo Studio** : Outil intégré pour personnaliser les applications sans coder.
* **Docker** : Support pour le déploiement conteneurisé.
* **Cloud et on-premise** : Hébergement possible sur les serveurs d’Odoo ou en interne.

#### Innovations récentes (2025)

* Intégration poussée de l’**intelligence artificielle** et du **machine learning** pour l’automatisation des processus, l’analyse prédictive et l’aide à la décision.
* Amélioration de l’interface utilisateur et des performances.
* Renforcement de la sécurité et des fonctionnalités collaboratives.

### Conclusion et perspectives

Odoo s’impose comme l’un des ERP/CRM les plus complets et flexibles du marché, grâce à son modèle open source, sa modularité et son écosystème dynamique. Son adoption croissante et son évolution technologique constante en font un choix privilégié pour les entreprises cherchant une solution tout-en-un, évolutive et personnalisable.

## ErpNext

### Résumé détaillé d’ERPNext

#### Qu’est-ce qu’ERPNext ?

[ERPNext](https://frappe.io/erpnext) est un logiciel de gestion d’entreprise (ERP) 100% open source, conçu pour répondre aux besoins des PME, des grandes entreprises, des associations, des écoles et des organisations de divers secteurs (industrie, distribution, retail, services, santé, éducation, etc.). Il se distingue par sa gratuité, son absence de fonctionnalités cachées derrière des paywalls, et son approche modulaire et intégrée.

#### Origine et communauté

Développé par la société indienne Frappe Technologies, ERPNext est distribué sous licence GPL-3.0, garantissant une totale liberté d’utilisation, de modification et de redistribution. Le projet bénéficie d’une communauté active de développeurs et d’utilisateurs, ainsi que d’un réseau de partenaires certifiés pour l’implantation, la personnalisation et le support.

#### Fonctionnalités principales

ERPNext couvre l’ensemble des processus métiers grâce à ses modules intégrés :

* **Comptabilité** (grand livre, facturation, taxes, rapports financiers)
* **Ventes et CRM** (devis, commandes, pipeline commercial, gestion des contacts)
* **Achats et gestion des stocks** (bon de commande, réception, inventaire, entrepôts)
* **Fabrication** (ordonnancement, nomenclature, suivi de production)
* **Ressources humaines** (paie, recrutement, congés, évaluations)
* **Gestion de projets** (tâches, Gantt, temps passé, facturation)
* **Site web et e-commerce** (CMS, blog, boutique en ligne)
* **Point de vente (POS)**
* **Support et helpdesk**
* **Gestion des actifs**
* **Intégration avec des services tiers** (PayPal, Stripe, Shopify, Google Drive, etc.).

#### Avantages

* **Open source et gratuit** : Pas de frais de licence, code source accessible.
* **Modulaire et personnalisable** : Activation des modules selon les besoins, développement de fonctionnalités spécifiques.
* **Interface moderne et intuitive** : Tableau de bord centralisé, navigation simple, formes cohérentes entre modules.
* **Multi-entreprises, multi-devises, multi-langues** : Adapté aux groupes internationaux.
* **Conformité fiscale** : Prise en charge des réglementations de nombreux pays.
* **Hébergement flexible** : Cloud (Frappe Cloud) ou on-premise.
* **Communauté et écosystème** : Documentation complète, forums, partenaires certifiés.

#### Inconvénients

* Courbe d’apprentissage initiale pour les non-techniciens.
* Certaines fonctionnalités avancées ou intégrations tierces peuvent nécessiter l’intervention d’un partenaire ou développeur.
* Les rapports et tableaux peuvent parfois manquer de convivialité.
* Support limité en version gratuite (nécessite un abonnement pour un support prioritaire).

#### Adoption et marché

ERPNext est utilisé par des milliers d’entreprises dans le monde, dans des secteurs variés. Il est souvent choisi pour son rapport qualité-prix, sa flexibilité et son indépendance technologique. La société Frappe Technologies continue d’investir dans son développement, avec des mises à jour régulières et une roadmap ambitieuse.

### Technologies utilisées par ERPNext

#### Langages et frameworks

* **Python** : Langage principal pour le backend, via le framework **Frappe**, développé spécifiquement pour ERPNext. Frappe fournit une architecture modulaire, des outils de développement rapides et une API REST intégrée.
* **JavaScript** : Pour le frontend, avec une interface réactive et moderne.
* **HTML/CSS** : Pour la structure et le style des interfaces utilisateur.

#### Base de données

* **PostgreSQL** : à Partir de la version 14 (sortie en 2023) il est possible d'utiliser PostgreSQL en remplacement de MariaDB.
* **MariaDB** : Système de gestion de base de données relationnelle open source, optimisé pour les performances et la fiabilité.

#### Architecture

* **Application web** : Fonctionne sur un serveur web (Nginx, Apache) avec un backend Python et un frontend JavaScript.
* **Modèle MVC** (Modèle-Vue-Contrôleur) : Pour une séparation claire entre la logique métier, l’interface et les données.
* **API REST** : Permet l’intégration avec d’autres logiciels et services externes.
* **Docker** : Support pour le déploiement conteneurisé, facilitant l’installation et la mise à jour.

#### Environnement de développement

* **Open source** : Code source disponible sur GitHub, encourageant les contributions de la communauté.
* **Frappe School** : Plateforme de formation pour apprendre à développer et personnaliser ERPNext.
* **Frappe Cloud** : Solution d’hébergement managé, avec mises à jour automatiques, sauvegardes et support technique.

#### Innovations récentes (2025)

* Amélioration de l’interface utilisateur et de l’expérience mobile.
* Renforcement des fonctionnalités de fabrication et de gestion de projets.
* Développement de l’écosystème de partenaires pour des solutions sectorielles sur mesure.

### Conclusion et perspectives

ERPNext s’impose comme une solution ERP open source mature, flexible et économique, adaptée aux entreprises de toutes tailles et de tous secteurs. Son approche modulaire, sa communauté active et son indépendance technologique en font un choix de plus en plus populaire, notamment pour les organisations cherchant à éviter les coûts élevés des solutions propriétaires.

## Tryton

### Résumé détaillé de Tryton

#### Qu’est-ce que Tryton ?

[Tryton](https://www.tryton.org/ "ERP tryton") est un ERP (Enterprise Resource Planning) open source, modulaire et puissant, conçu pour les entreprises de toutes tailles et de tous secteurs (industrie, distribution, retail, services, construction, etc.). Il se distingue par son architecture trois tiers, sa flexibilité, sa sécurité et son absence de verrouillage propriétaire (no vendor lock-in).

#### Origine et gouvernance

Tryton est développé et maintenu par la Tryton Foundation, une organisation à but non lucratif basée en Allemagne. Le projet est soutenu par une communauté internationale de développeurs et d’entreprises, et son code est entièrement open source (licence GPL-3.0), garantissant transparence et indépendance.

#### Fonctionnalités principales

`Tryton` couvre l’ensemble des processus métiers grâce à ses modules intégrés et extensibles :

* **Gestion financière** (comptabilité, facturation, multi-devises, multi-sociétés)
* **Ventes et CRM** (devis, commandes, pipeline commercial, gestion des contacts)
* **Achats et gestion des stocks** (bon de commande, réception, inventaire, entrepôts)
* **Fabrication** (ordonnancement, nomenclature, suivi de production)
* **Gestion de projets** (tâches, Gantt, temps passé, facturation)
* **Ressources humaines** (paie, recrutement, congés, évaluations)
* **Analytique et reporting**
* **Intégration avec des services tiers** via API
* **Sécurité** : chiffrement TLS/HTTPS, contrôles d’accès, politiques de mots de passe, journaux d’audit.

#### Avantages

* **Open source et gratuit** : Pas de frais de licence, code source accessible et modifiable.
* **Architecture trois tiers** : Client, serveur et base de données séparés, facilitant la maintenance et l’évolutivité.
* **Modularité** : Activation des modules selon les besoins, sans surcharge inutile.
* **Multi-plateforme** : Compatible avec Linux, Windows et macOS.
* **Interfaces utilisateur** : Version desktop (GTK+) et web (SAO).
* **Communauté active** : Documentation complète, forums, partenaires certifiés pour le support et la personnalisation.
* **Sécurité et conformité** : Respect des standards industriels, auditabilité du code.

#### Inconvénients

* Courbe d’apprentissage pour les utilisateurs non techniques, notamment pour la personnalisation avancée.
* Certaines fonctionnalités ou intégrations peuvent nécessiter l’intervention d’un développeur ou d’un partenaire.

#### Adoption et marché

Tryton est utilisé par des entreprises de divers secteurs et tailles, notamment en Europe et en Amérique latine.
Il est souvent choisi pour sa flexibilité, sa sécurité et son modèle économique transparent.
La fondation et la communauté organisent régulièrement des événements et des mises à jour pour faire évoluer le logiciel.

### Technologies utilisées par Tryton

#### Langages et frameworks

* **Python** : Langage principal pour le développement du serveur et de la logique métier. Tryton utilise la librairie **python-sql**, développée par la communauté, pour écrire des requêtes SQL en Python, ce qui permet une compatibilité avec plusieurs systèmes de gestion de base de données.
* **GTK+** : Pour l’interface desktop.
* **JavaScript/HTML/CSS** : Pour l’interface web (SAO) et les interactions utilisateur.

#### Base de données

* **PostgreSQL** : Système de gestion de base de données relationnelle open source, recommandé pour ses performances et sa fiabilité. L’architecture de Tryton permet théoriquement d’utiliser d’autres SGBD, mais PostgreSQL est le plus couramment utilisé et supporté.

#### Architecture

* **Trois tiers** : Client (desktop ou web), serveur (Python), base de données (PostgreSQL). Cette séparation permet une grande flexibilité, une maintenance simplifiée et une évolutivité accrue.
* **API REST** : Pour l’intégration avec d’autres logiciels et services externes.
* **Modularité** : Chaque fonctionnalité est un module indépendant, facile à activer, désactiver ou personnaliser.

#### Environnement de développement

* **Open source** : Code source disponible sur des plateformes comme GitHub, encourageant les contributions de la communauté.
* **Outils de développement** : Utilisation de technologies libres et d’outils modernes pour le développement, le test et le déploiement.
* **Documentation** : Très complète, avec des sections dédiées à l’architecture, l’API, et chaque module métier.

#### Sécurité

* Chiffrement des données (TLS/HTTPS), contrôles d’accès granulaires, politiques de mots de passe, journaux d’audit.
* Transparence du code source, permettant des audits de sécurité indépendants.

### Conclusion et perspectives

Tryton est un ERP open source mature, sécurisé et modulaire, idéal pour les entreprises recherchant une solution flexible, indépendante et évolutive. Son architecture trois tiers, son utilisation de Python et PostgreSQL, et sa gouvernance communautaire en font un choix robuste pour une gestion d’entreprise sans verrouillage propriétaire.

## xTuple

### Résumé détaillé de xTuple

#### Qu’est-ce que xTuple ?

[xTuple](https://www.xtuple.com/solutions "ERP xTuple") est un logiciel ERP (Enterprise Resource Planning) spécialement conçu pour les entreprises de fabrication, de distribution et de gestion d’inventaire. Il se distingue par son approche open source, son coût abordable et sa capacité à répondre aux besoins des PME en croissance, ainsi que des entreprises plus grandes cherchant une solution flexible et évolutive.

#### Origine et modèle économique

Fondée en 2001 et basée à Raleigh (Caroline du Nord, États-Unis), xTuple propose une solution ERP open source, avec des options de déploiement cloud ou on-premise. Le modèle économique repose sur une version open source gratuite et des versions payantes (xTuple Essentials, xTuple Standard, xTuple Manufacturing) offrant des fonctionnalités avancées, un support professionnel et des services cloud.

#### Fonctionnalités principales

xTuple couvre l’ensemble des processus métiers grâce à ses modules intégrés :

* **Gestion de la production** (planification, ordonnancement, MRP, gestion des ateliers)
* **Gestion des stocks et entrepôts** (multi-entrepôts, suivi en temps réel, gestion des lots et numéros de série)
* **Comptabilité et finance** (grand livre, comptes clients/fournisseurs, rapports financiers)
* **Ventes et CRM** (devis, commandes, pipeline commercial, gestion des contacts)
* **Achats et gestion de la chaîne logistique**
* **Analytique et reporting** (tableaux de bord, rapports personnalisables, automatisation)
* **Gestion de projets**
* **Intégration avec des outils tiers** (via API)
* **Support multi-devises et multi-sites**.

#### Avantages

* **Open source** : Code source accessible, personnalisable, sans frais de licence pour la version de base.
* **Modularité** : Activation des modules selon les besoins, évolutivité.
* **Flexibilité de déploiement** : Cloud ou on-premise, compatible Windows, macOS, Linux.
* **Coût total de possession réduit** : L’un des plus bas du marché pour un ERP complet.
* **Support et communauté** : Documentation, formation, support technique, communauté active.
* **Adapté aux fabricants** : Support natif pour la fabrication hybride, discrète, sur commande, etc.
* **Automatisation** : Réduction des tâches manuelles, amélioration de la productivité.

#### Inconvénients

* Interface utilisateur parfois jugée peu intuitive, surtout pour les nouveaux utilisateurs.
* Courbe d’apprentissage pour la configuration et la personnalisation avancée.
* Certaines fonctionnalités avancées ou intégrations nécessitent des compétences techniques ou l’intervention d’un partenaire.

#### Adoption et marché

xTuple est particulièrement populaire auprès des PME et des entreprises de taille moyenne dans les secteurs de la fabrication et de la distribution. Il est souvent choisi pour son rapport qualité-prix, sa flexibilité et sa capacité à s’adapter aux besoins spécifiques des entreprises en croissance.

### Technologies utilisées par xTuple

#### Langages et frameworks

* **C++/Qt** : Pour le cœur de l’application et l’interface utilisateur native (Windows, macOS, Linux).
* **JavaScript/HTML/CSS** : Pour les interfaces web et les interactions utilisateur.
* **SQL** : Pour les requêtes et la gestion des données.

#### Base de données

* **PostgreSQL** : Système de gestion de base de données relationnelle open source, réputé pour sa robustesse et sa compatibilité avec les applications ERP.

#### Architecture

* **Client-serveur** : Architecture modulaire, permettant une séparation claire entre la logique métier, l’interface et la base de données.
* **API REST** : Pour l’intégration avec d’autres logiciels et services externes.
* **Cloud et on-premise** : Déploiement flexible selon les besoins de l’entreprise.

#### Environnement de développement

* **Open source** : Code source disponible, encourageant les contributions de la communauté et les personnalisations.
* **Outils de développement** : Environnements de développement modernes, documentation complète, support pour les intégrations tierces.
* **Mises à jour régulières** : Améliorations continues de l’interface, des performances et des fonctionnalités.

#### Innovations récentes (2025)

* Amélioration de l’interface utilisateur et de l’expérience mobile.
* Renforcement des outils d’analytique et de reporting (tableaux de bord, graphiques, automatisation).
* Optimisation des performances et de la sécurité, notamment pour le déploiement cloud.

### Conclusion et perspectives

`xTuple` s’impose comme une solution ERP open source mature, flexible et économique, particulièrement adaptée aux entreprises de fabrication et de distribution.
Son approche modulaire, son coût réduit et sa communauté active en font un choix privilégié pour les organisations cherchant une alternative aux ERP propriétaires,
sans sacrifier la puissance ou la personnalisation.

---

---
url: /outils.md
description: Liste d'outils pour gérer des bases de données sous PostgreSQL
---

# Outils

## Gestionnaires de base de données

| Programme | Descriptif | OS |
| --------- | ---------- | -- |
| [OmniDB](https://github.com/OmniDB/OmniDB) | Application Client et Version serveur  (Python 3.5 et Django) |![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [pgAdmin 4](http://pgadmin.org) |  | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) ||
| [pgAdmin III](http://pgadmin.org) |  (Replacer par PgAdmin 4) | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [phppgadmin](https://github.com/phppgadmin/phppgadmin) | Interface Web | |
| [RazorSQL](http://www.razorsql.com/features/postgresql_features.html) | Client JAVA Multibase | |
| [DataGrip](https://www.jetbrains.com/datagrip/) | | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [DBeaver](https://dbeaver.io/) | | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [PostgreSQL Maestro](https://www.sqlmaestro.com/products/postgresql/maestro/) | | ![Windows](/assets/windows.TQ0Bybb4.png) |
| [Database .NET](https://fishcodelib.com/Database.htm) | | ![Windows](/assets/windows.TQ0Bybb4.png) |
| [dbForge Studio](https://www.devart.com/dbforge/postgresql/studio/) | | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [Navicat for PostgreSQL](https://www.navicat.com/en/products/navicat-for-postgresql) | | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [Slashbase](https://slashbase.com/) | | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [Valentina Studio](https://www.valentina-db.com/en/studio-for-postgresql) | | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |

## Modelisation

| Programme | Descriptif | OS |
| --------- | ---------- | -- |
| [pgModeler](http://www.pgmodeler.com.br/) | | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [DbVisualizer](https://www.dbvis.com/database/postgresql/features/) | | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |

## Monitoring

| Programme | Descriptif | OS |
| --------- | ---------- | -- |
| [temBoard](https://github.com/dalibo/temboard) | PostgreSQL Remote Control | |

## Agent

| Programme | Descriptif | OS |
| --------- | ---------- | -- |
| [pg\_listen](https://github.com/begriffs/pg_listen) | Utilise Listen/Notify pour executer des commandes shell | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |
| [pgAgent](https://www.pgadmin.org/docs/pgadmin4/development/pgagent.html) | Planificateur de tâche sous PostgreSQL | ![Linux](/assets/linux.Da3JU1Id.png) ![Mac OS X](/assets/macosx.D3pOo-4c.png) ![Windows](/assets/windows.TQ0Bybb4.png) |

---

---
url: /programmation/plpgsql-date.md
description: Traitement sur les dates en PL/pgSQL
---

# Traitement sur les dates {#plpgsql\_date\_converter}

## Convertir une date Access en type date

Sous Access et historiquement Lotus 1-2-3 (Explication
[ici](https://stackoverflow.com/a/3963650)) la date est stockée sous
forme d'un entier, Dans PostgreSQL nous allons utiliser le type
interval pour retrouver le type date.

```sql
--
-- Fonction qui converti un entier en date
-- Dans Lotus 1-2-3 et Access, le jour 0 est égal au 30/12/1899
-- Auteur: Christophe CHAUVET
-- License: Creative commons BY-SA
--   https://creativecommons.org/licenses/by-sa/4.0/
--
CREATE OR REPLACE FUNCTION access_to_date(
   a_num INTEGER)
RETURNS date AS
$BODY$

BEGIN

  RETURN ('1899-12-30'::date + (a_num||' day')::interval)::date;

END;

$BODY$
LANGUAGE plpgsql;

```

Pour l'utiliser

```sql
SELECT access_to_date(42821)
-- on obtient 27/03/2017
```

## Convertir un type date en date Access

La fonction inverse, qui permet de retrouver la valeur à stocker

```sql
--
-- Fonction qui converti une date en entier
-- Dans Lotus 1-2-3 et Access, le jour 0 est égal au 30/12/1899
-- Auteur: Christophe CHAUVET
-- License: Creative commons BY-SA
--   https://creativecommons.org/licenses/by-sa/4.0/
--
CREATE OR REPLACE FUNCTION date_to_access(
   a_date DATE)
RETURNS integer AS
$BODY$

BEGIN

  RETURN (a_date - '1899-12-30'::date)::integer;

END;

$BODY$
LANGUAGE plpgsql;
```

```sql
SELECT date_to_access('2017-03-27'::date)
-- on obtient 42821
```

---

---
url: /information.md
description: >-
  Informations sur la politique de versionnement, les mises à jours et du cycle
  de vie
---

# Informations

## Politique de versionnement

Le groupe de développement mondial de **PostgreSQL** publie une nouvelle
version majeure contenant de nouvelles fonctionnalités environ une fois
par an. Chaque version majeure reçoit des correctifs de bogues et, si
nécessaire, des correctifs de sécurité qui sont publiés au moins une
fois tous les trois mois dans ce que nous appelons une « version mineure
».

Pour plus d'informations sur le calendrier des versions mineures, vous
pouvez consulter la feuille de route des versions mineures.

Si l'équipe de publication détermine qu'un bogue critique ou un
correctif de sécurité est trop important pour attendre la sortie de la
version mineure régulièrement programmée, elle peut proposer une version
en dehors de la feuille de route des versions mineures.

Le groupe de développement mondial de PostgreSQL prend en charge une
version majeure pendant 5 ans après sa sortie initiale. Après cela, une
version mineure finale sera publiée et le logiciel ne sera plus pris en
charge (fin de vie).

## Numérotation

À partir de PostgreSQL 10, une version majeure est indiquée en
augmentant la première partie du numéro de version, par exemple de 10 à
11\. Avant PostgreSQL 10, une version majeure était indiquée en
augmentant soit la première soit la deuxième partie du numéro de
version, par exemple de 9.5 à 9.6.

Les versions mineures sont numérotées en augmentant la dernière partie
du numéro de version. À partir de PostgreSQL 10, il s'agit de la
deuxième partie du numéro de version, par exemple de 10.0 à 10.1 ; pour
les versions plus anciennes, il s'agit de la troisième partie du numéro
de version, par exemple de 9.5.3 à 9.5.4.

## Mise à jour

Les versions majeures apportent des modifications complexes, de sorte
que le contenu du répertoire de données ne peut pas être conservé de
manière rétrocompatible. Un vidage/rechargement de la base de données ou
l'utilisation de l'application pg\_upgrade est nécessaire pour les
mises à niveau majeures.

Nous vous recommandons également de lire la section de mise à niveau de
la version majeure vers laquelle vous envisagez de migrer. Vous pouvez
effectuer une mise à niveau d'une version majeure vers une autre sans
effectuer de mise à niveau vers les versions intermédiaires, mais nous
vous recommandons de lire les notes de publication de toutes les
versions majeures intermédiaires avant de le faire.

Les mises à niveau de versions mineures ne nécessitent pas de vidage et
de restauration, vous arrêtez simplement le serveur de base de données,
installez les binaires mis à jour et redémarrez le serveur. De telles
mises à niveau peuvent nécessiter des étapes supplémentaires, lisez donc
toujours les notes de publication en avant toute mise à jour.

Les versions mineures ne contiennent que des correctifs pour les bogues
fréquemment rencontrés, les correctifs à faible risque, les problèmes de
sécurité et les problèmes de corruption de données.

La communauté considère que l'exécution de mises à niveau mineures est
moins risquée que de continuer à exécuter une ancienne version mineure.

::: warning Avertissement
Nous recommandons aux utilisateurs de toujours exécuter la version
mineure actuelle associée à leur version majeure.
:::

## Cycle de vie

|  Version  | Supportée | Date apparition | Fin de vie |
| :-------: | :-------: | :-------------: | :--------: |
| PostgreSQL 18  | Oui | 09/2025 | 11/2030 |
| PostgreSQL 17  | Oui | 09/2024 | 11/2029 |
| PostgreSQL 16  | Oui | 09/2023 | 11/2028 |
| PostgreSQL 15  | Oui | 10/2022 | 11/2027 |
| PostgreSQL 14  | Oui | 09/2021 | 11/2026 |
| PostgreSQL 13  | Non | 09/2020 | 11/2025 |
| PostgreSQL 12  | Non | 10/2019 | 11/2024 |
| PostgreSQL 11  | Non | 10/2017 | 11/2023 |
| PostgreSQL 10  | Non | 10/2017 | 11/2022 |
| PostgreSQL 9.6 | Non | 09/2016 | 11/2021 |
| PostgreSQL 9.5 | Non | 01/2016 | 02/2021 |
| PostgreSQL 9.4 | Non | 12/2014 | 02/2020 |
| PostgreSQL 9.3 | Non | 09/2013 | 11/2018 |
| PostgreSQL 9.2 | Non | 09/2012 | 09/2017 |
| PostgreSQL 9.1 | Non | 09/2011 | 09/2016 |
| PostgreSQL 9.0 | Non | 09/2010 | 09/2015 |
| PostgreSQL 8.4 | Non | 07/2009 | 07/2014 |
| PostgreSQL 8.3 | Non | 02/2008 | 02/2013 |
| PostgreSQL 8.2 | Non | 12/2006 | 12/2011 |
| PostgreSQL 8.1 | Non | 11/2005 | 11/2010 |
| PostgreSQL 8.0 | Non | 01/2005 | 10/2010 |
| PostgreSQL 7.4 | Non | 11/2003 | 10/2010 |
| PostgreSQL 7.3 | Non | 11/2002 | 11/2007 |
| PostgreSQL 7.2 | Non | 02/2002 | 02/2007 |
| PostgreSQL 7.1 | Non | 04/2001 | 04/2006 |
| PostgreSQL 7.0 | Non | 05/2000 | 05/2005 |
| PostgreSQL 6.5 | Non | 06/1999 | 06/2004 |
| PostgreSQL 6.4 | Non | 10/1998 | 10/2003 |
| PostgreSQL 6.3 | Non | 03/1998 | 03/2003 |

---

---
url: /programmation.md
---

# Programmation

## Ecosystème

L'ecosystème PostgreSQL dispose de nombreuses bibliothèques natives
pour s'interfacer avec une multitude de langage.

Lorsque que pour un langage, aucune interface native n'est disponible,
il est parfois possible de s'y connecter avec un driver ODBC.

* [Language C](./c.md)
* [Java](./java.md)
* [Python](./python.md)
* [PHP](./php.md)
* [PlPgSQL](./plpgsql.md)
* [PowerShell](./powershell.md)
* [Rust](./rust.md)

---

---
url: /programmation/java.md
description: Utilisation de Java pour se connecter à une base de données PostgreSQL
---

# Langage Java

## Introduction

Java est un langage de programmation **orienté objet**, **portable** et **sécurisé**,
créé en 1995 par Sun Microsystems (aujourd’hui propriété d’Oracle).

Il repose sur le principe **"Write Once, Run Anywhere"** (WORA), grâce à la **Java Virtual Machine (JVM)**,
qui permet d’exécuter du code compilé (bytecode) sur n’importe quel système d’exploitation.

Java est largement utilisé pour développer des **applications d’entreprise**, des **applications web** (avec Spring, Jakarta EE),
des **applications mobiles** (Android), et des **systèmes embarqués**. Ses principales caractéristiques incluent :

* **La syntaxe simple et structurée**, inspirée du C++ mais sans sa complexité (pas de pointeurs, gestion automatique de la mémoire via le **garbage collector**).
* **La robustesse** : gestion stricte des types, exceptions, et vérifications à la compilation/exécution.
* **La sécurité** : sandboxing, gestion des permissions, et absence de vulnérabilités liées à la gestion manuelle de la mémoire.
* **Une riche bibliothèque standard** (Java API) pour les E/S, réseaux, collections, concurrency, etc.

Java est aussi un écosystème mature avec des outils comme `Maven` ou `Gradle` (ou plus ancien comme `ANT`) pour la gestion des dépendances,
et des frameworks comme **Spring** ou **Hibernate** pour simplifier le développement.

## Connexion au base de données

Pour se connecter au base de données, Java a implémenté la spécification `JDBC` pour la conception de driver.
Plusieurs version sont apparus au fil des années suivant l'évolution du langage.

### Résumé des versions de JDBC

| Version | Année | Java SE | Principales nouveautés |
|:-------:|:-----:|:-------:|------------------------|
| **JDBC 1.0** | 1997 | JDK 1.1 | Première version, API de base pour la connexion aux bases de données, `DriverManager`, `Connection`, `Statement`, `ResultSet`. |
| **JDBC 2.0** | 1999 | JDK 1.2/1.3 | Ajout des **ResultSet scrollables** (navigation bidirectionnelle), **ResultSet updatable**, **Batch Updates**, et introduction de l’API `javax.sql` (DataSource, Connection Pooling, RowSet). |
| **JDBC 3.0** | 2002 | JDK 1.4 | **Savepoints** (pour les transactions imbriquées), amélioration des `PreparedStatement`, support des **BLOB/CLOB**, et métadonnées étendues. |
| **JDBC 4.0** | 2006 | Java SE 6 | **Auto-loading des pilotes** (plus besoin de `Class.forName`), support des **SQL XML**, amélioration des `RowSet`, et intégration avec Java EE. |
| **JDBC 4.1** | 2011 | Java SE 7 | Support des **try-with-resources** (AutoCloseable), amélioration des `RowSet`, et gestion simplifiée des exceptions. |
| **JDBC 4.2** | 2014 | Java SE 8 | Support des **REF\_CURSOR** (Oracle), amélioration des `RowSet`, et compatibilité avec les nouvelles fonctionnalités de Java 8 (comme les streams pour `ResultSet`). |
| **JDBC 4.3** | 2017 | Java SE 9 | Support des **nouvelles API de date/heure** (`java.time`), méthodes `getObject` avec mapping automatique vers les types Java 8, et amélioration de la gestion des shards (bases de données partitionnées). |
| **JDBC 4.4** | 2021 | Java SE 17 (LTS) | Support des **SQL:2016**, amélioration des **mappages de types**, et optimisations pour les applications cloud/natives. |

### Points clés à retenir

* **JDBC 4.0** a marqué un tournant avec l’auto-chargement des pilotes et une meilleure intégration avec Java SE.
* **JDBC 4.2/4.3** ont apporté des améliorations pour les applications modernes, notamment avec Java 8 et les API de date/heure.
* **JDBC 4.4** est la version la plus récente (inclus dans Java 17+), avec un focus sur la compatibilité avec les bases de données cloud et les standards SQL récents.

## JDBC et PostgreSQL

Pour se connecter à `PostgreSQL` en Java nous utiliseront le driver
[JDBC](https://fr.wikipedia.org/wiki/Java_Database_Connectivity) qui
fournit une interface de programmation standard, et est developpé par la communauté PostgreSQL.

* [driver JDBC pour PostgreSQL](https://jdbc.postgresql.org/download/)

:::: warning
Il faut sélectionner le driver [JDBC](https://fr.wikipedia.org/wiki/Java_Database_Connectivity)
qui correspond a votre version de PostgreSQL mais aussi à votre version de Java.
::::

## Configuration de la connexion à PostgreSQL en Java

Pour interagir avec PostgreSQL, utilisez le **pilote JDBC** officiel.

### Déclarer la dépendance

#### Avec Maven (`pom.xml`)

```xml
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.6.0</version> <!-- Vérifiez la dernière version -->
</dependency>
```

#### Avec Gradle (`build.gradle`)

```groovy
dependencies {
    implementation 'org.postgresql:postgresql:42.6.0'
}
```

## Exemple de code Java pour se connecter et exécuter des requêtes

### Connexion à la base de données

```java
import java.sql.*;

public class PostgreSQLExample {
    private static final String URL = "jdbc:postgresql://localhost:5432/nom_de_la_base";
    private static final String USER = "utilisateur";
    private static final String PASSWORD = "mot_de_passe";

    public static void main(String[] args) {
        try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
            System.out.println("Connexion réussie à PostgreSQL!");

            // Exemple de requête SELECT
            String sql = "SELECT * FROM clients";
            try (Statement stmt = conn.createStatement();
                 ResultSet rs = stmt.executeQuery(sql)) {

                while (rs.next()) {
                    System.out.println("ID: " + rs.getInt("id") +
                                       ", Nom: " + rs.getString("nom"));
                }
            }

            // Exemple de requête INSERT
            String insertSql = "INSERT INTO clients (nom, email) VALUES (?, ?)";
            try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
                pstmt.setString(1, "Dupont");
                pstmt.setString(2, "dupont@example.com");
                pstmt.executeUpdate();
                System.out.println("Nouveau client ajouté!");
            }

        } catch (SQLException e) {
            System.err.println("Erreur de connexion: " + e.getMessage());
        }
    }
}
```

## Bonnes pratiques

* **Gestion des ressources**: Utilisez `try-with-resources` pour fermer automatiquement les connexions, statements et resultsets.
* **Requêtes préparées**: Préférez `PreparedStatement` pour éviter les injections SQL.
* **Pool de connexions**: Pour les applications web, utilisez un pool de connexions comme **HikariCP** (intégré à Spring Boot par défaut).

## Pool de connexion (HikariCP)

**HikariCP** est un **pool de connexions JDBC** ultra-rapide, léger et conçu pour les applications Java modernes.
Il est devenu le standard de facto pour la gestion des connexions à une base de données, notamment avec **PostgreSQL**,
grâce à sa performance, sa simplicité et sa fiabilité.

### Pourquoi utiliser HikariCP ?

* **Performance** : HikariCP est jusqu’à **10 fois plus rapide** que d’autres pools comme Apache DBCP ou C3P0.
* **Léger** : Moins de 130 Ko, sans dépendances lourdes.
* **Optimisé pour la production** : Gestion intelligente des connexions, des timeouts, et des fuites de mémoire.
* **Intégré par défaut** dans Spring Boot, Quarkus, et d’autres frameworks modernes.

### Ajouter la dépendance

#### Avec Maven (`pom.xml`)

```xml
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version> <!-- Vérifiez la dernière version -->
</dependency>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.6.0</version> <!-- Pilote JDBC pour PostgreSQL -->
</dependency>
```

#### Avec Gradle (`build.gradle`)

```groovy
implementation 'com.zaxxer:HikariCP:5.0.1'
implementation 'org.postgresql:postgresql:42.6.0'
```

### Code Java

```java
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class PostgreSQLPoolExample {
    public static void main(String[] args) {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost:5432/nom_de_la_base");
        config.setUsername("utilisateur");
        config.setPassword("mot_de_passe");
        config.setMaximumPoolSize(10);

        try (HikariDataSource ds = new HikariDataSource(config);
             Connection conn = ds.getConnection()) {

            // Utilisez la connexion comme avant
            String sql = "SELECT * FROM clients";
            try (Statement stmt = conn.createStatement();
                 ResultSet rs = stmt.executeQuery(sql)) {
                while (rs.next()) {
                    System.out.println("ID: " + rs.getInt("id"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
```

### Bonnes pratiques avec HikariCP

* **Taille du pool** :
  * `maximumPoolSize` : Dépend de votre charge. Pour la plupart des applications, **10 à 20** connexions suffisent.
  * Évitez de surdimensionner le pool (risque de surcharge du serveur PostgreSQL).
* **Timeouts** :
  * `connectionTimeout` : Temps max pour obtenir une connexion (évite les attentes infinies).
  * `maxLifetime` : Limite la durée de vie d’une connexion pour éviter les problèmes de stagnation.
* **Validation des connexions** :
  * Activez `connectionTestQuery` pour vérifier la validité des connexions avant utilisation :
    ```java
    config.setConnectionTestQuery("SELECT 1");
    ```
* **Journalisation** :
  * HikariCP fournit des métriques détaillées (nombre de connexions actives, temps d’attente, etc.). Activez les logs pour le débogage :
    ```java
    config.setLeakDetectionThreshold(60000); // Détection des fuites après 60s
    ```

### Avantages spécifiques avec PostgreSQL

* **Compatibilité totale** : HikariCP fonctionne parfaitement avec le pilote JDBC de PostgreSQL.
* **Gestion des transactions** : Intègre naturellement avec les transactions JDBC et les frameworks comme Spring Transaction.
* **Support des fonctionnalités avancées** : Comme les `PreparedStatement` en cache, les requêtes batch, et les types de données spécifiques à PostgreSQL (JSONB, UUID, etc.).

### Résumé des paramètres clés

| Paramètre | Description | Valeur recommandée |
|:----------|-------------|:-----------------:|
| `maximumPoolSize` | Nombre max de connexions | 10-20 |
| `minimumIdle` | Nombre min de connexions inactives | 5 |
| `idleTimeout` | Temps max d’inactivité (ms) | 30000 |
| `connectionTimeout` | Timeout pour obtenir une connexion (ms) | 30000 |
| `maxLifetime` | Durée de vie max d’une connexion (ms) | 1800000 (30 min) |
| `connectionTestQuery` | Requête de validation | `SELECT 1` |

### Configuration avec Spring Boot

Si vous utilisez **Spring Boot**, HikariCP est le pool par défaut. Il suffit de configurer `application.properties` :

```properties
# PostgreSQL
spring.datasource.url=jdbc:postgresql://localhost:5432/ma_base
spring.datasource.username=utilisateur
spring.datasource.password=mot_de_passe
spring.datasource.driver-class-name=org.postgresql.Driver

# HikariCP (paramètres optionnels)
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.max-lifetime=1800000
```

### Quand utiliser HikariCP ?

* **Applications web** (Spring Boot, Jakarta EE, Micronaut, Quarkus).
* **Microservices** nécessitant des connexions rapides et fiables.
* **Environnements cloud** où la latence et la scalabilité sont critiques.

## Intégration avec Spring Boot

Si vous utilisez **Spring Boot**, la configuration est simplifiée via `application.properties`:

```properties
spring.datasource.url=jdbc:postgresql://localhost:5432/nom_de_la_base
spring.datasource.username=utilisateur
spring.datasource.password=mot_de_passe
spring.datasource.driver-class-name=org.postgresql.Driver
```

Spring Boot gère automatiquement le pool de connexions avec HikariCP.

## Résumé des étapes clés

| Étape | Action |
|:-----:|:-------|
| **1** | Ajouter la dépendance PostgreSQL (Maven/Gradle) |
| **2** | Charger le pilote JDBC et établir la connexion |
| **3** | Exécuter des requêtes (SELECT, INSERT, UPDATE, DELETE) |
| **4** | Utiliser des requêtes préparées pour la sécurité |
| **5** | Gérer les ressources avec `try-with-resources` |
| **6** | (Optionnel) Configurer un pool de connexions (HikariCP) |

---

---
url: /programmation/php.md
description: Etablissement d'une connexion à PostgreSQL en PHP et le driver PDO PgSQL
---

# Langage PHP

## Bibliothèques

* [Librairie officiel
  native](https://www.php.net/manual/fr/book.pgsql.php)
* [Librairie PDO](https://php.net/manual/fr/book.pdo.php)

## Gestionnaire de modèle

* [POMM](https://github.com/chanmix51/Pomm)

## Configuration

Pour activer l'extension PDO pour PostgreSQL, il faut editer le fichier php.ini, trouver la ligne ci-dessous

```ini
extension=php_pdo_pgsql.dll
```

enlever le **;** qui est un commentaire pour activer l'extension.

Une fois l'extension activée (vérifiable avec un **phpinfo()** ), nous pouvons commencer à utiliser PostgreSQL avec PHP et PDO

## Pourquoi utiliser PDO avec PostgreSQL ?

PDO (PHP Data Objects) est une extension PHP qui offre une interface unifiée pour interagir avec différentes bases de données, dont PostgreSQL. Ses avantages :

* **Sécurité** : Protection contre les injections SQL via les requêtes préparées.
* **Portabilité** : Code facilement adaptable à d’autres SGBD (MySQL, SQLite, etc.).
* **Performance** : Gestion optimisée des connexions et des requêtes.

### Prérequis

* Un serveur web avec PHP (version 7.4 ou supérieure recommandée).
* L’extension PDO et le driver PDO\_PGSQL activés dans `php.ini` :
  ```ini
  extension=pdo
  extension=pdo_pgsql
  ```
* Un serveur PostgreSQL accessible (local ou distant).

## Connexion à PostgreSQL avec PDO

### Exemple de connexion

```php
<?php
// Paramètres de connexion
$host = 'localhost';      // Adresse du serveur PostgreSQL
$dbname = 'nom_base';     // Nom de la base de données
$user = 'utilisateur';    // Nom d'utilisateur
$password = 'motdepasse'; // Mot de passe

try {
    // Chaîne de connexion PDO
    $dsn = "pgsql:host=$host;dbname=$dbname;port=5432";

    // Création de la connexion
    $pdo = new PDO($dsn, $user, $password);

    // Configuration pour afficher les erreurs PDO
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    echo "Connexion à PostgreSQL réussie !";
} catch (PDOException $e) {
    // Gestion des erreurs
    die("Erreur de connexion : " . $e->getMessage());
}
?>
```

## Exécution de requêtes

### Requête simple (SELECT)

```php
try {
    $sql = "SELECT * FROM clients WHERE age > :age";
    $stmt = $pdo->prepare($sql);

    // Liaison des paramètres
    $age_min = 18;
    $stmt->bindParam(':age', $age_min, PDO::PARAM_INT);

    // Exécution
    $stmt->execute();

    // Récupération des résultats
    $clients = $stmt->fetchAll(PDO::FETCH_ASSOC);

    // Affichage
    foreach ($clients as $client) {
        echo "Nom : " . $client['nom'] . ", Âge : " . $client['age'] . "<br>";
    }
} catch (PDOException $e) {
    echo "Erreur : " . $e->getMessage();
}
```

### Insertion de données (INSERT)

```php
try {
    $sql = "INSERT INTO clients (nom, email, age) VALUES (:nom, :email, :age)";
    $stmt = $pdo->prepare($sql);

    // Données à insérer
    $nom = "Dupont";
    $email = "dupont@example.com";
    $age = 30;

    // Liaison des paramètres
    $stmt->bindParam(':nom', $nom);
    $stmt->bindParam(':email', $email);
    $stmt->bindParam(':age', $age);

    // Exécution
    $stmt->execute();

    echo "Client ajouté avec succès !";
} catch (PDOException $e) {
    echo "Erreur : " . $e->getMessage();
}
```

### Mise à jour (UPDATE)

```php
try {
    $sql = "UPDATE clients SET email = :email WHERE id = :id";
    $stmt = $pdo->prepare($sql);

    // Données à mettre à jour
    $id = 1;
    $nouvel_email = "nouvel_email@example.com";

    // Liaison des paramètres
    $stmt->bindParam(':id', $id, PDO::PARAM_INT);
    $stmt->bindParam(':email', $nouvel_email);

    // Exécution
    $stmt->execute();

    echo "Email mis à jour !";
} catch (PDOException $e) {
    echo "Erreur : " . $e->getMessage();
}
```

### Suppression (DELETE)

```php
try {
    $sql = "DELETE FROM clients WHERE id = :id";
    $stmt = $pdo->prepare($sql);

    // ID du client à supprimer
    $id = 1;
    $stmt->bindParam(':id', $id, PDO::PARAM_INT);

    // Exécution
    $stmt->execute();

    echo "Client supprimé !";
} catch (PDOException $e) {
    echo "Erreur : " . $e->getMessage();
}
```

## Transactions

Les transactions permettent de regrouper plusieurs requêtes en un bloc atomique (tout est exécuté ou rien).

```php
try {
    $pdo->beginTransaction();

    // Exemple : Transfert d'argent entre deux comptes
    $sql1 = "UPDATE comptes SET solde = solde - 100 WHERE id = 1";
    $sql2 = "UPDATE comptes SET solde = solde + 100 WHERE id = 2";

    $pdo->exec($sql1);
    $pdo->exec($sql2);

    // Validation de la transaction
    $pdo->commit();
    echo "Transaction effectuée avec succès !";
} catch (PDOException $e) {
    // Annulation en cas d'erreur
    $pdo->rollBack();
    echo "Erreur : " . $e->getMessage();
}
```

## Bonnes pratiques

* **Toujours utiliser des requêtes préparées** pour éviter les injections SQL.
* **Gérer les erreurs** avec des blocs `try/catch`.
* **Fermer les connexions** : PDO ferme automatiquement la connexion à la fin du script, mais vous pouvez forcer la fermeture avec `$pdo = null;`.
* **Utiliser des transactions** pour les opérations critiques.

## Ressources utiles

* [Documentation officielle PDO](https://www.php.net/manual/fr/book.pdo.php)
* [PostgreSQL + PHP : Guide complet](https://www.postgresql.org/docs/current/libpq-connect.html)

---

---
url: /programmation/python.md
description: Programmation en langage python avec diverses bibliothèques
---

# Langage Python {#langage\_python}

## Pourquoi utiliser Python avec PostgreSQL ?

Python est un langage populaire pour interagir avec PostgreSQL grâce à sa simplicité et à ses bibliothèques dédiées. Les principales bibliothèques sont :

* **psycopg2** : La plus utilisée, stable et mature.
* **psycopg3** : Nouvelle version, plus rapide et moderne.
* **asyncpg** : Pour les applications asynchrones (avec `async/await`).

## Installation des bibliothèques

```bash
pip install psycopg2-binary  # psycopg2 (version binaire pour simplifier l'installation)
pip install psycopg          # psycopg3
pip install asyncpg          # asyncpg
```

::: tip
Depuis quelques temps il n'est plus necessaire de préciser binary dans l'installation de psycopg2
:::

## Utilisation de psycopg2

### Connexion à la base de données

```python
import psycopg2

# Paramètres de connexion
conn_params = {
    "host": "localhost",
    "database": "nom_base",
    "user": "utilisateur",
    "password": "motdepasse",
    "port": "5432"
}

try:
    # Établir la connexion
    conn = psycopg2.connect(**conn_params)
    print("Connexion réussie à PostgreSQL !")

    # Créer un curseur
    cur = conn.cursor()

    # Exemple de requête
    cur.execute("SELECT version();")
    version = cur.fetchone()
    print("Version de PostgreSQL :", version)

except psycopg2.Error as e:
    print("Erreur de connexion :", e)

finally:
    # Fermer le curseur et la connexion
    if 'cur' in locals():
        cur.close()
    if 'conn' in locals():
        conn.close()
```

### Requêtes paramétrées (éviter les injections SQL)

```python
def ajouter_client(nom, email, age):
    try:
        conn = psycopg2.connect(**conn_params)
        cur = conn.cursor()

        # Requête paramétrée
        query = "INSERT INTO clients (nom, email, age) VALUES (%s, %s, %s) RETURNING id;"
        cur.execute(query, (nom, email, age))

        # Récupérer l'ID du client inséré
        client_id = cur.fetchone()[0]
        conn.commit()
        print(f"Client ajouté avec l'ID : {client_id}")

    except psycopg2.Error as e:
        conn.rollback()
        print("Erreur :", e)
    finally:
        if 'cur' in locals():
            cur.close()
        if 'conn' in locals():
            conn.close()

ajouter_client("Dupont", "dupont@example.com", 30)
```

### Récupération de données

```python
def lister_clients():
    try:
        conn = psycopg2.connect(**conn_params)
        cur = conn.cursor()

        cur.execute("SELECT id, nom, email FROM clients;")
        clients = cur.fetchall()

        for client in clients:
            print(f"ID: {client[0]}, Nom: {client[1]}, Email: {client[2]}")

    except psycopg2.Error as e:
        print("Erreur :", e)
    finally:
        if 'cur' in locals():
            cur.close()
        if 'conn' in locals():
            conn.close()

lister_clients()
```

## Utilisation de psycopg3

**psycopg3** est une réécriture moderne de psycopg2, plus rapide et avec une API plus intuitive.

### Connexion et requête simple

```python
import psycopg

conn_params = "host=localhost dbname=nom_base user=utilisateur password=motdepasse"

try:
    # Connexion et création d'un curseur
    with psycopg.connect(conn_params) as conn:
        with conn.cursor() as cur:
            cur.execute("SELECT version();")
            version = cur.fetchone()
            print("Version de PostgreSQL :", version)

except psycopg.Error as e:
    print("Erreur :", e)
```

### Requête paramétrée et transaction

```python
def ajouter_client_psycopg3(nom, email, age):
    try:
        with psycopg.connect(conn_params) as conn:
            with conn.cursor() as cur:
                query = "INSERT INTO clients (nom, email, age) VALUES (%s, %s, %s) RETURNING id;"
                cur.execute(query, (nom, email, age))
                client_id = cur.fetchone()[0]
                conn.commit()
                print(f"Client ajouté avec l'ID : {client_id}")

    except psycopg.Error as e:
        print("Erreur :", e)

ajouter_client_psycopg3("Martin", "martin@example.com", 25)
```

## Utilisation de asyncpg (asynchrone)

**asyncpg** est conçu pour les applications asynchrones, utilisant `async/await`.

### Connexion et requête asynchrone

```python
import asyncio
import asyncpg

async def test_connexion():
    conn_params = {
        "host": "localhost",
        "database": "nom_base",
        "user": "utilisateur",
        "password": "motdepasse",
        "port": "5432"
    }

    try:
        # Connexion asynchrone
        conn = await asyncpg.connect(**conn_params)
        print("Connexion asynchrone réussie !")

        # Exécution d'une requête
        version = await conn.fetchval("SELECT version();")
        print("Version de PostgreSQL :", version)

    except asyncpg.PostgresError as e:
        print("Erreur :", e)
    finally:
        if 'conn' in locals():
            await conn.close()

# Exécuter la fonction asynchrone
asyncio.run(test_connexion())
```

### Insertion asynchrone

```python
async def ajouter_client_async(nom, email, age):
    conn_params = {
        "host": "localhost",
        "database": "nom_base",
        "user": "utilisateur",
        "password": "motdepasse",
        "port": "5432"
    }

    try:
        conn = await asyncpg.connect(**conn_params)
        query = "INSERT INTO clients (nom, email, age) VALUES ($1, $2, $3) RETURNING id;"
        client_id = await conn.fetchval(query, nom, email, age)
        print(f"Client ajouté avec l'ID : {client_id}")

    except asyncpg.PostgresError as e:
        print("Erreur :", e)
    finally:
        if 'conn' in locals():
            await conn.close()

# Exécuter
asyncio.run(ajouter_client_async("Bernard", "bernard@example.com", 40))
```

### Récupération asynchrone de données

```python
async def lister_clients_async():
    conn_params = {
        "host": "localhost",
        "database": "nom_base",
        "user": "utilisateur",
        "password": "motdepasse",
        "port": "5432"
    }

    try:
        conn = await asyncpg.connect(**conn_params)
        clients = await conn.fetch("SELECT id, nom, email FROM clients;")

        for client in clients:
            print(f"ID: {client['id']}, Nom: {client['nom']}, Email: {client['email']}")

    except asyncpg.PostgresError as e:
        print("Erreur :", e)
    finally:
        if 'conn' in locals():
            await conn.close()

# Exécuter
asyncio.run(lister_clients_async())
```

## Comparatif des bibliothèques

| Fonctionnalité          | psycopg2               | psycopg3               | asyncpg                |
|-------------------------|------------------------|------------------------|------------------------|
| **Type**                | Synchrone              | Synchrone              | Asynchrone             |
| **Performance**         | Bonne                  | Meilleure              | Excellente (async)     |
| **API**                 | Classique              | Moderne                | Asynchrone             |
| **Transactions**        | Oui                    | Oui                    | Oui                    |
| **Requêtes paramétrées**| Oui (`%s`)             | Oui (`%s`)             | Oui (`$1`, `$2`)       |
| **Pool de connexions**  | Non (nécessite un module externe) | Oui (intégré) | Oui (intégré) |

## Bonnes pratiques

* **Toujours utiliser des requêtes paramétrées** pour éviter les injections SQL.
* **Gérer les exceptions** pour éviter les plantages silencieux.
* **Fermer les connexions** après utilisation (ou utiliser `with` pour psycopg3).
* **Pour les applications web asynchrones**, privilégier `asyncpg`.
* **Pour les scripts synchrones**, `psycopg3` est un excellent choix moderne.

## Ressources utiles

* [Documentation psycopg2](https://www.psycopg.org/docs/)
* [Documentation psycopg3](https://www.psycopg.org/psycopg3/docs/)
* [Documentation asyncpg](https://magic.io/blog/asyncpg-1m-row/)

---

---
url: /programmation/plpgsql.md
description: Programmation en langage procédural avec PLpgSQL
---

# Langage PLpgSQL {#langage\_plpgsql}

[PL/pgSQL](https://docs.postgresql.fr/17/plpgsql.html) (Procedural
Language/PostgreSQL) est un langage de programmation procédural pris en
charge par le SGBDR **PostgreSQL**.

Il ressemble beaucoup au langage PL/SQL d'Oracle. Implémenté par Jan
Wieck, PL/pgSQL est apparu pour la première fois avec PostgreSQL 6.4,
publié le 30 octobre 1998.

La version 9 implémente également certaines fonctionnalités ISO SQL/PSM,
comme la surcharge des fonctions et procédures invoquées par SQL.

PL/pgSQL, en tant que langage de programmation complet, permet un
contrôle procédural beaucoup plus important que SQL, y compris la
possibilité d'utiliser des boucles et d'autres structures de contrôle.

Les instructions et déclencheurs SQL peuvent appeler des fonctions
créées dans le langage [PL/pgSQL](https://docs.postgresql.fr/17/plpgsql.html).

La conception de [PL/pgSQL](https://docs.postgresql.fr/17/plpgsql.html)
visait à permettre aux utilisateurs de PostgreSQL d'effectuer des
opérations et des calculs plus complexes que SQL, tout en offrant une
facilité d'utilisation.

Le langage peut être défini comme approuvé par le serveur.

[PL/pgSQL](https://docs.postgresql.fr/17/plpgsql.html) est l'un des
langages de programmation inclus dans la distribution standard de
PostgreSQL, les autres étant PL/Tcl, PL/Perl et PL/Python. De plus, de
nombreux autres sont disponibles auprès de tiers, notamment PL/Java,
PL/pgPSM, PL/php, PL/R, PL/Ruby, PL/sh, PL/Lua, Postmodern (basé sur
Common Lisp) et PL/v8.

PostgreSQL utilise Bison comme analyseur, ce qui facilite le portage de
nombreux langages open source, ainsi que la réutilisation du code.

## Avantages

* **Performance** : Réduction des allers-retours entre l’application et la base.
* **Modularité** : Encapsulation de la logique métier dans la base.
* **Sécurité** : Contrôle fin des droits d’accès.

## Structure de base d’un bloc PL/pgSQL

Un bloc PL/pgSQL est délimité par des mots-clés et peut contenir des déclarations, des instructions, et des exceptions.

```sql
[ <<étiquette>> ]
DECLARE
    -- Déclarations des variables, curseurs, etc.
BEGIN
    -- Instructions SQL et PL/pgSQL
EXCEPTION
    -- Gestion des erreurs
END;
```

## Déclarations

### Variables

Les variables sont déclarées dans la section `DECLARE` et peuvent être de n’importe quel type PostgreSQL.

```sql
DECLARE
    ma_variable INTEGER;
    mon_texte TEXT := 'Bonjour';
    mon_tableau INTEGER[] := '{1, 2, 3}';
    ma_date DATE := CURRENT_DATE;
```

### Constantes

Utilisez `CONSTANT` pour déclarer une constante.

```sql
DECLARE
    PI CONSTANT NUMERIC := 3.14159;
```

### C. Alias de type

Vous pouvez utiliser `%TYPE` pour déclarer une variable du même type qu’une colonne de table.

```sql
DECLARE
    nom_client clients.nom%TYPE;
```

## Expressions et instructions de base

### Affectation

L’affectation se fait avec `:=` ou `SELECT INTO`.

```sql
ma_variable := 42;
SELECT COUNT(*) INTO nombre_clients FROM clients;
```

### Instructions SQL

Toute instruction SQL valide peut être utilisée dans un bloc PL/pgSQL.

```sql
INSERT INTO clients (nom, email) VALUES ('Dupont', 'dupont@example.com');
UPDATE clients SET email = 'nouvel@example.com' WHERE id = 1;
DELETE FROM clients WHERE id = 1;
```

### Appel de fonction

```sql
resultat := ma_fonction(param1, param2);
```

## Structures de contrôle

### Conditionnelles (`IF/ELSE`)

```sql
IF condition THEN
    -- instructions
ELSIF autre_condition THEN
    -- instructions
ELSE
    -- instructions
END IF;
```

**Exemple :**

```sql
IF age >= 18 THEN
    statut := 'majeur';
ELSE
    statut := 'mineur';
END IF;
```

### Boucles (`LOOP`, `WHILE`, `FOR`)

#### `LOOP` (boucle infinie avec sortie conditionnelle)

```sql
LOOP
    -- instructions
    EXIT WHEN condition;
END LOOP;
```

#### `WHILE`

```sql
WHILE condition LOOP
    -- instructions
END LOOP;
```

#### `FOR` (itération sur un ensemble de résultats)

```sql
FOR ma_variable IN SELECT * FROM clients LOOP
    -- instructions
END LOOP;
```

**Exemple :**

```sql
FOR client IN SELECT * FROM clients WHERE age > 18 LOOP
    RAISE NOTICE 'Client majeur : %', client.nom;
END LOOP;
```

## Curseurs

Les curseurs permettent de parcourir les résultats d’une requête ligne par ligne.

### Déclaration et utilisation

```sql
DECLARE
    mon_curseur CURSOR FOR SELECT * FROM clients;
    client_record clients%ROWTYPE;
BEGIN
    OPEN mon_curseur;
    LOOP
        FETCH mon_curseur INTO client_record;
        EXIT WHEN NOT FOUND;
        -- Traitement de la ligne
        RAISE NOTICE 'Client : %', client_record.nom;
    END LOOP;
    CLOSE mon_curseur;
END;
```

### Curseurs avec paramètres

```sql
DECLARE
    mon_curseur CURSOR(age_min INTEGER) FOR
        SELECT * FROM clients WHERE age > age_min;
BEGIN
    OPEN mon_curseur(18);
    -- ...
END;
```

## Gestion des erreurs et messages

### Gestion des exceptions (`EXCEPTION`)

```sql
BEGIN
    -- instructions
EXCEPTION
    WHEN division_by_zero THEN
        RAISE NOTICE 'Division par zéro !';
    WHEN OTHERS THEN
        RAISE EXCEPTION 'Erreur inattendue : %', SQLERRM;
END;
```

### Messages (`RAISE`)

* `RAISE NOTICE` : Message informatif.
* `RAISE WARNING` : Avertissement.
* `RAISE EXCEPTION` : Erreur fatale.

**Exemple :**

```sql
RAISE NOTICE 'Le client % est majeur', nom_client;
RAISE EXCEPTION 'Le client % n''existe pas', id_client;
```

## Exemple complet : Fonction PL/pgSQL

```sql
CREATE OR REPLACE FUNCTION calculer_solde_moyen()
RETURNS NUMERIC AS $$
DECLARE
    total NUMERIC;
    nombre_clients INTEGER;
    moyenne NUMERIC;
BEGIN
    SELECT SUM(solde), COUNT(*) INTO total, nombre_clients FROM comptes;
    IF nombre_clients = 0 THEN
        RAISE EXCEPTION 'Aucun client trouvé !';
    END IF;
    moyenne := total / nombre_clients;
    RETURN moyenne;
EXCEPTION
    WHEN OTHERS THEN
        RAISE EXCEPTION 'Erreur : %', SQLERRM;
END;
$$ LANGUAGE plpgsql;
```

## Bonnes pratiques

* **Commenter votre code** pour faciliter la maintenance.
* **Utiliser des transactions** pour les opérations critiques.
* **Limiter l’utilisation de `OTHERS`** dans les blocs `EXCEPTION` pour éviter de masquer des erreurs.
* **Préférer les curseurs** pour les traitements lourds sur de grands jeux de données.

## Ressources utiles

* [Documentation officielle PL/pgSQL](https://www.postgresql.org/docs/current/plpgsql.html)
* [Tutoriel PL/pgSQL en anglais](https://www.postgresqltutorial.com/plpgsql/)

## Exemples de fonctions PL/pgSQL pour traitement

* [Dates](./plpgsql-date.md) Traitement sur les dates

---

---
url: /programmation/c.md
description: Programmation PostgreSQL avec le langage C en utilisant la libpq et ecpg
---

# Langage C {#langage\_c}

PostgreSQL étant écrit en **C**, il existe par conséquent une bibliothèque native qui se nomme
[libpq](https://docs.postgresql.fr/current/libpq.html)

## Bibliothèque libpq {#language\_c\_libpq}

La bibliothèque pour le language C se nomme
[libpq](https://docs.postgresql.fr/current/libpq.html) .

D'autres langages de programmation on également leur bibliothèque mais
les principales s'appuie sur la libpq via des wrappers

Pour commencer à travailler avec libpq dans votre programme C, vous
devez importer les bibliothèques nécessaires.

Ouvrez votre fichier de programme C et incluez les bibliothèques
suivantes en haut du fichier

```C
#include <stdio.h>
#include <stdlib.h>
#include <libpq-fe.h>
```

### Etablir une connexion

Pour établir une connexion à la base de données PostgreSQL à l'aide de
libpq, nous utiliserons la fonction PQconnectdb().

Cette fonction ouvre une nouvelle connexion à la base de données en
fonction des paramètres fournis dans la chaîne **conninfo**.

La chaîne **conninfo** contient un ou plusieurs paramètres au format
**keyword=value**, séparés par des espaces. Vous pouvez utiliser des
paramètres par défaut en transmettant une chaîne vide ou spécifier des
paramètres personnalisés selon vos besoins.

Pour inclure une valeur nulle ou une valeur avec des espaces, placez-la
entre guillemets simples (keyword='value'). Si nécessaire, échappez
les guillemets simples dans la valeur à l'aide d'une barre oblique
inverse ('). Les espaces autour du signe égal sont facultatifs.

Il est important de noter que la fonction PQconnectdb() renvoie toujours
un pointeur d'objet PGconn non nul, sauf si la mémoire est insuffisante
pour allouer l'objet.

Pendant le processus de connexion, vous pouvez vérifier l'état de la
connexion à l'aide de la fonction PQstatus().

Si l'état est **CONNECTION\_BAD**, la procédure de connexion a échoué.

A l'inverse, si le statut est **CONNECTION\_OK**, la connexion est prête.

Pour fermer correctement la connexion et libérer la mémoire utilisée par
l'objet PGconn, appelez la fonction [PQfinish()](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PQFINISH).

Même si la tentative de connexion au backend échoue (comme indiqué par
PQstatus), il est essentiel d'appeler [PQfinish()](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PQFINISH)
pour libérer la mémoire allouée. Après avoir appelé [PQfinish()](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PQFINISH),
le pointeur **PGconn** ne doit plus être utilisé.

Ci-dessous un exemple de programme qui se connect au serveur de base de
données, et affiche les informations de connexions

```c
#include <stdio.h>
#include <stdlib.h>
#include <libpq-fe.h>

int main(int argc, char *argv[]) {
   printf("Tuto utilisation de la libpq \n");

   // Connexion à la base de données
   // la chaine conninfo contient les mots clés et les valeurs séparés par des espaces.
   char *conninfo = "dbname=votre_nom_db user=utilisateur password=mot_de_passe host=localhost port=5432";

   // Creation de la connexion
   PGconn *conn = PQconnectdb(conninfo);

   // Vérification si la connexion s'est faite correctement
   if (PQstatus(conn) != CONNECTION_OK) {
      // Si echec de connxion, nous imprimons les messages d'erreur et liberont les ressources
      printf("Erreur lors de la connexion au serveur de base de données: %s\n", PQerrorMessage(conn));

      // On ferme la connexion
      PQfinish(conn);

      // On sort du programme avec un code 1 pour indiquer une erreur
      exit(1);
   }

   // La connexion a été établie avec succès, nous affichons les informations du serveur de base de données
   printf("Connection établie\n");
   printf("Port: %s\n", PQport(conn));
   printf("Hote: %s\n", PQhost(conn));
   printf("Nom de la DB: %s\n", PQdb(conn));

   // Fermeture de la connexion et libération de la mémoire
   PQfinish(conn);

   return 0;
}
```

Dans ce code, remplacez votre\_nom\_dn, utilisateur et mot\_de\_passe par
les valeurs appropriées pour votre configuration PostgreSQL. Le
programme imprime les détails de la connexion, tels que le port, l'hôte
et le nom de la base de données, pour confirmer la connexion réussie.

Enfin, la connexion est fermée à l'aide de [PQfinish()](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PQFINISH)
pour libérer la mémoire allouée à l'objet PGconn.

### Executer une requête SQL

Une fois la connexion à la base de données établie, nous pouvons
procéder à l'exécution des requêtes à l'aide de libpq.

La fonction principale que nous utiliserons pour l'exécution des
requêtes est [PQexec()](https://www.postgresql.org/docs/current/libpq-exec.html#LIBPQ-EXEC-MAIN).

La fonction [PQexec()](https://www.postgresql.org/docs/current/libpq-exec.html#LIBPQ-EXEC-MAIN)
est utilisée pour soumettre une requête à PostgreSQL et attendre le résultat.

Elle renvoie un pointeur PGresult, qui encapsule le résultat de la requête renvoyé par le backend de la base de données.

Dans la plupart des cas, un pointeur non nul est renvoyé, sauf dans des
situations telles que des conditions de manque de mémoire ou des erreurs
critiques empêchant l'envoi de la requête au backend.

Si un pointeur nul est renvoyé, il doit être traité comme un résultat **PGRES\_FATAL\_ERROR**.

Pour obtenir plus d'informations sur l'erreur, vous pouvez utiliser la fonction
[PQerrorMessage()](https://www.postgresql.org/docs/current/libpq-exec.html#LIBPQ-PQRESULTERRORMESSAGE).

La structure PGresult doit être conservée comme une abstraction lors de
l'utilisation du résultat de la requête. Il est recommandé d'utiliser
des fonctions d'accès au lieu de référencer directement les champs de
la structure **PGresult**, car les champs peuvent changer dans les
futures versions de libpq.

Après avoir exécuté une requête à l'aide de [PQexec()](https://www.postgresql.org/docs/current/libpq-exec.html#LIBPQ-EXEC-MAIN),
vous pouvez vérifier l'état du résultat à l'aide de PQresultStatus().

Les états de résultat possibles incluent:

* **PGRES\_EMPTY\_QUERY**: la chaîne de requête envoyée par le backend était vide.
* **PGRES\_COMMAND\_OK**: la commande s'est terminée avec succès, mais aucune donnée n'a été renvoyée.
* **PGRES\_TUPLES\_OK**: la requête s'est exécutée avec succès et a renvoyé des tuples (lignes).
* **PGRES\_COPY\_OUT**: le transfert de données (copie sortante) depuis le serveur a commencé.
* **PGRES\_COPY\_IN**: le transfert de données (copie entrante) vers le serveur a commencé.
* **PGRES\_BAD\_RESPONSE**: la réponse du serveur n'a pas été comprise.
* **PGRES\_NONFATAL\_ERROR**: une erreur non fatale s'est produite lors de l'exécution de la requête.
* **PGRES\_FATAL\_ERROR**: une erreur fatale s'est produite lors de l'exécution de la requête.

Si le statut du résultat de la requête est **PGRES\_TUPLES\_OK**, vous pouvez utiliser
diverses fonctions pour récupérer des informations sur les tuples renvoyés.

Voici quelques fonctions utiles:

* **PQntuples()** : renvoie le nombre de tuples (lignes) dans le résultat de la requête.
* **PQnfields()** : renvoie le nombre de champs (attributs) dans chaque tuple du résultat de la requête.
* **PQfname()** : renvoie le nom du champ (attribut) associé à l'index de champ donné. Les indices de champ commencent à 0.
* **PQftype()** : renvoie le type de champ associé à l'index de champ donné.
  L'entier renvoyé représente un codage interne du type. Les indices de champ commencent à 0.
* **PQgetvalue()** : renvoie la valeur d'un champ spécifique (attribut)
  dans un tuple du résultat de la requête. Les indices de tuple et de
  champ commencent à 0.

Ces fonctions fournissent des fonctionnalités essentielles pour
récupérer et travailler avec les résultats de la requête.

```C
// Requête a exécuter
char *query = "SELECT * FROM ma_table";

// Envoyer la requête et récupérer les résultats
PGresult *res = PQexec(conn, query);

// Vérifier l'état de résultat de la requête
ExecStatusType resStatus = PQresultStatus(res);

// Convertir l'état en message texte et 'l'afficher
printf("Etat requete: %s\n", PQresStatus(resStatus));
```

Vérification de ce que retourne la requête

```c
if (resStatus != PGRES_TUPLES_OK) {
    //Si on ne récupère pas de ligne, on affiche et un message et on termine la connexion
    printf("Erreur lors de l'execution de la requête: %s\n", PQerrorMessage(conn));

    PQclear(res);

    PQfinish(conn);

    exit(1);
}

// On recupère des données, on affiche un message
printf("Requête exécutée avec succès\n");
```

Ensuite on affiche le résultat sur la console.

```c
// On récupère le nombre de lignes et de colonne
int rows = PQntuples(res);
int cols = PQnfields(res);
printf("Nombre de lignes: %d\n", rows);
printf("Nombre de colonnes: %d\n", cols);

// On affiche les noms de colonnes
for (int i = 0; i < cols; i++) {
    printf("%s\t", PQfname(res, i));
}
printf("\n");

// On affiche le contenue des lignes
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        printf("%s\t", PQgetvalue(res, i, j));
    }
    printf("\n");
}
```

On n'oublie pas de liberer les ressources et de fermer la connexion

```c
PQclear(res);

PQfinish(conn);

return 0;
```

Pour compiler et exécuter votre code, suivez les étapes ci-dessou:

1. Assurez-vous que le répertoire bin de PostgreSQL est inclus dans le
   chemin de vos variables d'environnement. Cela permet au compilateur
   de localiser les bibliothèques et exécutables PostgreSQL
   nécessaires.
2. Ouvrez le terminal ou l'invite de commande et accédez au répertoire
   où se trouve votre fichier C.
3. Utilisez la commande suivante pour compiler votre code:

```shell
gcc monprogramme.c -o monprogramme -I "path/to/postgres/include" -L "path/to/postgres/lib" -lpq
```

Si la compilation s'est déroulé correctement, vous devriez avoir un
executable **monprogramme** dans votre dossier

Que vous pourrez lancer comme ceci:

```shell
./monprogramme
```

Pour plus de maintenabilité, vous pourrez privilégié la creation d'un fichier [Makefile](https://fr.wikipedia.org/wiki/Make).

## Bibiothèque ECPG

[ECPG](https://www.postgresql.org/docs/current/app-ecpg.html) est un préprocesseur, qui vous permet d'embarquer du SQL
directement dans votre programme en C

Vos fichiers C embarquant du SQL auront pour extension **pgc**.

Chaque instructions utilisants du SQL commencera par **EXEC SQL**.

Lors de la compilation, les fichiers ayant l'extension pgc seront
traduit en fichier C et seront ensuite compilés

Ci-dessous un exemple tiré de la documentation utilisant de multiples
connexions

```c
#include <stdio.h>

EXEC SQL BEGIN DECLARE SECTION;
    char nomdb[1024];
EXEC SQL END DECLARE SECTION;

int
main()
{
    EXEC SQL CONNECT TO basetest1 AS con1 USER utilisateurtest;
    EXEC SQL SELECT pg_catalog.set_config('search_path', '', false); EXEC SQL COMMIT;
    EXEC SQL CONNECT TO basetest2 AS con2 USER utilisateurtest;
    EXEC SQL SELECT pg_catalog.set_config('search_path', '', false); EXEC SQL COMMIT;
    EXEC SQL CONNECT TO basetest3 AS con3 USER utilisateurtest;
    EXEC SQL SELECT pg_catalog.set_config('search_path', '', false); EXEC SQL COMMIT;

    /* Cette requête serait exécuté dans la dernière base ouverte "basetest3". */
    EXEC SQL SELECT current_database() INTO :nomdb;
    printf("courante=%s (devrait être basetest3)\n", nomdb);

    /* Utiliser "AT" pour exécuter une requête dans "basetest2" */
    EXEC SQL AT con2 SELECT current_database() INTO :nomdb;
    printf("courante=%s (devrait être basetest2)\n", nomdb);

    /* Basculer la connexion courante à "basetest1". */
    EXEC SQL SET CONNECTION con1;

    EXEC SQL SELECT current_database() INTO :nomdb;
    printf("courante=%s (devrait être basetest1)\n", nomdb);

    EXEC SQL DISCONNECT ALL;
    return 0;
}
```

---

---
url: /livres.md
description: Liste de livres français traitant du serveur de base de données PostgreSQL
---

# Livres

Sélection de livres en français s'articulant autour de PostgreSQL

## PostgreSQL - Architecture et notions avancées

5 ème édition de ce livre écrit par:

* Guillaume Lelarge
* Julien Rouhaud

Lien vers [PostgreSQL - Architecture et notions avancées
(5e édition)](https://www.d-booker.fr/bases-de-donnees/805-postgresql-architecture-et-notions-avancees-5ed.html)

* EAN: 9782822711241
* ISBN: 978-2-8227-1124-1

### Présentation

![image](/postgresql-architecture-et-notions-avancees-5ed.png "PostgreSQL - Architecture et notions avancées"){.align-right}

Pour maîtriser PostgreSQL, rien de mieux que de comprendre son
fonctionnement interne. C'est ce que vous proposent **Guillaume
Lelarge**, consultant chez Dalibo, contributeur majeur de PostgreSQL,
ainsi que **Julien Rouhaud**, auteur notamment
d'[HypoPg](https://hypopg.readthedocs.io), avec ce livre sans
équivalent, pas même en anglais.

Dans un style clair et précis, il vous explique en détails la mécanique
de ce puissant système de gestion de bases de données open-source, vous
aidant ainsi à en comprendre toutes les subtilités et donc à mieux
l'administrer, le paramétrer, le superviser... en un mot à mieux
l'utiliser.

Sa lecture ne requiert pas de connaissances avancées en PostgreSQL, ni
la maîtrise préalable d'un autre moteur de bases de données. En
revanche, il est préférable que vous soyez à l'aise avec le
fonctionnement d'un système d'exploitation comme Linux. Une
connaissance modérée du langage SQL sera un plus.

Cette cinquième édition, entièrement revue et complétée, prend en compte
les nouveautés des versions 15 et 16 (septembre 2023). Lorsque des
différences importantes dues aux versions sont à noter, elles sont
indiquées aussi clairement que possible.

### Sommaire

1. Instance
2. Fichiers
3. Contenu physique des fichiers
4. Architecture des processus
5. Architecture mémoire
6. Protocole de communication
7. Gestion des connexions
8. Gestion des transactions
9. Gestion des objets
10. Planification des requêtes
11. Sauvegarde et restauration
12. Réplication
13. Statistiques d'activité
14. Collecte et traitement des traces
15. Maintenance
16. Sécurité

## PostgreSQL - Administration et exploitation de vos bases de données

4 ème édition de ce livre écrit par:

* Sébastien Lardière

Lien vers [PostgreSQL - Administration et exploitation de vos bases de données](https://www.eyrolles.com/Informatique/Livre/postgresql-9782409011467/)

* EAN: 9782409011467
* ISBN: 978-2-409-01146-7

### Présentation

![image](/administration-exploit-bases-de-donnes.jpg "PostgreSQL - Administration et exploitation de vos bases de données"){.align-right}

L'administrateur de bases de données, le technicien d'exploitation et
le développeur trouveront dans ce livre les informations indispensables
pour exploiter au mieux toutes les possibilités de PostgreSQL (en
version 10 au moment de la rédaction).

Les premiers chapitres du livre couvrent l'installation de PostgreSQL
sur Windows et GNU/Linux ainsi que la préparation de l'environnement
d'exécution du serveur. L'auteur présente ensuite les applications
clientes pouvant être utilisées, les différents paramètres de sécurité
et les différents aspects de PostgreSQL concernant le support du langage
SQL. Les chapitres qui suivent introduisent la programmation dans
PostgreSQL et détaillent l'administration et l'exploitation (de la
configuration du serveur aux différentes tâches d'exploitation, en
passant par les sauvegardes). Un chapitre présente des outils annexes
enrichissant l'utilisation de PostgreSQL. Enfin, l'auteur introduit le
thème de la réplication des données entre différents serveurs, en
étudiant la réplication physique et logique intégrée à PostgreSQL ainsi
que l'outil Slony.

### Sommaire

1. Installation
2. Initialisation du système de fichiers
3. Connexions
4. Définition des données
5. Programmation
6. Exploitation
7. Outils
8. Réplication

## PostgreSQL - Entraînez-vous à créer et programmer une base de données relationnelle

Livre écrit par:

* François-Marie Colonna

Lien vers [PostgreSQL - Entraînez-vous à créer et programmer une base de données relationnelle](https://www.eyrolles.com/Informatique/Livre/postgresql-entrainez-vous-a-creer-et-programmer-une-base-de-donnees-relationnelle-9782746043817/)

* EAN: 9782746043817
* ISBN: 978-2-7460-4381-7

### Présentation

![image](/creer-programmer-base-de-donnes-relationnelle.jpg "PostgreSQL - Entraînez-vous à créer et programmer une base de données relationnelle"){.align-right}

Conçu par un formateur, ce livre sur PostgreSQL est destiné à un public
de lecteurs débutants ou initiés, déjà familiers de l'utilisation
d'une base de données relationnelle.

Au travers d'un travail pratique dont le fil conducteur s'étend sur
les 7 premiers chapitres, les exercices proposés couvrent la conception
de la base de données (création de tables, de types de données, de
domaines), l'interrogation de la base à l'aide de requêtes SQL
(sélection, insertion, mise à jour, suppression), les transactions
(niveaux d'isolation, verrouillage) et la programmation côté serveur
(vues, règles et déclencheurs).

Les pré-requis proposés au début de chaque chapitre permettent au
lecteur d'évaluer précisément ses connaissances avant d'aborder les
exercices.

Le dernier chapitre est un exercice de synthèse qui reprend sur un sujet
différent toutes les notions abordées dans les premiers chapitres du
livre. 209 QCM - 81 travaux pratiques et leurs corrigés - Près de 30 H
de mise en pratique.

### Sommaire

1. Connexion à PostgreSQL et création des tables
2. Requêtes SQL de base
3. Requêtes SQL avancées
4. Vues, règles, droits et tables système
5. Transactions et concurrence
6. Fonctions SQL et langages procéduraux
7. Déclencheurs
8. TP de synthèse - Gestion d'une librairie

---

---
url: /services.md
---

# Prestation autour de PostgreSQL

* [Sociétés de services](./societes.md)
* [Hébergeurs](./hebergeurs.md)

---

---
url: /services/societes.md
description: Société proposant des services et prestations autour de PostgreSQL
---

# Société de services

Liste des sociétés assurants de la prestation de services autour de
PostgreSQL (Triées par ordre alphabétique)

* [2ndQuadrant](https://2ndquadrant.com)
* [5432 Tech](https://5432.tech/grav/) (non affilié à 5432.fr)
* [Adrien Nayrat](https://pro.anayrat.info/)
* [AgoraTIC](https://agoratic.com/)
* [Camptocamp SA](https://camptocamp.com/postgresql)
* [Dalibo](https://www.dalibo.com/)
* [Data Bene](https://www.data-bene.io/fr/)
* [GCII](https://gcii.fr/)
* [Hybrix](https://www.hybrix.fr/)
* [LOXODATA](https://www.loxodata.com/)
* [Mirounga](https://mirounga.fr/postgresql)
* [Openska](https://openska.com/)
* [SIGMAZ Consilium](https://sigmaz-consilium.fr/postgresql/)
* [splendiddata](https://www.splendiddata.com/)

---

---
url: /articles/indexes.md
description: Cette page décrit l'utilisation des diféfrents index dans PostgreSQL
---

# Les Index

## Les types d'index

| Type d’index   | Description | Cas d’usage typique |
|----------------|-------------|---------------------|
| B-tree | Structure équilibrée par défaut, idéale pour les requêtes d’égalité et de plage. | Clés primaires, colonnes fréquemment interrogées avec `=`, `>`, `<`, `BETWEEN`. |
| Hash | Basé sur une fonction de hachage, très rapide pour les recherches d’égalité exacte. | Colonnes utilisées uniquement avec `=` (pas de tri ou de plage). |
| GiST | Index généralisé pour les recherches, supporte les opérateurs personnalisés. | Données géométriques, texte en plein texte, types personnalisés.                  |
| SP-GiST | Variante de GiST pour les données non équilibrées (arbres de suffixes, etc.). | Données hiérarchiques, adresses IP, types de données non structurées.              |
| GIN | Inversé par rapport à GiST, efficace pour les valeurs composites (tableaux, JSON, texte). | Colonnes contenant des tableaux, documents JSON, recherche de mots-clés. |
| BRIN | Index minimaliste pour les tables très grandes et ordonnées physiquement. | Tables volumineuses avec un ordre naturel (ex : données temporelles). |
| Bloom | Filtre probabiliste pour réduire le nombre de lignes à scanner. | Tables avec de nombreuses colonnes interrogées de manière aléatoire. |

## Index B-tree

```sql
-- Création d'une table utilisateurs
CREATE TABLE utilisateurs (
    id SERIAL PRIMARY KEY,
    nom VARCHAR(100),
    email VARCHAR(100),
    date_inscription TIMESTAMP
);

-- Création d'un index B-tree sur la colonne 'email'
CREATE INDEX idx_utilisateurs_email ON utilisateurs (email);

-- Création d'un index B-tree sur plusieurs colonnes (index composite)
CREATE INDEX idx_utilisateurs_nom_email ON utilisateurs (nom, email);
```

Explications:

* `CREATE INDEX idx_utilisateurs_email ON utilisateurs (email);` crée un index B-tree sur la colonne email.
* PostgreSQL utilise B-tree par défaut, donc tu n’as pas besoin de préciser USING btree.
* Les index composites (sur plusieurs colonnes) sont utiles pour les requêtes qui filtrent sur plusieurs champs.

## Index Hash

Ci dessous quelques exemples d’utilisation des **index HASH** sous PostgreSQL, avec des cas concrets et des bonnes pratiques:

### Création d’un index HASH sur une colonne simple

Supposons une table `clients` avec une colonne `email` souvent utilisée dans des requêtes de type `WHERE email = '...'`.

```sql
CREATE INDEX idx_clients_email_hash ON clients USING HASH (email);
```

::: tip Utilité
L’index HASH est très efficace pour les recherches d’égalité (`=`), mais pas pour les comparaisons de plage (`>`, `<`, `BETWEEN`).
:::

### Utilisation dans une requête

L’index sera automatiquement utilisé par le planificateur de requêtes si la condition est une égalité.

```sql
SELECT * FROM clients WHERE email = 'client@example.com';
```

::: tip Remarque
PostgreSQL utilise l’index HASH uniquement pour les opérateurs `=` et `IN` (si les valeurs sont constantes).
:::

### Index HASH sur plusieurs colonnes

Vous pouvez créer un index HASH sur plusieurs colonnes, mais il ne sera utilisé que si toutes les colonnes sont spécifiées dans la condition.

```sql
CREATE INDEX idx_clients_nom_prenom_hash ON clients USING HASH (nom, prenom);
```

**Exemple de requête utilisant l’index** :

```sql
SELECT * FROM clients WHERE nom = 'Dupont' AND prenom = 'Jean';
```

### Cas d’usage typique : tables de jointure

Les index HASH sont souvent utilisés pour les colonnes de jointure, surtout si les valeurs sont uniformément distribuées.

```sql
CREATE INDEX idx_commandes_client_id_hash ON commandes USING HASH (client_id);
```

**Exemple de jointure** :

```sql
SELECT c.nom, co.montant
FROM clients c
JOIN commandes co ON c.id = co.client_id
WHERE co.client_id = 123;
```

### Limites et bonnes pratiques

* **Pas de tri** : Les index HASH ne permettent pas de trier les résultats (`ORDER BY`).
* **Pas de recherche de plage** : Ils ne sont pas adaptés pour `>`, `<`, `BETWEEN`.
* **Maintenance** : Les index HASH doivent être recréés après un `VACUUM FULL` ou une réorganisation majeure de la table.
* **PostgreSQL 10+** : Avant PostgreSQL 10, les index HASH n’étaient pas persistants après un redémarrage du serveur.

### Vérification de l’utilisation de l’index

Pour vérifier si PostgreSQL utilise bien votre index HASH, utilisez `EXPLAIN ANALYZE` :

```sql
EXPLAIN ANALYZE SELECT * FROM clients WHERE email = 'client@example.com';
```

::: tip Résultat attendu
Si l’index est utilisé, vous verrez une ligne comme `Index Scan using idx_clients_email_hash on clients`.
:::

### Quand ne pas utiliser un index HASH ?

* Si vous avez besoin de recherches de plage ou de tri.
* Si la colonne a une faible cardinalité (peu de valeurs distinctes).
* Si vous utilisez souvent des opérateurs autres que `=`.

## Index GIST

Ci-dessous des exemples concrets d’utilisation des **index GiST** (Generalized Search Tree) sous PostgreSQL, avec des cas d’usage typiques et des bonnes pratiques.

### Index GiST pour les types géométriques (PostGIS)

L’usage le plus courant des index GiST est pour les requêtes spatiales avec l’extension **PostGIS**.

### Exemple : Table avec des points géographiques

```sql
CREATE EXTENSION postgis;
CREATE TABLE lieux (
    id SERIAL PRIMARY KEY,
    nom VARCHAR(100),
    position GEOMETRY(Point, 4326)
);

-- Création d'un index GiST sur la colonne géométrique
CREATE INDEX idx_lieux_position_gist ON lieux USING GIST(position);
```

**Requête utilisant l’index** :

```sql
-- Trouver les lieux à moins de 10 km d'un point donné
SELECT nom
FROM lieux
WHERE ST_DWithin(position, ST_SetSRID(ST_MakePoint(2.3522, 48.8566), 4326), 10000);
```

::: info
L’index GiST accélère les calculs de distance et les intersections spatiales.
:::

### Index GiST pour les types de données textuels (recherche full-text)

GiST peut aussi être utilisé pour la recherche full-text, bien que GIN soit souvent plus efficace.

```sql
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    contenu TEXT
);
-- Création d'un index GiST pour la recherche full-text
CREATE INDEX idx_documents_contenu_gist ON documents USING GIST(to_tsvector('french', contenu));
```

**Requête utilisant l’index** :

```sql
SELECT id, contenu
FROM documents
WHERE to_tsvector('french', contenu) @@ to_tsquery('french', 'PostgreSQL & index');
```

::: info
L’index GiST permet d’accélérer les recherches de mots-clés.
:::

### Index GiST pour les types de données personnalisés

GiST permet d’indexer des types de données personnalisés, comme des intervalles, des réseaux, etc.

#### Exemple : Index sur des intervalles de dates

```sql
CREATE TABLE reservations (
    id SERIAL PRIMARY KEY,
    periode TSRANGE
);
-- Création d'un index GiST sur un type intervalle
CREATE INDEX idx_reservations_periode_gist ON reservations USING GIST(periode);
```

**Requête utilisant l’index** :

```sql
-- Trouver les réservations qui chevauchent une période donnée
SELECT id
FROM reservations
WHERE periode && '[2025-09-01, 2025-09-30]'::TSRANGE;
```

::: info
L’index GiST accélère les tests de chevauchement (`&&`), de contenu (`@>`), etc.
:::

### Index GiST pour les types de données géométriques natifs

Même sans PostGIS, PostgreSQL supporte des types géométriques de base.

```sql
CREATE TABLE formes (
    id SERIAL PRIMARY KEY,
    rectangle BOX
);
-- Création d'un index GiST sur un type BOX
CREATE INDEX idx_formes_rectangle_gist ON formes USING GIST(rectangle);
```

**Requête utilisant l’index** :

```sql
-- Trouver les rectangles qui contiennent un point donné
SELECT id
FROM formes
WHERE rectangle @> '(10,10)'::POINT;
```

### Vérification de l’utilisation de l’index GiST

Pour vérifier si PostgreSQL utilise bien votre index GiST, utilisez `EXPLAIN ANALYZE`:

```sql
EXPLAIN ANALYZE
SELECT * FROM lieux
WHERE ST_DWithin(position, ST_SetSRID(ST_MakePoint(2.3522, 48.8566), 4326), 10000);
```

::: info
Cherchez `Index Scan using idx_lieux_position_gist` dans le plan d’exécution.
:::

### Quand utiliser GiST plutôt que GIN ou SP-GiST ?

* `GiST` : Idéal pour les données géométriques, les intervalles, les recherches de chevauchement.
* `GIN` : Mieux adapté pour les recherches full-text, les tableaux, les données composites.
* `SP-GiST` : Utile pour les données hiérarchiques ou les recherches de préfixe.

## Index GIN

Voici des exemples concrets d’utilisation des **index GIN** (Generalized Inverted Index) sous PostgreSQL, avec des cas d’usage typiques et des bonnes pratiques.

### Index GIN pour les colonnes de type tableau (ARRAY)

Les index GIN sont très efficaces pour rechercher des valeurs dans des colonnes de type tableau.

#### Exemple : Table avec un tableau de tags

```sql
CREATE TABLE articles (
    id SERIAL PRIMARY KEY,
    titre VARCHAR(255),
    tags TEXT[]
);
-- Création d'un index GIN sur la colonne tags
CREATE INDEX idx_articles_tags_gin ON articles USING GIN(tags);
```

**Requêtes utilisant l’index** :

```sql
-- Trouver les articles qui ont le tag 'postgresql'
SELECT * FROM articles WHERE 'postgresql' = ANY(tags);

-- Trouver les articles qui ont tous les tags 'postgresql' ET 'index'
SELECT * FROM articles WHERE tags @> ARRAY['postgresql', 'index'];

-- Trouver les articles qui ont au moins un des tags 'postgresql' OU 'base de données'
SELECT * FROM articles WHERE tags && ARRAY['postgresql', 'base de données'];
```

::: info
L’index GIN accélère les recherches de valeurs dans les tableaux, surtout pour les opérateurs `@>`, `&&` et `= ANY`.
:::

### Index GIN pour la recherche full-text

GIN est souvent utilisé pour la recherche full-text, car il est plus rapide que GiST pour ce type de requête.

```sql
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    contenu TEXT
);
-- Création d'un index GIN pour la recherche full-text
CREATE INDEX idx_documents_contenu_gin ON documents USING GIN(to_tsvector('french', contenu));
```

**Requêtes utilisant l’index** :

```sql
-- Trouver les documents contenant les mots 'postgresql' ET 'index'
SELECT id, contenu
FROM documents
WHERE to_tsvector('french', contenu) @@ to_tsquery('french', 'postgresql & index');

-- Trouver les documents contenant la phrase 'optimisation des requêtes'
SELECT id, contenu
FROM documents
WHERE to_tsvector('french', contenu) @@ plainto_tsquery('french', 'optimisation des requêtes');
```

::: info
L’index GIN est très efficace pour les recherches de mots-clés et les requêtes booléennes.
:::

### Index GIN pour les colonnes de type JSON/JSONB

GIN est le type d’index le plus performant pour les requêtes sur des colonnes JSONB, surtout pour rechercher des clés ou des valeurs imbriquées.

```sql
CREATE TABLE produits (
    id SERIAL PRIMARY KEY,
    nom VARCHAR(255),
    attributs JSONB
);
-- Création d'un index GIN sur la colonne JSONB
CREATE INDEX idx_produits_attributs_gin ON produits USING GIN(attributs);
```

**Requêtes utilisant l’index** :

```sql
-- Trouver les produits dont l'attribut 'couleur' est 'bleu'
SELECT * FROM produits WHERE attributs @> '{"couleur": "bleu"}';

-- Trouver les produits qui ont une clé 'prix' dans leurs attributs
SELECT * FROM produits WHERE attributs ? 'prix';

-- Trouver les produits dont la valeur de la clé 'prix' est supérieure à 100
SELECT * FROM produits WHERE attributs->>'prix'::NUMERIC > 100;
```

::: info
→ L’index GIN accélère les recherches de clés, de valeurs et les tests de contenu dans les JSONB.
:::

### Index GIN pour les colonnes de type composite ou personnalisé

GIN peut aussi être utilisé pour des types de données composites ou personnalisés, comme les `hstore` ou les `ltree`.

#### Exemple avec hstore

```sql
CREATE EXTENSION hstore;
CREATE TABLE profils (
    id SERIAL PRIMARY KEY,
    infos HSTORE
);
-- Création d'un index GIN sur la colonne hstore
CREATE INDEX idx_profils_infos_gin ON profils USING GIN(infos);
```

**Requêtes utilisant l’index** :

```sql
-- Trouver les profils dont la clé 'langue' a la valeur 'français'
SELECT * FROM profils WHERE infos @> 'langue=>français';

-- Trouver les profils qui ont une clé 'pays'
SELECT * FROM profils WHERE infos ? 'pays';
```

### Vérification de l’utilisation de l’index GIN

Pour vérifier si PostgreSQL utilise bien votre index GIN, utilisez `EXPLAIN ANALYZE` :

```sql
EXPLAIN ANALYZE
SELECT * FROM articles WHERE tags @> ARRAY['postgresql', 'index'];
```

::: tip
Cherchez `Bitmap Heap Scan` ou `Index Scan` avec le nom de votre index GIN dans le plan d’exécution.
:::

### Quand utiliser GIN plutôt que GiST ou SP-GiST ?

* `GIN` : Idéal pour les tableaux, les JSONB, la recherche full-text, les données composites.
* `GiST` : Mieux adapté pour les données géométriques, les intervalles, les recherches de chevauchement.
* `SP-GiST` : Utile pour les données hiérarchiques ou les recherches de préfixe.

## Index BRIN

Voici des exemples concrets d’utilisation des **index BRIN** (Block Range INdex) sous PostgreSQL, avec des cas d’usage typiques, des bonnes pratiques et des exemples de requêtes.

### Qu’est-ce qu’un index BRIN ?

* **BRIN** est un type d’index conçu pour les **très grandes tables** où les données sont **physiquement ordonnées** selon une colonne (par exemple, une colonne de type date, timestamp, ou série numérique).
* Il est **très compact** et **rapide à maintenir**, mais moins précis qu’un B-tree pour les recherches ponctuelles.
* Idéal pour les tables où les données sont **insérées dans l’ordre** (logs, séries temporelles, etc.).

### Création d’un index BRIN sur une colonne de type timestamp

Supposons une table de logs où les entrées sont toujours insérées par ordre chronologique :

```sql
CREATE TABLE logs (
    id BIGSERIAL PRIMARY KEY,
    date_log TIMESTAMPTZ NOT NULL,
    message TEXT
);

-- Création d'un index BRIN sur la colonne date_log
CREATE INDEX idx_logs_date_brin ON logs USING BRIN(date_log);
```

::: tip Pourquoi BRIN ?

* Les logs sont toujours insérés par ordre chronologique.
* La table peut devenir très volumineuse.
* BRIN est très efficace pour les requêtes de plage sur `date_log`.
  :::

### Requêtes utilisant l’index BRIN

#### Exemple 1 : Recherche de plage de dates

```sql
-- Trouver tous les logs entre deux dates
SELECT * FROM logs WHERE date_log BETWEEN '2025-09-01' AND '2025-09-16';
```

::: info
L’index BRIN permet de sauter rapidement les blocs de données qui ne contiennent pas de logs dans cette plage.
:::

#### Exemple 2 : Recherche de logs récents

```sql
-- Trouver les logs des dernières 24 heures
SELECT * FROM logs WHERE date_log > NOW() - INTERVAL '24 hours';
```

::: info
BRIN est très efficace pour ce type de requête sur des données ordonnées.
:::

### Création d’un index BRIN sur une colonne numérique ordonnée

Exemple avec une table de mesures de capteurs, où les données sont insérées par ordre de `timestamp` et de `valeur` :

```sql
CREATE TABLE mesures (
    id BIGSERIAL PRIMARY KEY,
    timestamp TIMESTAMPTZ NOT NULL,
    valeur DOUBLE PRECISION NOT NULL
);
-- Création d'un index BRIN sur la colonne timestamp
CREATE INDEX idx_mesures_timestamp_brin ON mesures USING BRIN(timestamp);
```

**Requête utilisant l’index** :

```sql
-- Trouver les mesures entre deux timestamps
SELECT * FROM mesures
WHERE timestamp BETWEEN '2025-09-01 00:00:00' AND '2025-09-01 12:00:00';
```

### Création d’un index BRIN multi-colonnes

Vous pouvez créer un index BRIN sur plusieurs colonnes, si elles sont corrélées et ordonnées ensemble.

```sql
-- Création d'un index BRIN sur deux colonnes
CREATE INDEX idx_mesures_timestamp_valeur_brin ON mesures USING BRIN(timestamp, valeur);
```

::: warning Remarque
BRIN est surtout efficace si les colonnes sont **physiquement corrélées** dans l’ordre d’insertion.
:::

### Vérification de l’utilisation de l’index BRIN

Pour vérifier si PostgreSQL utilise bien votre index BRIN, utilisez `EXPLAIN ANALYZE` :

```sql
EXPLAIN ANALYZE
SELECT * FROM logs
WHERE date_log BETWEEN '2025-09-01' AND '2025-09-16';
```

::: info
Cherchez `Index Scan using idx_logs_date_brin` dans le plan d’exécution.
:::

### Quand utiliser BRIN plutôt que B-tree ou GiST ?

| Critère                | BRIN           | B-tree          | GiST          |
|------------------------|----------------|-----------------|---------------|
| Données ordonnées      | ✅ Idéal       | ⚠️ Possible    | ❌ Non        |
| Taille de l’index      | Très compact   | Volumineux      | Compact       |
| Recherche ponctuelle   | ❌ Peu précis  | ✅ Très précis | ⚠️ Variable   |
| Recherche de plage     | ✅ Très rapide | ✅ Rapide      | ⚠️ Variable   |
| Maintenance            | Très rapide     | Lente          | Rapide        |

::: info Cas d’usage typiques pour BRIN

* Tables de logs, séries temporelles, données IoT.
* Tables où les données sont toujours insérées dans l’ordre (par exemple, par date).
* Tables très volumineuses où la taille de l’index est un critère important.
  :::

### Bonnes pratiques avec BRIN

* **Ordonner les données** : BRIN est efficace si les données sont physiquement ordonnées selon la colonne indexée.
* **Éviter les mises à jour aléatoires** : BRIN est optimisé pour les insertions séquentielles.
* **Utiliser `pages_per_range`** : Vous pouvez ajuster la taille des blocs indexés pour optimiser les performances (par défaut, 128 pages par bloc).

```sql
CREATE INDEX idx_logs_date_brin ON logs USING BRIN(date_log) WITH (pages_per_range = 64);
```

## Use the index Luke

Le site [Use the index,
Luke](http://use-the-index-luke.com/fr/sql/preface) décrit les
problématiques du SQL, et vous donnent des pistes pour créer des indexes
efficaces en fonctions de vos cas de figures.

## Articles divers

* [Retarder la vérification des
  contraintes](https://blog.anayrat.info/2016/08/13/postgresql-retarder-la-verification-des-contraintes/)
* [Index BRIN --
  Performances](https://blog.anayrat.info/2016/04/21/index-brin-performances/)