PDO en PHP : Un tutoriel complet avec des exemples concrets

PDO (PHP Data Objects) est une extension de PHP qui offre une interface d’abstraction pour accéder aux bases de données. Elle permet d’exécuter des requêtes SQL, de récupérer des données et de manipuler des bases de données de manière cohérente, indépendamment du type de base de données utilisée (MySQL, PostgreSQL, SQLite, etc.).

Ce tutoriel complet vous guidera à travers les concepts fondamentaux de PDO en PHP, en illustrant chaque notion avec des exemples concrets.

Différences entre PDO et les autres techniques d’accès à MySQL en PHP

Comparé aux autres techniques d’accès à MySQL en PHP, PDO présente plusieurs avantages importants :

Portabilité : PDO est compatible avec une large variété de bases de données, contrairement à d’autres extensions qui sont spécifiques à MySQL, comme mysql et mysqli. Cela signifie que le code PDO peut être facilement adapté pour fonctionner avec d’autres SGBD tels que PostgreSQL, Oracle ou Microsoft SQL Server, sans avoir à réécrire le code.
Sécurité : PDO est conçu pour prévenir les injections SQL, une faille de sécurité courante qui peut affecter les applications web. En utilisant des requêtes préparées et le binding de paramètres, PDO permet de séparer les données du code SQL, empêchant ainsi l’injection de code malveillant.
Performance : PDO peut être plus performant que d’autres extensions, en particulier pour les applications qui exécutent de nombreuses requêtes SQL. Cela est dû à son utilisation de techniques optimisées pour la communication avec les bases de données.
Facilité d’utilisation : PDO offre une syntaxe plus simple et plus cohérente que les autres extensions, ce qui facilite l’apprentissage et la maintenance du code. De plus, PDO fournit un ensemble complet de fonctionnalités pour gérer les transactions, les erreurs et la récupération de données.

Comparatif avec les autres techniques

Fonctionnalité	PDO	mysql	mysqli
Compatibilité SGBD	Multiple (MySQL, PostgreSQL, Oracle, etc.)	MySQL uniquement	MySQL uniquement
Prévention des injections SQL	Oui	Non	Oui (mais moins sécurisé que PDO)
Performance	Bonne	Moyenne	Bonne
Facilité d’utilisation	Facile	Moyenne	Moyenne

Sa portabilité, sa sécurité, ses performances et sa facilité d’utilisation en font un outil puissant et flexible pour le développement d’applications web modernes.

Connexion à la base de données

Avant de pouvoir interagir avec une base de données, il est nécessaire d’établir une connexion. Pour ce faire, on utilise la classe PDO et on lui fournit les informations de connexion à la base de données :

$dsn = 'mysql:host=localhost;dbname=ma_base_de_donnees;charset=utf8';
$user = 'mon_utilisateur';
$password = 'mon_mot_de_passe';

try {
    $pdo = new PDO($dsn, $user, $password);
} catch (PDOException $e) {
    echo 'Echec de la connexion : ' . $e->getMessage();
    exit;
}

Dans cet exemple, on se connecte à une base de données MySQL nommée ma_base_de_donnees située sur le serveur local localhost. L’identifiant de connexion est mon_utilisateur et le mot de passe est mon_mot_de_passe.

Requêtes SQL avec l’objet PDO : Insertion

Une fois la connexion établie, on peut exécuter des requêtes SQL en utilisant la méthode exec() de l’objet PDO. Par exemple, pour insérer une nouvelle ligne dans une table utilisateurs :

$nom = 'Dupont';
$prenom = 'Jean';
$email = 'jean.dupont@exemple.com';

$sql = "INSERT INTO utilisateurs (nom, prenom, email) VALUES (:nom, :prenom, :email)";
$stmt = $pdo->prepare($sql);
$stmt->bindParam(':nom', $nom);
$stmt->bindParam(':prenom', $prenom);
$stmt->bindParam(':email', $email);

if ($stmt->execute()) {
    echo 'Insertion réussie !';
} else {
    echo 'Echec de l'insertion.';
}

Dans cet exemple, on prépare la requête SQL en utilisant la méthode prepare(). Cela permet de prévenir les injections SQL en remplaçant les paramètres par des marqueurs.

Ensuite, on lie les valeurs des paramètres aux variables PHP correspondantes en utilisant la méthode bindParam(). Enfin, on exécute la requête en utilisant la méthode execute().

Récupération de données

Pour récupérer des données de la base de données, on peut utiliser la méthode query() de l’objet PDO. Par exemple, pour sélectionner tous les utilisateurs de la table utilisateurs :

$sql = "SELECT * FROM utilisateurs";
$stmt = $pdo->query($sql);

