rollback

Introduction

MySQLi est l'extension PHP utilisée pour communiquer avec les bases de données MySQL. La fonction mysqli_rollback() (ou la méthode $mysqli->rollback() en style orienté objet) annule toutes les modifications effectuées depuis le début d'une transaction. Cette page explique quand et pourquoi vous en avez besoin, comment elle s'articule avec mysqli_commit(), et montre des exemples exécutables en style procédural et orienté objet.

Si vous débutez avec cette extension, commencez par PHP MySQLi et la connexion à MySQL.

Qu'est-ce que la fonction MySQLi Rollback ?

Une transaction est un groupe d'opérations de base de données traitées comme une seule unité de travail : soit toutes sont appliquées, soit aucune ne l'est. mysqli_rollback() rend possible le « aucune ne l'est » — elle supprime toutes les modifications effectuées depuis le début de la transaction et ramène la base de données à son état précédent.

L'exemple classique est un virement bancaire. Débiter un compte et créditer un autre doivent tous deux se produire ; si la deuxième requête échoue, vous ne pouvez pas laisser la première appliquée. L'annulation (rollback) garantit que les comptes restent équilibrés.

bool mysqli_rollback(mysqli $mysql, int $flags = 0, ?string $name = null)

Elle retourne true en cas de succès et false en cas d'échec. Le paramètre optionnel $name vous permet d'effectuer un rollback jusqu'à un point de sauvegarde nommé plutôt que d'annuler toute la transaction.

Autocommit : pourquoi avez-vous besoin des transactions ?

Par défaut, MySQL fonctionne en mode autocommit, ce qui signifie que chaque instruction individuelle est validée immédiatement et de façon permanente — il n'y a rien à annuler. L'appel à mysqli_begin_transaction() désactive l'autocommit pour la durée de la transaction, afin que vos modifications restent en attente jusqu'à ce que vous fassiez explicitement un commit() ou un rollback(). Consultez autocommit pour le comportement complet.

Comment fonctionne le flux de travail du rollback

Une transaction complète suit quatre étapes :

1. Connexion au serveur.
2. Démarrage d'une transaction avec mysqli_begin_transaction().
3. Exécution de vos requêtes.
4. Validation si tout a réussi, ou annulation si quelque chose a échoué.

Voici un exemple procédural complet :

<?php
// Create a connection to the MySQL server
$conn = mysqli_connect("localhost", "username", "password", "database");

// Check connection
if (!$conn) {
    die("Connection failed: " . mysqli_connect_error());
}

// Start a transaction
mysqli_begin_transaction($conn);

// Execute queries and make changes to the database
$insert = mysqli_query($conn, "INSERT INTO `my_table` (column1, column2) VALUES ('value1', 'value2')");
$update = mysqli_query($conn, "UPDATE `my_table` SET column1 = 'new_value' WHERE id = 1");

// Check if queries succeeded
if ($insert && $update) {
    // Commit the transaction if all queries succeed
    mysqli_commit($conn);
    echo "Transaction committed successfully.";
} else {
    // Rollback the changes if any query fails
    mysqli_rollback($conn);
    echo "Transaction failed and rolled back: " . mysqli_error($conn);
}

mysqli_close($conn);
?>

Une transaction est démarrée, deux requêtes s'exécutent, et le résultat détermine l'issue : validation en cas de succès, annulation en cas d'échec. Notez que mysqli_query() ne retourne false que lorsqu'une requête échoue au niveau SQL — elle ne lève pas d'exception, vous devez donc vérifier la valeur de retour vous-même, sauf si vous activez les exceptions (présenté ci-dessous).

Style orienté objet avec les requêtes préparées

La plupart du code en production utilise l'API orientée objet avec les requêtes préparées, qui empêchent l'injection SQL en séparant la requête de ses données. Activer le mode de rapport d'exceptions vous permet d'encapsuler toute la transaction dans un seul bloc try/catch et d'effectuer le rollback depuis un seul endroit :

<?php
// Throw exceptions on any MySQLi error instead of returning false
mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);

$mysqli = new mysqli("localhost", "username", "password", "database");

$mysqli->begin_transaction();

