Commandes de base pour bosser avec les transactions : BEGIN, COMMIT, ROLLBACK

Pour garder le contrôle sur tous les changements dans ta base de données et t'assurer que tout se passe bien, PostgreSQL utilise le concept de transaction. C'est un groupe d'opérations SQL qui s'exécutent comme un tout. Si un truc foire, il faut annuler les modifs. C'est là que les commandes BEGIN, COMMIT et ROLLBACK entrent en jeu.

Les commandes de transaction, c'est pas juste pour faire joli — elles sont cruciales pour protéger tes données contre les bugs et les plantages. Quand tu fais une série d'opérations SQL, c'est super important d'être sûr que tout passe bien : si une commande plante, la base doit revenir à son état initial. C'est une des raisons principales pour lesquelles on a besoin des commandes de transaction — elles t'aident à garder la cohérence des données.

En plus, les transactions assurent ce qu'on appelle l'atomicité : soit tous les changements sont appliqués ensemble, soit aucun. Comme ça, t'as jamais une base "à moitié" mise à jour — genre l'argent est débité mais le produit n'est pas ajouté à la commande.

Et bien sûr, les transactions te donnent de la flexibilité. Tu peux construire des chaînes d'actions complexes, décider quand valider avec COMMIT ou annuler avec ROLLBACK, et même faire des retours précis avec SAVEPOINT. Tout ça rend le taf avec la base non seulement safe, mais aussi super contrôlable.

Commande BEGIN

La commande BEGIN dit à PostgreSQL que tu démarres une transaction. Après ça, tous les changements que tu fais restent "en attente" jusqu'à ce que tu termines la transaction avec COMMIT ou que tu annules avec ROLLBACK.

Un exemple classique : imaginons que tu veux transférer 100 unités de monnaie d'un compte à un autre. Tu démarres la transaction avec BEGIN :

BEGIN;
-- Transaction démarrée
UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
-- Balance diminuée sur le compte 1
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;
-- Balance augmentée sur le compte 2

Commande COMMIT

La commande COMMIT termine la transaction et enregistre tous les changements faits dans la base. Après cette commande, tout le monde voit les modifs.

Exemple pour finir une transaction :

COMMIT;
-- Tous les changements de la transaction sont enregistrés

Maintenant, les changements de balance qu'on a faits plus haut sont "définitifs". L'argent a bien été transféré.

Commande ROLLBACK

Si pendant la transaction tu vois une erreur ou tu veux annuler les changements, tu peux utiliser ROLLBACK. Ça annule toutes les opérations faites après le BEGIN.

Par exemple, pendant le transfert d'argent, tu découvres qu'il n'y a pas assez de fonds sur le compte. Du coup, la transaction est annulée :

BEGIN;
-- Transaction démarrée
UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;

-- Oups, erreur : pas assez de fonds.
ROLLBACK;
-- Tous les changements sont annulés, la base est revenue à l'état initial

Après ROLLBACK, aucun changement n'est gardé dans la base. Super pratique pour éviter les boulettes.

Exemple complet : transfert d'argent entre comptes

On va tout mettre ensemble. Voilà un exemple complet de transaction — avec vérif du solde, transfert d'argent et possibilité d'annuler si y'a un souci :

BEGIN;
-- On démarre la transaction

-- On vérifie le solde du compte
SELECT balance INTO current_balance FROM accounts WHERE account_id = 1;

-- On vérifie si y'a assez de fonds
IF current_balance >= 100 THEN
    -- Si y'a assez, on fait le transfert
    UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
    UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;
    COMMIT;
    -- On valide les changements
ELSE
    -- Si pas assez, on annule la transaction
    ROLLBACK;
END IF;

Cet exemple montre comment les commandes de transaction bossent ensemble pour éviter les incohérences de données.

Particularité du mode autocommit

Dans PostgreSQL, par défaut, le mode autocommit est activé, donc si tu fais des commandes hors transaction explicite, elles sont direct enregistrées dans la base. Par exemple :

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
-- Les changements sont enregistrés direct, même sans COMMIT

Si tu veux gérer les transactions à la main, c'est conseillé d'utiliser BEGIN pour démarrer explicitement la transaction.

Tu peux désactiver l'autocommit pour ta session actuelle avec la commande :

SET AUTOCOMMIT TO OFF;

Retiens : si l'autocommit est off, tu dois finir chaque session avec COMMIT ou ROLLBACK.

Erreurs classiques avec les transactions

Oubli de COMMIT. Si tu oublies de faire COMMIT, tes changements restent en attente et seront perdus à la fin de la session.

Verrous. Tant que la transaction n'est pas finie, les ressources qu'elle utilise peuvent rester verrouillées. Ça peut causer des soucis d'accès concurrent aux données.

Trop de ROLLBACK. Parfois, les devs sont trop prudents et annulent la transaction pour rien. Ça fait des recalculs inutiles et ça charge la base.

Transactions bloquées. Si tu démarres une transaction mais tu l'oublies (ni COMMIT ni ROLLBACK), ça peut bloquer la session et les ressources de la base.

Utilisation pratique

En entretien pour un poste de dev ou DBA (admin de base de données), on peut te demander comment marchent les transactions dans PostgreSQL. Comprendre BEGIN, COMMIT et ROLLBACK montre que tu sais manipuler les données de façon safe et efficace.

En vrai, les transactions sont super utiles pour construire des systèmes fiables, genre pour gérer les commandes d'une boutique en ligne ou calculer les points de fidélité dans un programme de rewards.

Maintenant que tu gères les commandes de base des transactions, on va pouvoir aller plus loin et plonger dans des sujets cools comme l'utilisation de SAVEPOINT et la gestion des niveaux d'isolation. PostgreSQL, c'est un océan de possibilités, alors accroche-toi !