if ($stmt->rowCount() > 0) {
    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
        echo 'ID : ' . $row['id'] . ' - Nom : ' . $row['nom'] . ' - Prénom : ' . $row['prenom'] . ' - Email : ' . $row['email'] . '
';
    }
} else {
    echo 'Aucun utilisateur trouvé.';
}

Dans cet exemple, on exécute la requête SQL en utilisant la méthode query(). La méthode rowCount() permet de vérifier si la requête a retourné des résultats.

Si c’est le cas, on utilise une boucle while pour parcourir chaque ligne de résultat et afficher les données dans un format associatif.

Transactions

Les transactions permettent de regrouper plusieurs requêtes SQL en une seule unité atomique. Cela signifie que si une requête échoue, toutes les autres requêtes de la transaction sont annulées.

Pour démarrer une transaction, on utilise la méthode beginTransaction(). Pour valider la transaction et enregistrer les modifications, on utilise la méthode commit().

Les transactions sont essentielles pour garantir l’intégrité des données dans les applications qui effectuent des opérations critiques, comme les transferts bancaires ou les réservations de vols.

Démarrage d’une transaction

Pour démarrer une transaction avec PDO, on utilise la méthode beginTransaction() de l’objet PDO.

$pdo->beginTransaction();

Exécution des requêtes SQL

Une fois la transaction démarrée, on peut exécuter plusieurs requêtes SQL. Toutes ces requêtes seront considérées comme faisant partie de la même transaction.

$pdo->beginTransaction();

// Exécuter des requêtes SQL

$pdo->commit();

Validation de la transaction

Si toutes les requêtes de la transaction se sont déroulées sans erreur, on peut valider la transaction en utilisant la méthode commit(). Cela enregistre définitivement les modifications apportées aux données dans la base de données.

$pdo->beginTransaction();

// Exécuter des requêtes SQL

$pdo->commit();

Annulation de la transaction

En cas d’erreur pendant la transaction, on peut annuler toutes les modifications en utilisant la méthode rollBack(). Cela permet de restaurer l’état de la base de données avant le début de la transaction.

$pdo->beginTransaction();

// Exécuter des requêtes SQL

if ($erreur) {
    $pdo->rollBack();
} else {
    $pdo->commit();
}

Exemple concret d’utilisation des transactions

Supposons que vous vouliez transférer 100€ du compte A vers le compte B. Pour garantir l’intégrité de la transaction, il est nécessaire de mettre à jour les soldes des deux comptes en une seule opération atomique. Voici comment le faire avec PDO :

// Commence une transaction
$pdo->beginTransaction();

try {
    // Débiter le compte A
    $sql = "UPDATE comptes SET solde = solde - 100 WHERE id = :id_compte_a";
    $stmt1 = $pdo->prepare($sql);
    $stmt1->bindParam(':id_compte_a', $id_compte_a);
    $stmt1->execute();

    // Créditer le compte B
    $sql = "UPDATE comptes SET solde = solde + 100 WHERE id = :id_compte_b";
    $stmt2 = $pdo->prepare($sql);
    $stmt2->bindParam(':id_compte_b', $id_compte_b);
    $stmt2->execute();

    // Vérifier si les deux opérations ont affecté une ligne
    if ($stmt1->rowCount() == 1 && $stmt2->rowCount() == 1) {
        // Valider la transaction
        $pdo->commit();
        echo 'Transfert effectué avec succès !';
    } else {
        // Annuler la transaction
        $pdo->rollBack();
        echo 'Échec du transfert.';
    }
} catch (Exception $e) {
    // En cas d'exception, annuler la transaction
    $pdo->rollBack();
    echo 'Échec du transfert : ' . $e->getMessage();
}
?>

Les transactions sont un outil essentiel pour garantir l’intégrité des données dans les applications qui accèdent aux bases de données.

Gestion des erreurs

Il est important de gérer correctement les erreurs lors de l’utilisation de PDO. Pour ce faire, on peut utiliser des blocs try/catch comme dans les exemples précédents. De plus, PDO fournit des informations détaillées sur les erreurs grâce à l’objet PDOException.

try {
    // Exécuter une requête SQL

} catch (PDOException $e) {
    echo 'Erreur SQL : ' . $e->getMessage() . ' (' . $e->getCode() . ')';
}

Le code d’erreur ($e->getCode()) peut être utilisé pour identifier la cause de l’erreur et prendre des mesures appropriées.

Fermeture de la connexion PDO

Une fois que vous avez terminé d’interagir avec la base de données, il est important de fermer la connexion en utilisant la méthode close() de l’objet PDO.

$pdo->close();

PDO est un outil puissant et flexible pour accéder aux bases de données en PHP. En maîtrisant les concepts fondamentaux de PDO et en suivant les bonnes pratiques, vous pouvez développer des applications PHP robustes et efficaces.

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr