De nombreux développeurs PHP peinent à sécuriser et optimiser leurs bases de données, ce qui expose leurs applications aux failles critiques comme les injections SQL.
Sans une solution unique et efficace, ils se retrouvent à jongler avec des méthodes complexes, augmentant les erreurs et compromettant à la fois la performance et la sécurité.
Avec PDO en PHP 8, centralisez vos requêtes SQL, renforcez la sécurité de vos applications et simplifiez leur gestion. Découvrez comment faire dans cet article !
Classe PDO en PHP 8 : Découverte
Imaginez que vous devez discuter avec différents systèmes de bases de données. Vous auriez besoin d’apprendre une nouvelle langue pour chaque système. Eh bien, PDO (PHP Data Objects) est là pour simplifier votre vie. C’est comme un traducteur universel pour les bases de données. Vous pouvez utiliser la même syntaxe pour interagir avec MySQL, PostgreSQL, SQLite, et bien d’autres.
La classe PDO (PHP Data Objects) est une interface orientée objet en PHP qui permet d’accéder et de manipuler différentes bases de données de manière cohérente et sécurisée. Elle fournit une abstraction de base de données, ce qui signifie que vous pouvez utiliser la même syntaxe et les mêmes fonctions pour interagir avec divers systèmes de gestion de bases de données (SGBD) tels que MySQL, PostgreSQL, SQLite, et bien d’autres.
Les Avantages de PDO
- Abstraction de Base de Données : Avec PDO, vous n’avez pas besoin de réécrire votre code si vous changez de base de données. Il suffit de modifier quelques paramètres de connexion.
- Sécurité : PDO vous permet d’utiliser des requêtes préparées, ce qui renforce la sécurité de votre application en prévenant les injections SQL.
- Gestion des Erreurs : PDO gère les erreurs de manière robuste en lançant des exceptions, ce qui facilite le débogage.
- Portabilité : En utilisant PDO, vous pouvez aisément migrer votre application d’une base de données à une autre sans grands changements de code.
PHP 8 : Créer une base de données avec PDO
Nous allons maintenant créer une base de données en PHP 8 nommée alphorm avec deux tables : salarier et restaurant.
Étape 1 : Accéder à PhpMyAdmin
- Ouvrez votre navigateur web.
- Entrez l’URL de PhpMyAdmin, généralement http://localhost/phpmyadmin si vous utilisez un serveur local comme XAMPP, WAMP, ou MAMP.
Étape 2 : Créer une Nouvelle Base de Données
- Connectez-vous à PhpMyAdmin avec votre nom d’utilisateur et mot de passe MySQL.
- Créez une nouvelle base de données appelée alphorm.
Étape 3 : Créer les Tables
- Table salarier :
Créez une table salarier avec les colonnes salarierID, nom, prenom, et restoID.
- Table restauant :
Créez une table restaurant avec les colonnes restoID et ville.
- Clés Étrangères :
Ajoutez une clé étrangère dans salarier pour relier restoID à restoID dans restaurant.
Ce concerne la table salarier voila le résultat d’affichage
Instancier la classe PDO en PHP 8
Nous allons maintenant passer à l’étape de l’instanciation de la classe PDO pour établir une connexion avec votre base de données alphorm. Pour commencer, créez un dossier et un fichier spécifiques pour organiser votre projet.
Étape 1 : Créer le Dossier et le Fichier
Créer le Dossier :
- Allez dans le répertoire htdocs de votre serveur local (par exemple, XAMPP ou WAMP).
- Créez un nouveau dossier nommé alphorm.
- Créez un nouveau dossier nommé alphorm.
Créer le Fichier de Connexion :
- Dans le dossier alphorm, créez un nouveau fichier nommé cnx.php.
Étape 2 : Écrire le Code de Connexion
Ouvrez le fichier cnx.php et ajoutez le code suivant :
<?php
$dsn="mysql:host=localhost;dbname=alphorm;charset=utf8";
$user="root";
$pass="";
try{
cnx=new PDO($dsn,$user,$pass);
}catch(PDOException $e){
echo 'error de connexion '.$e->getMessage();
}
Explications
- Créer le Dossier et le Fichier : Vous créez un dossier alphorm dans le répertoire htdocs pour organiser votre projet. Ensuite, vous créez un fichier cnx.php dans ce dossier pour gérer la connexion à la base de données.
- DSN (Data Source Name) : Vous spécifiez le type de base de données (MySQL), l’hôte (localhost), le nom de la base de données (alphorm) et le jeu de caractères (utf8) pour vous assurer que tous les caractères sont correctement codés.
- Nom d’utilisateur et mot de passe : Utilisez vos informations d’identification MySQL (root et un mot de passe vide pour un serveur local par défaut).
- Instanciation de PDO :
Vous utilisez la chaîne DSN, le nom d’utilisateur et le mot de passe pour créer une nouvelle instance de PDO.
La variable $cnx stocke cette instance.
- Options PDO :
PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION : Configurez PDO pour lancer des exceptions en cas d’erreur. Cela rend le débogage plus facile car vous obtenez des messages d’erreur détaillés.
PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC : Configurez PDO pour renvoyer les résultats des requêtes sous forme de tableaux associatifs par défaut, ce qui est souvent plus pratique.
Exemple de requête de sélection simple
Maintenant, nous allons passer à la création d’un fichier nommé selecte-simple.php. Ce fichier vous permettra d’afficher les prénoms et noms des salariés en utilisant une requête SQL simple.
Étape 1 : Créer le Fichier selecte-simple.php
Dans le dossier alphorm, créez un nouveau fichier nommé selecte-simple.php et ajoutez-y le code suivant :
?php
require_once('cnx.php');
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Afficher le prenom et le nom des salarier</title>
<style id="wpr-lazyload-bg-container"></style><style id="wpr-lazyload-bg-exclusion"></style>
<noscript>
<style id="wpr-lazyload-bg-nostyle">.jet-image-accordion__item-loader span{--wpr-bg-b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba: url('https://blog.alphorm.com/wp-content/plugins/jet-tabs/assets/images/spinner-32.svg');}.rll-youtube-player .play{--wpr-bg-6abf8c39-d959-4247-9ac4-f4db2914212c: url('https://blog.alphorm.com/wp-content/plugins/wp-rocket/assets/img/youtube.png');}</style>
</noscript>
<script type="application/javascript">const rocket_pairs = [{"selector":".jet-image-accordion__item-loader span","style":".jet-image-accordion__item-loader span{--wpr-bg-b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba: url('https:\/\/blog.alphorm.com\/wp-content\/plugins\/jet-tabs\/assets\/images\/spinner-32.svg');}","hash":"b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba","url":"https:\/\/blog.alphorm.com\/wp-content\/plugins\/jet-tabs\/assets\/images\/spinner-32.svg"},{"selector":".rll-youtube-player .play","style":".rll-youtube-player .play{--wpr-bg-6abf8c39-d959-4247-9ac4-f4db2914212c: url('https:\/\/blog.alphorm.com\/wp-content\/plugins\/wp-rocket\/assets\/img\/youtube.png');}","hash":"6abf8c39-d959-4247-9ac4-f4db2914212c","url":"https:\/\/blog.alphorm.com\/wp-content\/plugins\/wp-rocket\/assets\/img\/youtube.png"}]; const rocket_excluded_pairs = [];</script></head>
<body>
<h1>Liste des salariers</h1>
<?php
$sql="SELECT prenom, nom FROM salarie";
$req=$cnx->query($sql);
$req->setFetchMode(PDO::FETCH_ASSOC);
while($salarie=$req->fetch()){
echo $salarie['prenom'].' '.$salarie['nom'].'<br>';
}
?>
<script>class RocketElementorAnimation{constructor(){this.deviceMode=document.createElement("span"),this.deviceMode.id="elementor-device-mode-wpr",this.deviceMode.setAttribute("class","elementor-screen-only"),document.body.appendChild(this.deviceMode)}_detectAnimations(){let t=getComputedStyle(this.deviceMode,":after").content.replace(/"/g,"");this.animationSettingKeys=this._listAnimationSettingsKeys(t),document.querySelectorAll(".elementor-invisible[data-settings]").forEach(t=>{const e=t.getBoundingClientRect();if(e.bottom>=0&&e.top<=window.innerHeight)try{this._animateElement(t)}catch(t){}})}_animateElement(t){const e=JSON.parse(t.dataset.settings),i=e._animation_delay||e.animation_delay||0,n=e[this.animationSettingKeys.find(t=>e[t])];if("none"===n)return void t.classList.remove("elementor-invisible");t.classList.remove(n),this.currentAnimation&&t.classList.remove(this.currentAnimation),this.currentAnimation=n;let s=setTimeout(()=>{t.classList.remove("elementor-invisible"),t.classList.add("animated",n),this._removeAnimationSettings(t,e)},i);window.addEventListener("rocket-startLoading",function(){clearTimeout(s)})}_listAnimationSettingsKeys(t="mobile"){const e=[""];switch(t){case"mobile":e.unshift("_mobile");case"tablet":e.unshift("_tablet");case"desktop":e.unshift("_desktop")}const i=[];return["animation","_animation"].forEach(t=>{e.forEach(e=>{i.push(t+e)})}),i}_removeAnimationSettings(t,e){this._listAnimationSettingsKeys().forEach(t=>delete e[t]),t.dataset.settings=JSON.stringify(e)}static run(){const t=new RocketElementorAnimation;requestAnimationFrame(t._detectAnimations.bind(t))}}document.addEventListener("DOMContentLoaded",RocketElementorAnimation.run);</script></body>
</html>
Explications
Inclure le Fichier de Connexion :
- Vous incluez cnx.php en utilisant require_once pour vous assurer que la connexion à la base de données est établie avant d’exécuter le reste du code.
Structure HTML de Base :
- Vous commencez par la déclaration du type de document et l’ouverture des balises HTML, tête, et corps.
- Vous ajoutez un en-tête
(<h1>)pour le titre de la page.
- Vous ajoutez un en-tête
Requête SQL :
- Vous préparez une requête SQL pour sélectionner les prénoms et noms des salariés de la table salarie.
Exécuter la Requête :
- Vous exécutez la requête en utilisant la méthode query de PDO.
- Vous configurez le mode de récupération des résultats
(FETCH_ASSOC)pour obtenir les résultats sous forme de tableau associatif.
- Vous configurez le mode de récupération des résultats
Afficher les Résultats :
- Vous parcourez les résultats de la requête à l’aide d’une boucle while.
- Pour chaque salarié, vous affichez le prénom et le nom.
Gestion des erreurs SQL avec PDO en PHP 8
Dans cette section, vous allez apprendre à gérer les éventuelles erreurs SQL dans votre projet. Nous commencerons par mettre à jour le fichier cnx.php pour configurer PDO afin qu’il lance des exceptions en cas d’erreurs. Ensuite, vous modifierez le fichier selecte-simple.php pour gérer ces erreurs de manière appropriée.
Étape 1 : Mettre à Jour cnx.php
Ajoutez la ligne suivante dans votre fichier cnx.php après la création de l’instance PDO :
$cnx->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
Étape 2 : Modifier selecte-simple.php
Vous allez maintenant entourer votre code SQL dans selecte-simple.php avec un bloc try-catch pour gérer les éventuelles erreurs.
<?php
try{
$sql="SELECT prenom, nom FROM salarie";
$req=$cnx->query($sql);
$req->setFetchMode(PDO::FETCH_ASSOC);
while($salarie=$req->fetch()){
echo $salarie['prenom'].' '.$salarie['nom'].'<br>';
}
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
} ?>
Explications
- Mise à Jour de cnx.php :
Vous ajoutez PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION pour configurer PDO afin qu’il lance des exceptions en cas d’erreurs. Cela permet une gestion plus robuste et claire des erreurs SQL.
- Modification de selecte-simple.php :
Vous entourez votre code SQL avec un bloc try-catch pour capturer et gérer les exceptions.
En cas d’erreur SQL, le message d’erreur sera capturé par l’exception PDOException et affiché
Requête de sélection préparée avec PDO en PHP 8
Dans cette section, vous allez apprendre à utiliser des requêtes préparées avec PDO pour effectuer des sélections dans votre base de données. Les requêtes préparées sont particulièrement utiles pour sécuriser votre code contre les injections SQL et pour améliorer les performances des requêtes répétitives.
Étape 1 : Modifier selecte-simple.php pour Utiliser une Requête Préparée
Vous allez modifier votre fichier selecte-simple.php pour utiliser une requête préparée.
<?php
try{
$sql="SELECT prenom, nom FROM salarie";
$req=$cnx->prepare($sql);
$req->execute();
while($salarie=$req->fetch()){
echo $salarie['prenom'].' '.$salarie['nom'].'<br>';
}
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Explication de prepare
- Création d’une Requête Préparée :
La méthode prepare est appelée sur une instance PDO pour créer une requête SQL qui sera envoyée à la base de données. Cette méthode prend comme argument la requête SQL contenant des paramètres nommés ou des marqueurs de position (par exemple, :param ou ?).
- Séparation des Données et de la Requête :
Lors de la préparation, la requête SQL est envoyée à la base de données sans les valeurs des paramètres. Cela permet à la base de données de préparer le plan d’exécution de la requête. Les valeurs des paramètres seront fournies séparément lors de l’exécution de la requête.
- Sécurité Contre les Injections SQL :
En utilisant prepare, vous séparez les données de la requête SQL. Cela protège contre les injections SQL, car les paramètres sont automatiquement échappés par PDO avant d’être intégrés dans la requête finale.
- Amélioration des Performances :
Pour des requêtes répétées avec des paramètres différents, préparer la requête une seule fois et la réutiliser avec différentes valeurs peut améliorer les performances par rapport à l’exécution répétée de requêtes SQL non préparées.
Sélection conditionnée simple
Dans cette section, vous allez apprendre à effectuer une requête SQL conditionnée en utilisant PDO. La requête récupérera des données en fonction d’une condition spécifique. Vous allez examiner un code qui illustre comment effectuer cette opération.
<?php
try{
$sql="SELECT prenom, nom FROM salarie WHERE salarierID=5";
$req=$cnx->query($sql);
$data=$req->fetch(PDO::FETCH_ASSOC);
echo $data['prenom'].' '.$data['nom'];
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Explication du Code
- Définition de la Requête SQL :
La requête SQL est définie pour sélectionner les colonnes prenom et nom de la table salarie où la condition salarierID = 5 est remplie. Cette condition filtre les résultats pour ne récupérer que les informations du salarié ayant l’ID égal à 5.
- Exécution de la Requête :
La méthode query est utilisée pour exécuter la requête SQL. Contrairement aux requêtes préparées, query est généralement utilisée pour des requêtes simples et ne nécessite pas de paramètres dynamiques.
- Récupération des Données :
La méthode fetch est utilisée pour obtenir la première ligne du résultat. En utilisant PDO::FETCH_ASSOC, les données sont récupérées sous forme de tableau associatif, où les clés sont les noms des colonnes.
- Affichage des Données :
Les données récupérées sont affichées en concaténant le prénom et le nom du salarié, séparés par un espace.
- Gestion des Erreurs :
Un bloc try-catch est utilisé pour capturer et afficher les erreurs éventuelles survenant lors de l’exécution de la requête. Cela permet d’assurer que les erreurs sont gérées de manière appropriée et affichées de façon claire.
Sélection préparée conditionnée
Dans cette section, vous allez apprendre à réaliser une requête de sélection préparée avec une condition PHP 8. Les requêtes préparées sont particulièrement utiles pour sécuriser vos interactions avec la base de données, surtout lorsqu’elles incluent des valeurs dynamiques fournies par l’utilisateur.
Objectif
Vous allez créer une requête préparée qui sélectionne des données conditionnées par un paramètre, ce qui protège contre les injections SQL et améliore la performance des requêtes.
Code Exemple
<?php
try{
$sql="SELECT prenom, nom FROM salarie WHERE salarierID=?";
$req=$cnx->prepare($sql);
$req->execute(array(2));
$resultat=$req->fetch(PDO::FETCH_ASSOC);
echo $resultat->nom.' '.$resultat->prenom;
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
} ?>
Affichage des Résultats
Utilisation de marqueurs nommés avec PDO PHP 8
Dans cette section, vous allez découvrir comment utiliser des marqueurs nommés dans vos requêtes SQL avec PDO pour gérer les paramètres dynamiques de manière sécurisée et efficace. En utilisant des marqueurs comme :salarierID et :restoID, vous pouvez améliorer la lisibilité de votre code et protéger votre application contre les injections SQL. Vous apprendrez à préparer une requête SQL avec ces marqueurs, à l’exécuter en fournissant des valeurs spécifiques, et à récupérer les résultats de manière structurée. Cette approche vous permettra de créer des requêtes flexibles et sécurisées tout en simplifiant la gestion des données dynamiques.
Voici le code
<?php
try{
$sql="SELECT prenom, nom FROM salarie WHERE salarierID=:salarierID and restoID=:restoID";
$req=$cnx->prepare($sql);
$req->execute(array('salarierID'=>2,'restoID'=>1));
$resultat=$req->fetch(PDO::FETCH_ASSOC);
echo $resultat->nom.' '.$resultat->prenom;
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Voici une explication détaillée du code pour mettre en place une requête SQL avec des marqueurs nommés, sous forme de tableau :
Étape | Description | Code |
|---|---|---|
1. Définition de la Requête SQL | Vous définissez une requête SQL qui utilise des marqueurs nommés pour les paramètres. Les marqueurs :salarierID et :restoID sont utilisés pour représenter les valeurs dynamiques. | $sql = « SELECT prenom, nom FROM salarie WHERE salarierID=:salarierID and restoID=:restoID »; |
2. Préparation de la Requête | Vous préparez la requête SQL en utilisant la méthode prepare de PDO. Cela crée une requête sécurisée en utilisant les marqueurs nommés. | $req = $cnx->prepare($sql); |
3. Exécution de la Requête avec des Paramètres | Vous exécutez la requête préparée en passant un tableau associatif où les clés correspondent aux marqueurs nommés et les valeurs aux données à substituer. | $req->execute(array(‘salarierID’=>2, ‘restoID’=>1)); |
4. Récupération des Résultats | Vous récupérez les résultats de la requête en utilisant fetch, qui retourne la première ligne du résultat sous forme de tableau associatif. | $resultat = $req->fetch(PDO::FETCH_ASSOC); |
5. Affichage des Données | Vous affichez le nom et le prénom du salarié récupéré. Notez que vous utilisez la notation d’objet pour accéder aux données. | echo $resultat[‘nom’].’ ‘.$resultat[‘prenom’]; |
6. Gestion des Erreurs | Vous utilisez un bloc try-catch pour capturer et afficher les erreurs éventuelles lors de l’exécution de la requête. Cela permet de gérer les exceptions de manière appropriée. | catch (PDOException $e) { echo ‘Une erreur est survenue : ‘ . $e->getMessage(); } |
Insertion simple en PHP 8 avec PDO
Dans cette section, vous allez apprendre à réaliser une requête SQL pour insérer des données dans une table à l’aide de PDO. Vous allez créer un fichier insert.php pour exécuter une insertion simple dans la table salarie.
Code Exemple
Voici le code pour insérer des données dans la table salarie :
<?php
require_once('cnx.php');
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Insérer un salarier</title>
<style id="wpr-lazyload-bg-container"></style><style id="wpr-lazyload-bg-exclusion"></style>
<noscript>
<style id="wpr-lazyload-bg-nostyle">.jet-image-accordion__item-loader span{--wpr-bg-b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba: url('https://blog.alphorm.com/wp-content/plugins/jet-tabs/assets/images/spinner-32.svg');}.rll-youtube-player .play{--wpr-bg-6abf8c39-d959-4247-9ac4-f4db2914212c: url('https://blog.alphorm.com/wp-content/plugins/wp-rocket/assets/img/youtube.png');}</style>
</noscript>
<script type="application/javascript">const rocket_pairs = [{"selector":".jet-image-accordion__item-loader span","style":".jet-image-accordion__item-loader span{--wpr-bg-b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba: url('https:\/\/blog.alphorm.com\/wp-content\/plugins\/jet-tabs\/assets\/images\/spinner-32.svg');}","hash":"b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba","url":"https:\/\/blog.alphorm.com\/wp-content\/plugins\/jet-tabs\/assets\/images\/spinner-32.svg"},{"selector":".rll-youtube-player .play","style":".rll-youtube-player .play{--wpr-bg-6abf8c39-d959-4247-9ac4-f4db2914212c: url('https:\/\/blog.alphorm.com\/wp-content\/plugins\/wp-rocket\/assets\/img\/youtube.png');}","hash":"6abf8c39-d959-4247-9ac4-f4db2914212c","url":"https:\/\/blog.alphorm.com\/wp-content\/plugins\/wp-rocket\/assets\/img\/youtube.png"}]; const rocket_excluded_pairs = [];</script></head>
<body>
<h1> Insérer un salarier</h1>
<?php
try{
$sql="INSERT INTO salarie (nom, prenom, restoID) VALUES ('Steph', 'Morin', 1)";
$req=$cnx->exec($sql);
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
</body>
</html>
Définition de la Requête SQL :
- Code :
$sql = "INSERT INTO salarie (nom, prenom, restoID) VALUES ('Steph', 'Morin', 1)"; - Explication : Vous définissez une requête SQL pour insérer des données dans la table salarie. La requête spécifie les colonnes dans lesquelles vous souhaitez insérer des valeurs (nom, prenom, et restoID). Ensuite, vous fournissez les valeurs correspondantes à insérer (‘Steph’, ‘Morin’, et 1). Cette ligne crée une chaîne de caractères contenant l’instruction SQL qui sera envoyée à la base de données.
Exécution de la Requête SQL :
- Code :
$req = $cnx->exec($sql); - Explication : Vous exécutez la requête SQL en utilisant la méthode exec de l’objet PDO
($cnx). La méthode exec est conçue pour exécuter des requêtes SQL qui modifient les données, telles que les insertions, les mises à jour ou les suppressions. Elle retourne le nombre de lignes affectées par la requête. Dans ce cas, elle insère une nouvelle ligne dans la table salarie avec les valeurs spécifiées.
Voici le résultat d’affichage
Maîtrise Complète de PHP 8 : De l'Initiation à l'Expertise en Architecture MVC
Requête d'insertion préparée
Dans cette section, vous allez apprendre à utiliser une requête d’insertion préparée pour insérer des données dans une table à l’aide de PDO. Les requêtes préparées sont particulièrement utiles pour protéger votre application contre les injections SQL et pour gérer les valeurs dynamiques de manière sécurisée.
Code Exemple
Voici le code pour réaliser une insertion préparée :
<?php
try{
$sql="INSERT INTO salarie (nom, prenom, restoID) VALUES (?, ?, ?)";
$req=$cnx->prepare($sql);
$retour= $req->execute(array('Sylvie', 'Pierre', 2));
if($retour){
echo 'insertion OK';
}
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Voici le résultat d’affichage
Si on vérifie notre base de donnes en va trouver :
Insertion avec marqueurs nommés en PDO PHP 8
Dans cette section, vous allez apprendre à utiliser des marqueurs nommés dans une requête SQL pour insérer des données dans une table. Les marqueurs nommés permettent de rendre le code plus lisible et de faciliter la gestion des paramètres dans les requêtes SQL.
Code Exemple
Voici le code pour réaliser une insertion en utilisant des marqueurs nommés :
<?php
try{
$sql="INSERT INTO salarie (nom, prenom, restoID) VALUES (:nom, :prenom, :restoID)";
$req=$cnx->prepare($sql);
$retour=$req->execute(array('nom'=>'DUPONT','prenom'=>'Pierre','restoID'=>1));
if($retour){
echo 'salarie bien ajouter';
}
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Modification simple de données avec PDO PHP 8
Dans cette section, vous allez apprendre à réaliser une requête SQL pour modifier des données existantes dans une table à l’aide de PDO. Les requêtes de modification sont utilisées pour mettre à jour les enregistrements dans une base de données.
Code Exemple
Voici le code pour réaliser une modification simple :
<?php
try{
$sql='UPDATE salarie SET nom="Perrot", prenom="Sylvia" WHERE salarierID=8 ';
$req=$cnx->exec($sql);
if($req){
echo 'salarie modifie';
}
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Explication du Code
Définition de la Requête SQL pour la Modification :
- Code :
$sql = 'UPDATE salarie SET nom="Perrot", prenom="Sylvia" WHERE salarierID=8';
- Explication : Vous définissez une requête SQL pour mettre à jour les données dans la table salarie. La requête spécifie les nouvelles valeurs pour les colonnes nom et prenom, et utilise une condition WHERE pour cibler l’enregistrement avec un salarierID de 8. Cette condition assure que seule la ligne spécifique sera modifiée.
Exécution de la Requête SQL :
- Code :
$req = $cnx->exec($sql);
- Explication : Vous exécutez la requête SQL en utilisant la méthode exec de PDO. La méthode exec est adaptée pour les requêtes qui modifient les données (comme les mises à jour) et retourne le nombre de lignes affectées par la requête.
Vérification du Succès de la Modification :
- Code :
if ($req) { echo 'Salarié modifié'; }
- Explication : Vous vérifiez si la modification a réussi en testant la valeur retournée par exec. Si la requête a été exécutée avec succès, un message confirmant la modification est affiché.
Gestion des Erreurs :
- Code :
catch (PDOException $e) { echo 'Une erreur est survenue : ' . $e->getMessage(); }
- Explication : Un bloc try-catch est utilisé pour capturer et afficher les erreurs éventuelles qui peuvent survenir lors de l’exécution de la requête. Cela aide à diagnostiquer les problèmes et à maintenir la stabilité du code.
Voici la sortie
Requête de modification préparée avec PDO en PHP 8
Les requêtes préparées sont un excellent moyen de gérer les opérations de mise à jour dans une base de données de manière sécurisée. Elles aident à éviter les injections SQL et simplifient la gestion des paramètres dynamiques.
Code Exemple
Voici comment vous pouvez réaliser une requête de modification préparée :
<?php
try{
$sql='UPDATE salarie SET nom=?, prenom=? WHERE salarierID=8 ';
$req=$cnx->prepare($sql);
$req->execute(array('DUPONT','JEAN'));
echo 'salarie modifie';
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Explication du Code
Ligne de Code | Explication |
|---|---|
$sql = ‘UPDATE salarie SET nom=?, prenom=? WHERE salarierID=8’; | Vous définissez une requête SQL pour mettre à jour les champs nom et prenom dans la table salarie. Les marqueurs de position ? indiquent où les valeurs dynamiques seront insérées. La condition WHERE salarierID=8 cible l’enregistrement spécifique avec salarierID égal à 8. |
$req = $cnx->prepare($sql); | Vous préparez la requête SQL avec la méthode prepare de PDO. Cela sécurise la requête et vous permet d’exécuter la requête ultérieurement avec les valeurs dynamiques. |
$req->execute(array(‘DUPONT’, ‘JEAN’)); | Vous exécutez la requête préparée en fournissant les valeurs pour les marqueurs de position. Ici, ‘DUPONT’ est utilisé pour le champ nom, et ‘JEAN’ pour le champ prenom. |
echo ‘Salarié modifié’; | Vous affichez un message confirmant que l’enregistrement a été modifié avec succès. |
catch (PDOException $e) { echo ‘Une erreur est survenue : ‘ . $e->getMessage(); } | Vous utilisez un bloc try-catch pour gérer les exceptions. Si une erreur se produit lors de l’exécution de la requête, elle est capturée et un message d’erreur est affiché. |
Modifier avec des marqueurs nommés en PHP 8
Les marqueurs nommés sont une méthode utile pour réaliser des requêtes SQL préparées avec PDO. Ils rendent le code plus lisible en associant des noms explicites aux paramètres de la requête.
Code Exemple
Voici comment modifier un enregistrement en utilisant des marqueurs nommés :
<?php
try{
$sql='UPDATE salarie SET nom=:nom, prenom=:prenom , restoID=:restoID WHERE salarierID=:salarierID ';
$req=$cnx->prepare($sql);
$req->execute(array('salarierID'=>9,'nom'=>'Dufoure','prenom'=>'Sebastien','restoID'=>1));
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Voici le résultat
Suppression simple en PHP 8 avec PDO
Les requêtes de suppression permettent d’éliminer des enregistrements spécifiques de votre base de données. Il est important de les utiliser avec soin pour éviter des suppressions involontaires.
Code Exemple
Voici comment réaliser une requête de suppression simple :
<?php
try{
$sql="DELETE FROM salarie WHERE salarierID=1";
$req=$cnx->exec($sql);
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Explication du Code
Ligne de Code | Explication | |
|---|---|---|
$sql = « DELETE FROM salarie WHERE salarierID = 1 »; | Vous définissez la requête SQL pour supprimer l’enregistrement de la table salarie où salarierID est égal à 1. Cette condition spécifie l’enregistrement à supprimer.
| |
$req = $cnx->exec($sql); | Vous exécutez la requête SQL en utilisant la méthode exec de PDO. Cette méthode est appropriée pour les requêtes qui modifient la base de données sans retourner de données, comme les requêtes DELETE, INSERT ou UPDATE. | |
echo ‘Enregistrement supprimé avec succès’; | Vous affichez un message confirmant que l’enregistrement a été supprimé avec succès. | |
catch (PDOException $e) { echo ‘Une erreur est survenue : ‘ . $e->getMessage(); } | Vous utilisez un bloc try-catch pour gérer les erreurs. Si une exception se produit lors de l’exécution de la requête, elle est capturée et le message d’erreur est affiché, ce qui aide à di agnostiquer les problèmes éventuels. |
Requête de suppression préparée avec PDO en PHP 8
Les requêtes de suppression préparées vous permettent de supprimer des enregistrements de manière sécurisée en utilisant des marqueurs de position. Elles sont particulièrement utiles pour éviter les risques d’injection SQL.
Code Exemple
Voici comment vous pouvez réaliser une requête de suppression préparée :
<?php
try{
$sql="DELETE FROM salarie WHERE salarierID=?";
$req=$cnx->prepare($sql);
$retour=$req->execute(array(1));
if($retour){
echo 'salarier suprime';
}
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Explication de code
Ligne de Code | Explication |
|---|---|
$sql = « DELETE FROM salarie WHERE salarierID = ? »; | Vous définissez la requête SQL pour supprimer un enregistrement de la table salarie en utilisant un marqueur de position ? pour salarierID. Cette approche permet d’insérer dynamiquement la valeur lors de l’exécution. |
$req = $cnx->prepare($sql); | Vous préparez la requête SQL avec la méthode prepare de PDO. Cette étape sécurise la requête contre les injections SQL en préparant le modèle de la requête avec des paramètres marqués. |
$retour = $req->execute(array(1)); | Vous exécutez la requête préparée en fournissant la valeur pour le marqueur de position. Ici, 1 est la valeur pour salarierID, ce qui signifie que l’enregistrement avec cet ID sera supprimé. |
if ($retour) { echo ‘Salarié supprimé avec succès’; } else { echo ‘Aucun salarié trouvé avec cet ID’; } | Vous vérifiez le résultat de l’exécution de la requête. Si execute retourne true, cela signifie que l’enregistrement a été supprimé avec succès. Sinon, vous affichez un message indiquant qu’aucun salarié avec cet ID n’a été trouvé. |
catch (PDOException $e) { echo ‘Une erreur est survenue : ‘ . $e->getMessage(); } | Vous utilisez un bloc try-catch pour gérer les exceptions. En cas d’erreur lors de l’exécution de la requête, le message d’erreur est affiché, ce qui facilite le diagnostic des problèmes. |
Voici le résultat
Suppression avec marqueurs nommés en PHP 8
Les requêtes de suppression utilisant des marqueurs nommés permettent de supprimer des enregistrements en spécifiant des valeurs dynamiques à l’aide de noms de paramètres. Cette méthode est pratique et améliore la lisibilité du code.
Code Exemple
Voici comment vous pouvez réaliser une suppression avec des marqueurs nommés :
<?php
try{
$sql="DELETE FROM salarie WHERE salarierID=:idsalarier";
$req=$cnx->prepare($sql);
$retour=$req->execute(array('idsalarier'=>2));
if($retour){
echo 'salarier suprime';
}
}catch(PDOException $e){
echo 'error est survenue '.$e->getMessage();
}
?>
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui. Découvrez des cours variés pour tous les niveaux !
Conclusion
Au cours de cette série de sections, vous avez exploré diverses méthodes pour gérer les requêtes SQL en utilisant PDO (PHP Data Objects), en vous concentrant sur les requêtes de sélection, d’insertion, de modification et de suppression. Voici un récapitulatif des techniques abordées avant de passer à une application pratique avec PHP 8.
Technique | Description | Avantages |
|---|---|---|
Requêtes Simples | Utilisation de commandes SQL directes comme query pour les sélections ou exec pour les modifications. | – Simplicité pour des opérations basiques. – Moins de code à écrire pour des requêtes simples. |
Requêtes Préparées | Préparation des requêtes SQL avec prepare, puis exécution avec execute, utilisant des marqueurs de position (?). | – Sécurité contre les injections SQL. – Séparation des données et de la logique SQL. – Réutilisabilité du code. |
Marqueurs Nommés | Utilisation de marqueurs nommés (:nom) dans les requêtes préparées pour améliorer la lisibilité. | – Lisibilité accrue du code. – Association claire des valeurs avec les paramètres. – Prévention des erreurs. |
Gestion des Erreurs | Utilisation de blocs try-catch pour capturer les exceptions et afficher des messages d’erreur appropriés. | – Diagnostic et résolution des problèmes facilités. – Amélioration de la robustesse du code. – Meilleure gestion des erreurs. |