try {
    $stmt = $mysqli->prepare("UPDATE accounts SET balance = balance - ? WHERE id = ?");
    $stmt->bind_param("di", $amount, $fromId);
    $amount = 100.00;
    $fromId = 1;
    $stmt->execute();

    $stmt = $mysqli->prepare("UPDATE accounts SET balance = balance + ? WHERE id = ?");
    $stmt->bind_param("di", $amount, $toId);
    $toId = 2;
    $stmt->execute();

    // Both updates succeeded — make them permanent
    $mysqli->commit();
    echo "Transfer committed.";
} catch (mysqli_sql_exception $e) {
    // Anything threw — undo everything
    $mysqli->rollback();
    echo "Transfer failed and rolled back: " . $e->getMessage();
}

$mysqli->close();
?>

Étant donné que MYSQLI_REPORT_STRICT fait lever une mysqli_sql_exception par les instructions échouées, vous n'avez jamais à tester la valeur de retour de chaque requête — le bloc catch gère tous les chemins d'erreur. Consultez les exceptions PHP pour en savoir plus sur try/catch.

Rollback vers un point de sauvegarde

Un point de sauvegarde (savepoint) est un marqueur nommé à l'intérieur d'une transaction. L'annulation jusqu'à ce point ne défait que le travail effectué après le savepoint, laissant les modifications antérieures en attente. Cela est pratique quand une partie d'une transaction est optionnelle :

<?php
$mysqli->begin_transaction();

$mysqli->query("INSERT INTO orders (customer_id) VALUES (5)");
$mysqli->savepoint("after_order");

$mysqli->query("INSERT INTO order_items (order_id, sku) VALUES (LAST_INSERT_ID(), 'BAD')");

// Undo only the order_items insert; the order row remains pending
$mysqli->rollback(0, "after_order");

$mysqli->commit(); // commits the order without the bad item
?>

Cas d'utilisation de la fonction MySQLi Rollback

La fonction MySQLi Rollback est utile dans de nombreux scénarios, notamment :

1. Intégrité des données

Maintient la cohérence de la base de données en annulant les mises à jour partielles lorsqu'une opération échoue, garantissant ainsi que les enregistrements restent valides.

2. Gestion des erreurs

Fournit un mécanisme de récupération propre. Lorsqu'une défaillance survient, l'annulation empêche la création de données orphelines ou corrompues tout en permettant à l'application de consigner et d'afficher des messages d'erreur significatifs.

3. Gestion des transactions

Simplifie le contrôle du flux de travail en permettant aux développeurs d'abandonner une séquence d'opérations dépendantes et de redémarrer ou d'abandonner la transaction en toute sécurité sans nettoyage manuel.

Avantages de la fonction MySQLi Rollback

La fonction MySQLi Rollback offre plusieurs avantages techniques aux développeurs PHP :

1. Atomicité

Elle garantit qu'un groupe d'opérations de base de données réussit entièrement ou échoue entièrement, empêchant les mises à jour partielles susceptibles de corrompre les données.

2. Débogage simplifié

Lorsqu'une transaction échoue, l'annulation restaure la base de données à son état précédent, facilitant l'isolation et la correction de la requête problématique sans nettoyage manuel.

3. Optimisation des performances

Regrouper plusieurs requêtes dans une seule transaction réduit la surcharge liée à la validation individuelle des modifications, ce qui conduit à des opérations de base de données plus rapides.

Pièges courants

• Le moteur de stockage est important. Seuls les moteurs transactionnels prennent en charge le rollback. Le moteur par défaut de MySQL, InnoDB, le fait ; l'ancien moteur MyISAM ignore silencieusement les transactions, donc un rollback n'y change rien. Assurez-vous que vos tables utilisent InnoDB.
• Les instructions DDL valident automatiquement. Les instructions telles que CREATE TABLE, ALTER TABLE et DROP TABLE valident implicitement la transaction en cours dans MySQL — vous ne pouvez pas les annuler. Gardez les modifications de schéma en dehors des transactions que vous prévoyez d'annuler.
• N'effectuez le rollback qu'une seule fois. Après un commit() ou un rollback() complet, la transaction est terminée. Commencez-en une nouvelle avant d'effectuer d'autres travaux transactionnels.
• Une perte de connexion entraîne un rollback automatique. Si la connexion est perdue en cours de transaction, MySQL effectue automatiquement un rollback — les travaux non validés ne sont jamais laissés partiellement appliqués.

Conclusion

La fonction mysqli_rollback() est essentielle pour les développeurs PHP qui ont besoin d'annuler des modifications de base de données au cours d'une transaction. Elle garantit l'intégrité des données, simplifie la gestion des transactions et améliore la gestion des erreurs. En suivant les étapes de ce guide, les développeurs peuvent implémenter des rollbacks en toute sécurité pour maintenir des opérations de base de données fiables.

Practice