Bachelor 2 – Développement web

PHP / MySQL

Dans cette page

Objectifs du cours et prérequis

Nous allons étudier les différentes fonctionnalités du PHP et de MySQL et voir comment les utiliser ensemble pour exploiter tout leur potentiel.

Maintenant que nous avons vu les grandes notions du PHP, nous allons aborder le MySQL, donc le langage SQL sur lequel MySQL repose et nous verrons les interactions entre le MySQL et le PHP.

Définition et rôle de MySQL

Le MySQL est un système de gestion de bases de données relationnelles. Une base de données est un ensemble structuré de données. Les données vont pouvoir être des informations clients (nom, adresse, mot de passe, etc.), la liste des commentaires de notre blog, le texte de nos articles, etc.

Le problème ici est qu’on ne va pas directement pouvoir interagir avec les bases de données car les données sont stockées d’une manière illisible pour un humain. Pour manipuler les données stockées dans les bases de données, nous allons devoir utiliser un langage de bases de données.

Le langage de bases de données le plus célèbre est le SQL.
SQL est l’acronyme de Structured Query Language (Langage de Requêtes Structurées).

Le système de gestion de bases de données MySQL utilise le langage SQL pour la manipulation des données des bases de données.

Les avantages du MySQL sont :

  • sa simplicité d’utilisation,
  • sa fiabilité
  • et ses performances

En plus du fait qu’on va pouvoir gérer plusieurs types de bases de données différentes si besoin avec MySQL et qu’on va pouvoir l’utiliser conjointement avec PHP.

Prenons donc un exemple concret. Imaginons que nous voulions créer un site sur lequel les utilisateurs vont pouvoir s’inscrire et s’identifier.

Nous allons créer nos formulaires d’inscription en HTML et allons ensuite récupérer les données des formulaires en PHP. Ici, nous allons vouloir enregistrer ces données dans une base de données. Une base de données n’est pas un objet mystique : ce n’est ni plus ni moins qu’un fichier « plat ».

Pour le moment, notre base de données n’existe pas. Nous allons donc devoir la créer. Pour cela, nous avons deux façons de faire : soit on passe par une application spécialisée comme PhpMyAdmin (dont nous reparlerons plus tard), soit on envoie nos requêtes SQL depuis un fichier de code.

Pour faire cela, nous allons utiliser une extension PHP (Comme PDO par exemple) qui va nous permettre de coder en MySQL.

Dans notre code MySQL, nous allons écrire différentes requêtes SQL qui vont nous permettre de créer notre base de données et d’enregistrer les données dedans.

Notre base de données est ici créée en utilisant du MySQL : cette base va donc être une base MySQL. Cela signifie que c’est ce système de gestion qui s’occupe de créer notre fichier « base de données », qui va ordonner les données et qui va le sécuriser.

Notez par ailleurs que le MySQL est un système de gestion de bases de données dit « relationnel » car les informations ne vont pas être toutes stockées au même endroit mais plutôt dans plusieurs compartiments appelés « tables » qui vont pouvoir communiquer entre elles.

L’idée principale à retenir ici et ce que je veux que vous compreniez est que nous ne pouvons pas créer ni manipuler de bases de données sans système de gestion de bases de données.

Pourquoi utiliser le PHP et le MySQL ?

Contrairement au HTML et au CSS qui sont de véritables standards, le PHP et le MySQL ont de nombreux concurrents : Python, Ruby voire JavaScript pour le PHP et PostGreSQL, Microsoft SQL Server ou encore MariaDB pour le MySQL pour ne citer qu’eux.

Pourquoi préférer le couple PHP / MySQL aux langages concurrents ? Concrètement, il n’y a pas de raison « absolue » au sens où les alternatives citées sont également des langages performants et qui possèdent certains avantages comme certains inconvénients par rapport au PHP et au MySQL.

Cependant, si le couple PHP / MySQL reste de loin le plus célèbre et le choix de référence lorsqu’on veut créer des sites dynamiques et stocker des données, c’est pour de bonnes raisons.

Le premier avantage du PHP concerne la structure de ce langage : c’est un langage à la fois très simple d’accès pour des débutants qui pourront rapidement comprendre sa syntaxe de base et réaliser leurs premiers scripts et qui va également supporter d’un autre côté des structures très complexes.

Ensuite, le PHP est un langage Open Source et donc gratuit. Il est bon de le noter car cela n’est pas forcément automatique même si les utilisateurs du web ont l’habitude du « tout gratuit ». Le PHP est également reconnu et supporté de manière universelle : il va fonctionner quasiment partout et avec l’immense majorité des architectures techniques.

Enfin, le PHP se distingue par ses performances et sa solidité : comme le langage est Open Source, n’importe qui peut contribuer à son évolution, ce qui fait qu’il est sans cesse perfectionné et qu’il ne sera à priori jamais abandonné. En outre, le PHP possède de bonnes performances d’exécution en termes de rapidité et est un langage sûr : les rares failles jamais détectées dans le langage ont toujours été corrigées dans les 24h.

Les systèmes de gestion de base de données sont également nombreux, quoiqu’ils se basent aujourd’hui pour la plupart sur du SQL standard. J’ai choisi dans ce cours d’utiliser le MySQL car c’est encore une fois le choix le plus populaire parmi les développeurs et cela pour de bonnes raisons.

Tout d’abord, il va être totalement compatible avec PHP et utilise une syntaxe SQL standard ce qui facilitera les opérations si un jour vous devez changer de système de gestion de bases de données. Ensuite et enfin le MySQL est à la fois simple d’utilisation, très robuste et offre d’excellente performances que cela soit pour une petite ou pour une grosse structure.

Introduction aux bases de données, au SQL et au MySQL

Avec l’utilisation et la manipulation des bases de données, nous entrons dans la partie « complexe » de la programmation.

Nous allons définir les différents éléments qui vont entrer dans la manipulation de ces bases de données ainsi que l’utilité de celles-ci.

Je vous conseille d’être attentifs et de ne pas vous précipiter dans l’apprentissage de vos premières requêtes SQL car vous aurez besoin de cette compréhension pour comprendre comment créer un « vrai » site.

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

Une base de données est un conteneur qui va servir à stocker toutes sortes de données : des dates, chiffres, mots, etc. de façon organisée et sans date d’expiration.

De manière pratique, une base de données va être constitué d’un ensemble de fichiers.

Pourquoi utiliser les bases de données ?

Pourquoi créer des bases de données et stocker des données dedans plutôt que simplement utiliser un fichier quelconque ?

Les bases de données possèdent deux grands avantages par rapport aux autres méthodes de stockage :

  1. Nous allons pouvoir stocker de très grandes quantités de données ;
  2. Nous allons pouvoir récupérer certaines données en particulier simplement et rapidement.

Si vous avez un nombre limité de données à stocker et peu d’opérations à faire, l’usage des bases de données peut ainsi être contestable. En revanche, dans le cas d’un blog ou d’un e-commerce par exemple, vous allez avoir besoin de stocker de nombreuses informations (informations de connexion et de profil de vos visiteurs ou clients, liste de vos produits et de leurs caractéristiques, liste des commandes, etc.) et vous allez avoir besoin de récupérer telle ou telle information très souvent (pour l’affichage d’une page produit, pour la connexion à votre site, etc.). Dans ces cas-là, l’usage d’une base de données est plus que recommandé, il est essentiel.

Qu’est-ce que le SQL ?

Le SQL est le langage principal utilisé pour accéder aux bases de données et les manipuler. Nous allons utiliser ce langage pour exécuter toutes sortes de requêtes dans une base de données : récupérer des données, les mettre à jour, en insérer de nouvelles ou même créer de nouvelles bases de données.

Le SQL est un langage à part entière : il possède sa propre syntaxe que nous allons découvrir dans les chapitres suivants.

Qu’est-ce que MySQL ?

MySQL est ce qu’on appelle un système de gestion de bases de données. De manière très schématique, c’est un programme qui va nous permettre de manipuler simplement nos bases de données.

En effet, les bases de données sont des systèmes très complexes. Nous utilisons un système de gestion de bases de données pour cacher cette complexité et effectuer simplement les opérations dont nous avons besoin sur nos bases de données.

Nous allons donc pouvoir utiliser le MySQL en PHP pour passer des ordres à nos bases de données : le MySQL va nous servir à envoyer nos requêtes écrites en SQL standard à nos bases de données.

Qu’est-ce que phpMyAdmin ?

Nous allons avoir deux moyens d’interagir avec nos bases de données MySQL : soit en envoyant nos requêtes à partir de nos fichiers de code PHP, soit directement via l’interface phpMyAdmin.

phpMyAdmin est un logiciel gratuit code en PHP qui sert à gérer directement nos bases de données MySQL. Dans phpMyAdmin, nous allons par exemple pouvoir directement créer une nouvelle base de données ou envoyer toutes sortes de requêtes SQL à nos bases de données.

phpMyAdmin est un logiciel web qui nous permet donc d’accéder directement aux données de nos bases de données et à gérer nos bases de données.

Notez que phpMyAdmin est embarqué et proposé sur tous les serveurs utilisant les bases de données MySQL. Vous allez également pouvoir y accéder en local, que vous utilisiez Wamp, Mamp ou Lamp.

Pourquoi utiliser le PHP et le MySQL si je peux directement utiliser phpMyAdmin ?

Ces deux façons d’accéder aux données de nos bases de données et de les gérer concernent des utilisations et des situations totalement différentes.

phpMyAdmin est un logiciel formidable pour créer, modifier ou effectuer des opérations directement sur nos bases de données via une interface web. En d’autres mots, il permet une utilisation manuelle de nos bases de données.

En revanche, nous n’allons pas pouvoir utiliser phpMyAdmin pour récupérer ou mettre à jour dynamiquement nos bases de données.

Par exemple, lorsqu’un utilisateur s’inscrit sur notre site, nous allons vouloir stocker différentes informations le concernant en base de données, afin de pouvoir s’en resservir par la suite : nom d’utilisateur, mot de passe, etc. Pour cela, nous devrons créer un formulaire d’inscription et utiliser le PHP et le MySQL pour traiter et stocker les données envoyées.

Pour faire très simple, vous pouvez retenir que dès qu’un utilisateur entre dans l’équation, nous allons utiliser le PHP et le MySQL. Encore une fois, phpMyAdmin ne va nous servir qu’à modifier directement et manuellement nos bases de données.

En résumé : les notions à retenir

  • On appelle base de données une collection de données stockées dans des fichiers particuliers ;
  • Les bases de données vont nous permettre de stocker de grandes quantités de données sans date d’expiration. Nous allons ensuite pouvoir manipuler ces données ;
  • Le langage des bases de données est le SQL. C’est un langage de requêtes qui va nous permettre d’accéder aux bases de données et de les manipuler ;
  • Nous n’allons pas pouvoir communiquer directement en SQL avec nos bases de données. Pour se faire, nous devrons utiliser un système de gestion de bases de données comme le MySQL ;
  • Le MySQL va nous permettre d’envoyer des requêtes SQL. Nous allons pouvoir l’utiliser avec le PHP ;
  • Nous allons pouvoir envoyer nos requêtes SQL via le MySQL de deux façons : soit dans nos fichiers de code PHP, soit en passant par l’interface phpMyAdmin, qui est un logiciel également codé en PHP ;
  • Nous allons utiliser phpMyAdmin lorsque nous voudrons effectuer des actions manuelles directes sur nos bases de données. Dès que les appels à la base de données seront conditionnés par l’utilisateur ou par un programme comme un site web, il faudra utiliser du code PHP.

Structure d’une base de données

Une base de données est généralement constituée de tables. Une table est une collection cohérente de données. Par exemple, dans le cas d’un site e-commerce, vous aurez certainement une table « Clients », une autre table « Commandes », etc.

On représente habituellement une table sous forme de tableau. Une table va ainsi être constituée de lignes qu’on appelle également entrées et de colonnes.

L’intersection entre une ligne et une colonne est ce qu’on appelle un champ. Un champ est l’équivalent d’une cellule dans un tableau et va contenir une donnée particulière (un ID, le nom d’un utilisateur, un numéro de téléphone, etc.).

Dans une table, chacun des champs d’une même ligne ou entrée va généralement être relatif à un même sujet. Si votre base de données possède une table « Clients » par exemple, la première ligne va regrouper des informations relatives à un client en particulier.

En colonne, nous allons trouver des informations de même type. Une table « Clients » par exemple pourra contenir des colonnes comme « Id du client », « nom du client », « adresse mail », « numéro de téléphone », etc.

Voici par exemple comment pourrait se présenter une table « Clients » d’un site e-commerce :

IdClientNomClientAdresseVilleCodePostalPaysMail
1Jean Martin30 avenue des AcaciasToulon83000Francejean.martin@gmail.com
2Victor Durand50 boulevard Jean JaurèsLille59000Francevictor.durand@gmail.com
3Julia Palaz113 avenue de VersaillesParis75016Franceju.palaz@gmail.com
4Chloé Joly28 rue Sainte CatherineBordeaux33000Francecjoly@outlook.fr
5Florian Buisson88 allée des sportifsLyon69002Franceflorian.b@gmail.com

Dans ce cas-là, notre table « Clients » possède 7 colonnes et 5 entrées.

Chacun de vos tables va généralement posséder une colonne de type « ID » (identifiant) qui va nous permettre par la suite d’établir des correspondances entre tables en identifiant précisément une donnée en particulier.

Par exemple, dans un site e-commerce, nous aurons généralement deux tables « Clients » et « Commandes » dans notre base de données. La table « Clients » va contenir des informations relatives à chaque client tandis que la table « Commandes » va contenir les informations relatives à chaque commande (montant, date, etc.).

Si ces deux tables ont été créées de manière intelligente, elles vont chacune contenir une colonne « ID » (« IdClient » pour la table « Clients » et « IdCommande » pour la table « Commandes »). Ces Ids vont nous permettre d’accéder et de récupérer simplement les informations relatives à un client ou à une commande,

De plus, dans ce cas précis, il va être ici très intéressant d’avoir une même colonne « Id client » dans la table « Clients » et dans la table « Commandes » pour ensuite pouvoir récupérer l’historique des commandes d’un client ainsi que les informations relatives à ce client d’un coup.

Exemple d’une base de données WordPress vue depuis phpMyAdmin

Voyons immédiatement comment se présente une « vraie » base de données en la visualisant avec phpMyAdmin et profitons-en également pour découvrir ce logiciel.

Ici, je vais vous présenter deux bases de données : l’une issue d’une installation WordPress et l’autre issue d’un PrestaShop, tous les deux vierges (sans aucune modification).

Normalement, que vous utilisiez MAMP ou WAMP, vous devriez pouvoir accéder à phpMyAdmin depuis la page d’accueil du logiciel. En cliquant sur phpMyAdmin, nous arrivons sur la page d’accueil du logiciel.

En haut de la page, vous avez différents onglets :

  • Un onglet « Bases de données » à partir duquel nous allons pouvoir créer de nouvelles bases de données en un clic ;
  • Un onglet « SQL » dans lequel nous allons pouvoir exécuter directement des requêtes SQL ;
  • Un onglet « Etat » qui nous donne des informations sur l’état / le statut du serveur ainsi que des statistiques sur les requêtes exécutées, etc. ;
  • Un onglet « Comptes d’utilisateurs » qui nous permet de gérer et d’ajouter des utilisateurs ayant les accès permettant de gérer les bases de données ;
  • Un onglet « Exporter » qui nous permet d’exporter des bases de données ;
  • Un onglet « Importer » qui nous permet d’importer des bases de données ;
  • Un onglet « Paramètres » qui va nous permettre de choisir nos préférences d’affichage, de création de bases de données ou de requêtes SQL, les paramètres par défaut lors d’un import ou d’un export, etc. ;
  • Un onglet « Réplication » qui va nous permettre de répliquer (dupliquer) une base de données en créant une base « slave » ;
  • Un onglet « Variables » qui liste toutes les variables utilisées et utilisables ainsi que leurs valeurs actuelle et globale et qui nous permet de les modifier;
  • Un onglet « Jeux de caractères » qui affiche la liste des jeux de caractères (charset) disponibles ;
  • Un onglet « Moteurs » qui affiche la liste des moteurs (engines) disponibles sur ce serveur ;
  • Un onglet « Greffons » qui correspond en fait à la liste des extensions (plugins) disponibles.

Nous n’allons pas voir ici en détail ce que signifie chaque onglet et comment utiliser telle ou telle fonctionnalité de phpMyAdmin.

Retenez simplement pour le moment que phpMyAdmin est un logiciel complet qui propose toutes les fonctionnalités nécessaires pour nous permettre de gérer les paramètres et de manipuler nos bases de données.

Pour l’instant, ce qui nous intéresse est la liste que vous pouvez voir à gauche de la page. Ceci est la liste des bases de données déjà créées.

Lorsque vous cliquez sur une base de données, vous avez accès à la liste des tables de celle-ci. Ici, nous allons particulièrement nous intéresser à mes deux bases « ps_reference » et « wp_reference » qui contiennent les tables créées automatiquement lors de l’installation en local d’un PrestaShop et d’un WordPress.

En cliquant sur la base de données « wp_reference », on peut voir que cette base contient 12 tables, dont la table « wp_comments » qui va par exemple stocker les commentaires des utilisateurs ou la table « wp_users » qui va stocker les différents utilisateurs inscrits sur notre blog et les informations les concernant.

Vous pouvez déjà voir que l’interface de phpMyAdmin nous permet d’effectuer toutes sortes d’action sur nos tables : affichage, recherche, insertion, suppression…

En cliquant sur « Structure » de la table « wp_comments », nous allons par exemple pouvoir voir la structure de notre table, c’est-à-dire les différentes colonnes de celles-ci et obtenir des informations par rapport à ces colonnes (type de données attendues, etc.).

En cliquant sur « Afficher », nous avons cette fois-ci accès à la liste des entrées c’est-à-dire, pour notre table « wp_comments », à la liste des commentaires postés sur notre blog. Comme je viens jute d’installer ce WordPress et comme je ne me suis même jamais connecté à son back office, cette table est vide car je n’ai pour le moment aucun commentaire sur mon blog (qui encore une fois n’est même pas à proprement dit créé).

Revenons maintenant en arrière et intéressons-nous cette fois ci à notre base de données « ps_reference ». En cliquant dessus, on s’aperçoit que PrestaShop a installé beaucoup plus de tables que WordPress. En effet, nous avons 250 tables dans notre base de données !

Je ne vais bien entendu pas expliquer à quoi correspond chaque table. L’idée à retenir ici est que selon les besoins d’une solution, la base de données ne va pas du tout être créée de la même manière que pour une autre solution.

Qui crée et comment créer les bases de données et les tables ?

Une nouvelle fois, en informatique, rien n’est magique et c’est bien là la difficulté de la gestion des bases de données.

Vous avez deux choix lors de la création d’un site Internet : soit utiliser une solution préconçue et prête à installer comme un PrestaShop ou un WordPress par exemple et le modifier ensuite selon vos besoins, soit créer une solution sur mesure.

Si vous choisissez d’installer une solution comme PrestaShop ou WordPress, vous n’aurez pas à vous soucier de la construction ni de la cohérence de vos bases de données. En effet, ces solutions vont se charger de créer automatiquement les tables dont elles ont besoin.

Il vous suffira simplement de créer la base de données vide et d’indiquer son nom ainsi que les bons identifiants lors de l’installation de WordPress ou PrestaShop afin que la solution arrive à établir une connexion avec votre système de gestion de bases de données et puisse créer les tables. Notez que nombre d’hébergeurs vont même faire cela à votre place en vous proposant des « installations en 1 clic ».

En revanche, si vous décidez de créer un site vous-même de A à Z et d’utiliser les bases de données, alors il va bien falloir réfléchir à la structure et celles-ci.

Pour cela, vous devrez toujours vous demander quel type de données vous souhaitez stocker et pourquoi et également comment récupérer telle ou telle donnée par la suite.

Bien créer une base de données requiert une grande expérience en tant que développeur et gestionnaire de projet, et également une capacité d’anticipation et une vision d’ensemble du projet. Si vous devez un jour créer une structure relativement complexe, la simple création de la structure de votre base de données peut prendre des mois !

Se connecter à MySQL en PHP : les API proposées par le PHP

Pour pouvoir manipuler nos bases de données MySQL en PHP (sans passer par phpMyAdmin), nous allons déjà devoir nous connecter à MySQL.

Pour cela, le PHP met à notre disposition deux API (Application Programming Interface) :

  • L’extension MySQLi ;
  • L’extension PDO (PHP Data Objects).

Note : Auparavant, nous pouvions également utiliser l’extension MySQL. Cependant, cette extension est désormais dépréciée et a été remplacée par MySQLi (« i » signifie « improved », c’est-à-dire « amélioré » en français).

Quelle API préférer : MySQLi ou PDO ?

Le PHP nous fournit donc deux API pour nous connecter à MySQL et manipuler nos bases de données.

Chacune de ces deux API possède des forces différentes et comme vous vous en doutez elles ne sont pas forcément interchangeables.

Il existe notamment une différence notable entre ces deux API : l’extension MySQLi ne va fonctionner qu’avec les bases de données MySQL tandis que PDO va fonctionner avec 12 systèmes de bases de données différents.

Pour cette raison, nous préférerons généralement le PDO car si vous devez un jour utiliser un autre système de bases de données, le changement sera beaucoup plus simple que si vous avez tout codé en MySQLi auquel cas vous devrez réécrire le code dans son ensemble.

En termes de fonctionnement, MySQLi et PDO sont tous les deux orienté objet (bien que MySQLi propose également une API en procédural), et ils supportent également tous les deux les requêtes préparées qui servent à se prémunir des injections SQL (nous reparlerons de cela dans la suite du cours).

Connexion au serveur avec MySQLi orienté objet

Pour se connecter au serveur et accéder à nos bases de données MySQL en MySQLi orienté objet, nous allons avoir besoin de trois choses : le nom du serveur, un nom d’utilisateur (avec des privilèges de type administrateur) et son mot de passe.

Dans le cas où votre site est hébergé sur un serveur, votre hébergeur vous donnera ces différents éléments. Ici, bien évidemment, nous travaillons en local. Le nom de notre serveur est donc localhost.

Concernant les identifiants au serveur local, ils peuvent changer selon vos paramétrages et selon le système que vous utilisez. Cependant, si vous disposez des réglages par défaut, le nom d’utilisateur devrait toujours être root et le mot de passe associé devrait être soit root soit une chaine de caractère vide.

Nous allons devoir procéder à deux opérations lors de la connexion au serveur : se connecter à proprement parler et vérifier que la connexion a bien été établie et si ce n’est pas le cas afficher le message d’erreur correspondant.

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
            $servername = 'localhost';
            $username = 'root';
            $password = 'root';
            
            //On établit la connexion
            $conn = new mysqli($servername, $username, $password);
            
            //On vérifie la connexion
            if($conn->connect_error){
                die('Erreur : ' .$conn->connect_error);
            }
            echo 'Connexion réussie';
        ?>
    </body>
</html>

Pour se connecter, nous instancions la classe prédéfinie mysqli en passant au constructeur les informations suivantes : nom du serveur auquel on doit se connecter, nom d’utilisateur et mot de passe.

Nous stockons les informations de connexion dans un objet qu’on appelle ici $conn. Cet objet représente notre connexion en soi.

Ensuite, nous devons tester que la connexion a bien été établie car dans le cas où celle-ci échoue on voudra renvoyer un message d’erreurIl est en essentiel de considérer les potentielles erreurs de connexion à nos bases de données pour éviter que des utilisateurs mal intentionnés tentent de récupérer les informations relatives à la tentative de connexion.

Pour cela, nous utilisons la propriété connect_error de la classe mysqli qui retourne un message d’erreur relatif à l’erreur rencontrée en cas d’erreur de connexion MySQL ainsi que la fonction die() pour stopper l’exécution du script en cas d’erreur.Attention : La propriété connect_error de mysqli ne fonctionne correctement que depuis la version 5.3 de PHP. Utilisez la fonction mysqli_connect_error() pour les versions antérieures.

Notez ici qu’on aurait également pu utiliser les exceptions et des blocs try et catch pour gérer les erreurs potentielles. Je voulais juste vous présenter une autre manière de faire ici.

Dans le cas où la connexion réussit, on se contente d’afficher un message « connexion réussie ».

Si vous désirez la liste complète des propriétés et méthodes de la classe mysqli, je vous invite à consulter la documentation officielle.

Connexion au serveur avec MySQLi procédural

Nous allons également pouvoir utiliser un script en procédural avec MySQLi pour nous connecter au serveur et à la base de données MySQL.

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
            $servername = 'localhost';
            $username = 'root';
            $password = 'root';
            
            //On établit la connexion
            $conn = mysqli_connect($servername, $username, $password);
            
            //On vérifie la connexion
            if(!$conn){
                die('Erreur : ' .mysqli_connect_error());
            }
            echo 'Connexion réussie';
        ?>
    </body>
</html>

Ce script ressemble à priori au précédent et pourtant il est bien très différent : nous n’avons cette fois-ci plus recours à notre classe mysqli ni à l’orienté objet.

A la place, nous utilisons les fonctions mysqli_connect() pour nous connecter à la base de données et mysqli_connect_error() pour obtenir des informations sur l’erreur de connexion si il y en a une.

En dehors de ça, le principe reste le même : nous devons toujours fournir le nom du serveur ainsi que des identifiants de connexion (nom d’utilisateur et mot de passe) pour se connecter avec la fonction mysqli_connect() et nous prenons toujours en charge les cas d’erreur de connexion et stoppant l’exécution du script avec la fonction die().

Connexion au serveur avec PDO

Pour se connecter en utilisant PDO, nous allons devoir instancier la classe PDO en passant au constructeur la source de la base de données (serveur + nom de la base de données) ainsi qu’un nom d’utilisateur et un mot de passe.

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
  $servername = 'localhost';
  $username   = 'root';
  $password   = 'root';
  $dbname     = 'bddtest';
  try {
    $conn = new PDO('mysql:host=' . $servername . ';dbname=' . $dbname . ';', $username, $password);
  } catch (PDOException $e) {
    echo 'Connexion échouée : ' . $e->getMessage();
  }
        ?>
    </body>
</html>

Vous pouvez déjà remarquer ici que pour se connecter à une base de données avec PDO, vous devez passer son nom dans le constructeur de la classe PDO. Cela implique donc qu’il faut que la base ait déjà été créée au préalable (avec phpMyAdmin par exemple) ou qu’on la crée dans le même script.

Notez également qu’avec PDO il est véritablement indispensable que votre script gère et capture les exceptions (erreurs) qui peuvent survenir durant la connexion à la base de données.

En effet, si votre script ne capture pas ces exceptions, l’action par défaut du moteur Zend (plus de détail sur le moteur ici) va être de terminer le script et d’afficher une trace. Cette trace contient tous les détails de connexion à la base de données (nom d’utilisateur, mot de passe, etc.). Nous devons donc la capturer pour éviter que des utilisateurs malveillants tentent de la lire.

Création d’une base de données

Nous allons pouvoir créer une nouvelle base de données en PHP en utilisant la requête SQL CREATE DATABASE suivie du nom que l’on souhaite donner à notre base de données.
Note : A partir de maintenant, nous allons commencer à découvrir et à utiliser le langage SQL. Nous allons envoyer nos requêtes SQL via MySQLi en PHP.

Voyons immédiatement le code de création d’une base de données que nous appellerons « test ».

<?php
define('MYSQL_SERVEUR', 'localhost');
define('MYSQL_UTILISATEUR', 'root');
define('MYSQL_MOTDEPASSE', '');
define('MYSQL_BASE', 'test');

$mysql = new MySQLi(MYSQL_SERVEUR,
                    MYSQL_UTILISATEUR,
                    MYSQL_MOTDEPASSE,
                    MYSQL_BASE);
$sql = 'CREATE DATABASE test)';
$mysql->query($sql);
?>

On commence déjà par se connecter au serveur.

Ensuite, nous écrivons notre requête SQL que nous enfermons dans une variable pour une plus grande liberté d’utilisation par la suite. Notez qu’on aurait aussi bien pu placer la requête directement en argument de query(). Par convention, nous écrirons toujours nos requêtes SQL en majuscule pour bien les séparer du reste du code.

Vous pouvez aller vérifier dans votre phpMyAdmin, la nouvelle base de données a bien été créée.

Création d’une table

Une base de données est constituée de tables. Les tables sont les « casiers » dans lesquelles nous allons stocker nos données. Mais avant de pouvoir stocker des données, il va déjà falloir apprendre à créer des tables dans notre base de données !

Pour créer une nouvelle table dans une base de données, nous allons utiliser la requête SQL CREATE TABLE suivie du nom que l’on souhaite donner à notre table et nous allons également pouvoir préciser entre parenthèse le nom des colonnes de notre table ainsi que le type de données qui doit être stocké dans chaque colonne.Le MySQL nous offre beaucoup de choix de types de données différent nous permettant de créer des tables de manière vraiment précise. Pour le moment, vous pouvez retenir qu’il existe quatre grands types de données principaux en MySQL : les données de type texte, les données de type nombre, les données de type date et les données de type spacial. Vous pouvez retrouver la liste complète des types de valeur en fin de section, dans l’annexe dédiée.

Les sous types de valeurs les plus courants et les plus utilisés sont :

  • INT : accepte un nombre entier de 4 octets. La fourchette pour les entiers relatifs est [-2 147 483 648, 2 147 483 647], celle pour les entiers positifs est [0, 4 294 967 295] ;
  • VARCHAR : accepte une chaine de longueur variable (entre 0 et 65 535 caractères). La longueur effective réelle de la chaine dépend de la taille maximum d’une ligne ;
  • TEXT : accepte une chaine de caractère d’une longueur maximum de 65 535 caractères ;
  • DATE : accepte une date se situant entre le 1er janvier de l’an 1000 et le 31 décembre de l’an 9999.

En plus de cela, nous allons également pouvoir spécifier des attributs ou contraintes pour chacune des colonnes de notre table. Ces attributs ou contraintes vont venir apporter des contraintes supplémentaires sur les données attendues (non nulle, etc.) ou vont définir des comportements.

Voici les attributs qu’on va pouvoir ajouter à nos colonnes durant la création de notre table :

  • NOT NULL – Signifie que chaque entrée doit contenir une valeur pour cette colonne. La valeur null n’est pas acceptée ;
  • UNIQUE – Chacune des valeurs dans la colonne doit être unique (est utile par exemple lorsqu’on reçoit des adresses mail, cela évite qu’un utilisateur s’inscrive deux fois sur notre site entre autres) ;
  • PRIMARY KEY – Est utilisé pour identifier de manière unique chaque nouvelle entrée dans une table. C’est une combinaison de NOT NULL et de UNIQUE. PRIMARY KEY ne doit s’appliquer qu’à une colonne dans une table mais chaque table doit obligatoirement posséder une colonne avec une PRIMARY KEY. La colonne avec PRIMARY KEY est souvent une colonne d’ID (nombres) qui s’auto-incrémentent ;
  • FOREIGN KEY – Utilisée pour empêcher des actions qui pourraient détruire les liens entre des tables. La FOREIGN KEY sert à identifier une colonne qui est identique à une colonne portant une PRIMARY KEY dans une autre table ;
  • CHECK – Sert à s’assurer que toutes les valeurs dans une colonne satisfont à une certaine condition ou se trouve dans un certain intervalle spécifié ;
  • DEFAULT value – Sert à définir une valeur par défaut qui va être renseignée si aucune valeur n’est fournie ;
  • AUTO_INCREMENT – MySQL va automatiquement incrémenter (c’est-à-dire ajouter 1) au champ pour chaque nouvelle entrée ;
  • UNSIGNED – Utilisé pour les données de type nombre, cette contrainte permet de limiter les données reçues aux nombres positifs (0 inclus).
<?php
define('MYSQL_SERVEUR', 'localhost');
define('MYSQL_UTILISATEUR', 'root');
define('MYSQL_MOTDEPASSE', '');
define('MYSQL_BASE', 'test');

$mysql = new MySQLi(MYSQL_SERVEUR,
                    MYSQL_UTILISATEUR,
                    MYSQL_MOTDEPASSE,
                    MYSQL_BASE);
$sql = "CREATE TABLE Clients(
                        Id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                        Nom VARCHAR(30) NOT NULL,
                        Prenom VARCHAR(30) NOT NULL,
                        Adresse VARCHAR(70) NOT NULL,
                        Ville VARCHAR(30) NOT NULL,
                        Codepostal INT UNSIGNED NOT NULL,
                        Pays VARCHAR(30) NOT NULL,
                        Mail VARCHAR(50) NOT NULL,
                        DateInscription TIMESTAMP,
                        UNIQUE(Mail))";
$mysql->query($sql);
$mysql->close();
?>

Ici, nous créons donc la table « Clients » en utilisant la requête SQL CREATE TABLE Clients. Entre les parenthèses, nous précisons les colonnes que doit contenir la table en indiquant déjà le type de données attendues et les contraintes relatives à chaque colonne et en définissant l’une de nos colonnes comme PRIMARY KEY.

La syntaxe du SQL nous impose de séparer la déclaration de chaque colonne par une virgule.

Les chiffres entre parenthèses après les VARCHAR sont facultatifs : ils permettent juste d’indiquer le maximum de caractère que la colonne peut accepter pour une valeur. Indiquer cela permet d’optimiser très marginalement la table mais est surtout considéré comme une bonne pratique.

Le type de valeur TIMESTAMP signifie que la date courante sera stockée lors de chaque nouvelle entrée dans la table.

Finalement, vous pouvez remarquer qu’on ajoute une contrainte UNIQUE pour notre colonne Mail de manière un peu différente du reste. C’est l’écriture conseillée en SQL.

Vous pouvez vérifier dans phpMyAdmin que la table a bien été créée avec ses colonnes en cliquant sur le nom de la table dans notre base de données puis en cliquant sur « Structure ».

Création d’une BDD et d’une table avec phpMyAdmin

Il va être très facile de créer une base de données et une table avec l’outil phpMyAdmin. Cependant, encore une fois, la limite est que nous devons faire cela « manuellement » et non pas dynamiquement.

Pour cela, rendez-vous sur la page d’accueil de phpMyAdmin. A partir de là, vous pouvez soit cliquer sur « Nouvelle base de données » dans la colonne de gauche, soit sur l’onglet « Bases de données en haut ».

Une fois arrivé ici, renseignez le nom de la base de données que vous souhaitez créer (on peut par exemple l’appeler « test2 ») et cliquez sur « créer ».

phpMyAdmin crée la table et vous amène sur une page vous permettant déjà de créer une première table. Vous pouvez revenir sur cette même page en cliquant sur le nom de la base de données créée dans la liste des bases à gauche de votre page.

Créons donc à nouveau une table « Clients » avec cette fois-ci simplement 4 colonnes pour aller plus vite.

A partir de là, on vous propose de définir les colonnes de la table. Notre première colonne va se nommer Id, acceptant des données de type INT, UNSIGNED, PRIMARY KEY et AUTO_INCREMENT. Notre deuxième colonne est une colonne Nom, acceptant des données de type VARCHAR(30) et NOT NULL. Idem pour notre troisième colonne Prenom et finalement notre dernière colonne contient les dates d’inscription de nos clients.

Notez que dans phpMyAdmin, il suffit de ne pas cocher la case « Null » pour que notre colonne possède la contrainte NOT NULL.

Nous n’avons plus qu’à cliquer sur « Sauvegarder » afin que notre table et nos colonnes soient définitivement créées.

Une fois notre base de données et nos premières tables créées, nous allons pouvoir commencer à insérer des données dans ces dernières.

Insérer des données dans une table

Pour insérer des données dans une table, nous allons cette fois-ci utiliser l’instruction SQL INSERT INTO suivie du nom de la table dans laquelle on souhaite insérer une nouvelle entrée avec sa structure puis le mot clef VALUES avec les différentes valeurs à insérer.

Concrètement, la structure de la requête SQL va être la suivante :

INSERT INTO nom_de_table (nom_colonne1, nom_colonne2, nom_colonne3, …)
 VALUES (valeur1, valeur2, valeur3, …)

Il y a cependant quelques règles de syntaxe à respecter afin que cette requête fonctionne :

  • Les valeurs de type chaine de caractère (String) doivent être placées entre apostrophes ;
  • La valeur NULL ne doit pas être placée entre apostrophes ;
  • Les valeurs de type numérique ne doivent pas être placées entre apostrophes.

A priori, vous devriez avoir autant de valeurs à insérer qu’il y a de colonnes dans votre table. Cependant, notez qu’il n’est pas nécessaire de préciser les colonnes possédant un attribut AUTO_INCREMENT ou TIMESTAMP ni leurs valeurs associées puisque par définition MySQL stockera automatiquement les valeurs courantes.

Reprenons par exemple notre table « Clients » créée dans la leçon précédente. Cette table possède neuf colonnes dont une colonne Id avec un attribut AUTO_INCREMENT et une colonne DateInscription qui possède un attribut TIMESTAMP.

Essayons d’insérer une première entrée dans cette table en utilisant PHP.

<?php
define('MYSQL_SERVEUR', 'localhost');
define('MYSQL_UTILISATEUR', 'root');
define('MYSQL_MOTDEPASSE', '');
define('MYSQL_BASE', 'test');

$mysql = new MySQLi(MYSQL_SERVEUR,
                    MYSQL_UTILISATEUR,
                    MYSQL_MOTDEPASSE,
                    MYSQL_BASE);

$sql = "INSERT INTO Clients(Nom,Prenom,Adresse,Ville,Codepostal,Pays,Mail)
                        VALUES('Jean','Martin','Quai d\'Europe','Toulon',83000,'France','jean.martin@gmail.com')";
$mysql->query($sql);

$mysql->close();
?>

Ici, on insère dans notre table Clients une entrée. Pour cela, on utilise INSERT INTO et on précise le nom des colonnes pour lesquelles on doit renseigner une valeur : Nom, Prénom, Adresse, Ville, Codepostal, Pays et Mail.

Ensuite, dans la même requête SQL, on transmet les valeurs relatives à ces colonnes. Le reste du script est très classique (connexion à la base de données, exécution de notre requête SQL et gestion des exceptions).

Notez une nouvelle fois que nous n’avons pas à préciser nos colonnes Id et DateInscription ni les valeurs relatives à ces colonnes puisque celles-ci possèdent respectivement un AUTO_INCREMENT et un TIMESTAMP. Le MySQL mettra donc à jour les valeurs automatiquement par lui-même.

Une fois notre code exécuté, nous pouvons aller voir notre table dans phpMyAdmin pour voir si l’entrée a bien été ajoutée comme on le désirait.

Insérer plusieurs entrées dans une table

Nous allons tout simplement pouvoir réutiliser l’écriture précédente en la répétant plusieurs fois.

<?php
define('MYSQL_SERVEUR', 'localhost');
define('MYSQL_UTILISATEUR', 'root');
define('MYSQL_MOTDEPASSE', '');
define('MYSQL_BASE', 'test');

$mysql = new MySQLi(MYSQL_SERVEUR,
                    MYSQL_UTILISATEUR,
                    MYSQL_MOTDEPASSE,
                    MYSQL_BASE);

$sql = "INSERT INTO Clients(Nom,Prenom,Adresse,Ville,Codepostal,Pays,Mail)
                        VALUES('Durand','Victor','Rue des Acacias','Brest',29200,'France','v.durand@gmail.com')";
$mysql->query($sql);

$sql = "INSERT INTO Clients(Nom,Prenom,Adresse,Ville,Codepostal,Pays,Mail)
                        VALUES('Julia','Joly','Rue du Hameau','Lyon',69001,'France','july@gmail.com')";
$mysql->query($sql);

$mysql->close();
?>

Préparer ses requêtes : comment ça marche ?

Si vous devez exécuter des requêtes similaires plusieurs fois d’affilée, il va alors être très intéressant d’utiliser ce qu’on appelle des requêtes préparées.

Les requêtes préparées sont des requêtes qui vont être créées en trois temps : la préparation, la compilation et l’exécution.

Tout d’abord, une première phase de préparation dans laquelle nous allons créer un template ou schéma de requête, en ne précisant pas les valeurs réelles dans notre requête mais en utilisant plutôt des marqueurs nommés (sous le forme :nom) ou des marqueurs interrogatifs (sous la forme ?).

Ces marqueurs nommés ou interrogatifs (qu’on peut plus globalement nommer marqueurs de paramètres) vont ensuite être remplacés par les vraies valeurs lors de l’exécution de la requête. Notez que vous ne pouvez pas utiliser les marqueurs nommés et les marqueurs interrogatifs dans une même requête SQL, il faudra choisir l’un ou l’autre.

Une fois le template créé, la base de données va analyser, compiler, faire des optimisations sur notre template de requête SQL et va stocker le résultat sans l’exécuter.

Finalement, nous allons lier des valeurs à nos marqueurs et la base de données va exécuter la requête. Nous allons pouvoir réutiliser notre template autant de fois que l’on souhaite en liant de nouvelles valeurs à chaque fois.

Utiliser des requêtes préparées va nous offrir deux principaux avantages par rapport à l’exécution directe de requêtes SQL :

  • Nous allons gagner en performance puisque la préparation de nos requêtes ne va être faite qu’une fois quel que soit le nombre d’exécutions de notre requête ;
  • Le risque d’injection SQL est minimisé puisque notre requête est pré-formatée et nous n’avons donc pas besoin de protéger nos paramètres ou valeurs manuellement.

Un premier point sur l’injection SQL

Jusqu’à présent, nous avons fourni nous-mêmes les valeurs à insérer en base de données. Cependant, en pratique, nous allons très souvent stocker et manipuler des données envoyées directement par les utilisateurs.

Le gros souci par rapport aux données envoyées par les utilisateurs est que vous devez toujours vous en méfier : vous n’êtes jamais à l’abri d’une étourderie ou d’un comportement volontairement malfaisant.

Jusqu’ici, nos requêtes n’étaient pas du tout protégées contre ce type de comportements. Pour bien comprendre cela, imaginez que vous récupériez les valeurs à insérer dans notre table Clients créée précédemment à partir d’un formulaire.

Vous demandez donc aux utilisateurs de rentrer leur nom, prénom, adresse, etc. Sans plus de vérification, rien n’empêche un utilisateur d’envoyer une valeur qui va soit faire planter notre script soit éventuellement altérer notre base de données.

<?php
define('MYSQL_SERVEUR', 'localhost');
define('MYSQL_UTILISATEUR', 'root');
define('MYSQL_MOTDEPASSE', '');
define('MYSQL_BASE', 'test');

$mysql = new MySQLi(MYSQL_SERVEUR,
                    MYSQL_UTILISATEUR,
                    MYSQL_MOTDEPASSE,
                    MYSQL_BASE);
/*On imagine qu'on récupère les valeurs suivantes à partir d'un formulaire envoyé
*par les utilisateurs*/
$nom = "Richard";
$prenom = "Pierre";
$adresse = "Rue de la Chèvre";
$ville = "Toulon";
$cp = 83000;
$pays = "France";
$mail = "'gg@gmail.com'),('a','b','c','d',1,'e','f'";

$sql = "INSERT INTO Clients(Nom,Prenom,Adresse,Ville,Codepostal,Pays,Mail)
                        VALUES('Durand','Victor','Rue des Acacias','Brest',29200,'France','v.durand@gmail.com')";
$mysql->query($sql);

$sql = "INSERT INTO Clients(Nom,Prenom,Adresse,Ville,Codepostal,Pays,Mail)
                        VALUES('Julia','Joly','Rue du Hameau','Lyon',69001,'France','july@gmail.com')";
$mysql->query($sql);

$mysql->close();
?>

Ici, nous avons précisé une valeur habile dans notre variable $mail qui nous a permis d’insérer deux entrées d’un coup en utilisant une syntaxe non recommandée mais qui fonctionne toujours qui précise les différentes valeurs des entrées à insérer en séparant les groupes par des virgules.

En effet, regardons plus attentivement ce que ça donne lorsqu’on remplace notre variable par son contenu dans le code ci-dessus.

$sql = "INSERT INTO Clients(Nom,Prenom,Adresse,Ville,Codepostal,Pays,Mail)
        VALUES($nom,$prenom,$adresse,$ville,$cp,$pays,'gg@gmail.com'),
              ('a','b','c','d',1,'e','f')";

Dans ce cas-là, deux nouvelles entrées vont être insérées dans notre table. Ici, nous restons dans la catégorie des cas « gênants » mais non dangereux.

Cependant, rien n’aurait empêché cet utilisateur d’insérer une autre commande SQL pour lire le contenu de notre base de données, la modifier ou encore la supprimer !

Pour cette raison, vous devez une nouvelle fois faire toujours très attention dès que vous recevez des données utilisateur et ajouter différents niveaux de sécurité (sécuriser ses formulaires en utilisant les regex, neutraliser les injections en PHP, préparer ses requêtes, etc.).

Les méthodes execute(), bindParam() et bindValue()

Pour exécuter une requête préparée, nous allons cette fois-ci devoir utiliser la méthode execute() et non plus exec() comme on utilisait depuis le début de ce cours.

En utilisant des marqueurs dans nos requêtes préparées, nous allons avoir deux grandes options pour exécuter la méthode execute() :

  • On va pouvoir lui passer un tableau de valeurs de paramètres (uniquement en entrée) ;
  • On va pouvoir d’abord appeler les méthodes bindParam() ou bindValue() pour respectivement lier des variables ou des valeurs à nos marqueurs puis ensuite exécuter execute().

Pas d’inquiétude, je vous explique immédiatement les différences concrètes entre ces méthodes et les cas d’utilisation !

Commencez déjà par noter que passer un tableau directement en valeur de execute() devrait être considéré comme la méthode par défaut puisque c’est finalement la plus simple et que tout va fonctionner normalement dans l’immense majorité des cas.

En fait, execute(array) est une méthode d’écriture raccourcie ; l’idée derrière cela est qu’une boucle va être exécutée en tâche de fond dont l’objet va être d’appeler bindValue() sur chacun des éléments du tableau.

En utilisant execute(array), les valeurs vont être liées en tant que type String excepté pour le type NULL qui restera inchangé. Cela va fonctionner une nouvelle fois dans l’immense majorité des cas.

Quelle différence entre bindParam() et bindValue() ?

La méthode bindParam() va lier un paramètre à un nom de variable spécifique et la variable va être liée en tant que référence et ne sera évaluée qu’au moment de l’appel à la méthode execute().

Si la variable change de valeur entre l’appel à la méthode bindParam() et l’appel à la méthode execute(), c’est donc la dernière valeur qui sera utilisée.

La méthode bindValue() va elle associer directement une valeur à un paramètre.

<?php
$mysqli = new mysqli("example.com", "user", "password", "database");
if ($mysqli->connect_errno) {
    echo "Echec lors de la connexion à MySQL : (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
}

/* Requête préparée, étape 1 : la préparation */
if (!($stmt = $mysqli->prepare("INSERT INTO 
                    Clients(Nom,Prenom,Adresse,Ville,Codepostal,Pays,Mail)
                    VALUES (?, ?, ?, ?, ?, ?, ?)"))) {
    echo "Echec de la préparation : (" . $mysqli->errno . ") " . $mysqli->error;
}
$stmt->bind_param("sssssss", $nom, $prenom, $adresse, $ville, $cp, $pays, $mail);

$nom = "Tom";
$prenom = "Dubois";
$adresse = "Rue du Chene";
$ville = "Nice";
$cp = 06000;
$pays = "France";
$mail = "duboistom@gmail.com";

/* Requête préparée, étape 2 : lie les valeurs et exécute la requête */
if (!$stmt->execute()) {
    echo "Echec lors de l'exécution de la requête : (" . $stmt->errno . ") " . $stmt->error;
}

/* Il est recommandé de fermer explicitement */
$stmt->close();
?>

Voilà tout pour les requêtes préparées ! Si ces nouvelles choses vous semblent floues, prenez le temps de relire ce chapitre et de refaire les exemples.

Dans tous les cas, nous allons beaucoup nous resservir des requêtes préparées par la suite donc vous devriez les assimiler et les maitriser rapidement.

Modifier les données d’une table

Dans de nombreux cas, nous devrons mettre à jour les données dans nos bases de données. Ce sera par exemple le cas lorsqu’un utilisateur va mettre à jour une adresse de livraison ou une adresse mail, ou encore lorsqu’une valeur de type date doit être remplacée régulièrement comme une date d’expiration ou la date de dernier achat d’un client.

Il va être beaucoup plus rare d’intervenir directement sur la structure d’une table qui devrait normalement être fixe mais cependant cela peut arriver dans des cas de refonte ou de mise en conformité avec de nouvelles fonctionnalités, lois, etc.

Mettre à jour des données dans une table

Nous allons utiliser l’instruction SQL UPDATE suivie du nom de la table pour mettre à jour des données dans une table.

Cette instruction va toujours être accompagnée de SET qui va nous servir à préciser la colonne à mettre à jour ainsi que la nouvelle valeur pour la colonne.

En s’arrêtant là, en effet, nous allons mettre à jour toutes les valeurs d’une colonne d’un coup ! Ce sera très rarement ce que nous voudrons faire en pratique, et c’est pour cela que nous allons généralement également utiliser la clause WHERE pour spécifier quelles entrées doivent être mises à jour.

Pour exemple, nous allons cette fois nous appuyer sur une table nommée « Users » qui appartient à ma base de données « test » et contient 4 colonnes :

  • Une colonne « Id », type INT, UNISGNED, PRIMARY KEY, AUTO_INCREMENT
  • Une colonne « Prenom », type VARCHAR(30) NOT NULL
  • Une colonne « Nom », type VARCHAR(30) NOT NULL
  • Une colonne « Mail », type VARCHAR(30) NOT NULL

Nous allons pour le moment nous contenter d’ajouter 3 entrées dans cette table.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset='utf-8'>                
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
        define('MYSQL_SERVEUR', 'localhost');
        define('MYSQL_UTILISATEUR', 'root');
        define('MYSQL_MOTDEPASSE', '');
        define('MYSQL_BASE', 'test');
         
        $mysqli = new MySQLi(MYSQL_SERVEUR,
                            MYSQL_UTILISATEUR,
                            MYSQL_MOTDEPASSE,
                            MYSQL_BASE);

        if ($mysqli->connect_errno) {
            echo "Echec lors de la connexion à MySQL : (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
        }
        //Crée la table Users
        $sql = "CREATE TABLE Users (
          id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
          Prenom VARCHAR(30) NOT NULL,
          Nom VARCHAR(30) NOT NULL,
          Mail VARCHAR(50) NOT NULL
        )";
        $mysqli->query($sql);
        /* Requête préparée, étape 1 : la préparation */
        if (!($stmt = $mysqli->prepare("INSERT INTO Users (Prenom, Nom, Mail)
                          VALUES (?, ?, ?)"))) {
            echo "Echec de la préparation : (" . $mysqli->errno . ") " . $mysqli->error;
        }
        $stmt->bind_param("sss", $prenom, $nom, $mail);
         
        //Insère une première entrée
        $prenom = "Pierre"; $nom = "Giraud"; $mail = "pierre.giraud@edhec.com";
        $stmt->execute();

        //Insère une deuxième entrée
        $prenom = "Victor"; $nom = "Durand"; $mail = "v.durandd@edhec.com";
        $stmt->execute();

        //Insère une troisième entrée
        $prenom = "Julia"; $nom = "Joly"; $mail = "july@gmail.com";
        $stmt->execute();
        echo "Parfait, tout s'est bien passé";
        ?>
    </body>
</html>

On s’aperçoit qu’il y a un « d » en trop dans l’adresse mail de notre utilisateur « Victor Durand », utilisons donc UPDATE pour SET une nouvelle valeur pour la colonne mail de cet utilisateur.

Pour ne mettre à jour que la valeur du mail correspondant à cette entrée, nous allons également utiliser WHERE en donnant une condition sur l’id.
Bon à savoir : Nous ne sommes pas obligés d’utiliser la clause WHERE sur la colonne « id », nous pouvons tout aussi bien donner une condition sur n’importe quelle autre colonne. Cependant, en pratique, nous nous appuierons très souvent sur cette fameuse colonne « id » car c’est un moyen simple et infaillible d’isoler une entrée en particulier. 

<!DOCTYPE html>
<html lang="fr">
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset='utf-8'>                
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
        define('MYSQL_SERVEUR', 'localhost');
        define('MYSQL_UTILISATEUR', 'root');
        define('MYSQL_MOTDEPASSE', '');
        define('MYSQL_BASE', 'test');
         
        $mysqli = new MySQLi(MYSQL_SERVEUR,
                            MYSQL_UTILISATEUR,
                            MYSQL_MOTDEPASSE,
                            MYSQL_BASE);

        if ($mysqli->connect_errno) {
            echo "Echec lors de la connexion à MySQL : (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
        }
        //Crée la table Users
        $sql = "CREATE TABLE Users (
          id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
          Prenom VARCHAR(30) NOT NULL,
          Nom VARCHAR(30) NOT NULL,
          Mail VARCHAR(50) NOT NULL
        )";
        $mysqli->query($sql);
        /* Requête préparée, étape 1 : la préparation */
        if (!($stmt = $mysqli->prepare("UPDATE Users
                  SET mail='v.durand@edhec.com'
                  WHERE id=2"))) {
            echo "Echec de la préparation : (" . $mysqli->errno . ") " . $mysqli->error;
        }
        $stmt->execute();
        ?>
    </body>
</html>

Le script ci-dessus est assez transparent : on prépare notre requête pour mettre à jour l’adresse mail de l’utilisateur portant l’id 2 dans notre table puis on exécute cette requête.

On peut aller vérifier dans phpMyAdmin que notre la valeur mail de notre entrée à bien été mise à jour.

Supprimer des données

De manière pratique, il est essentiel de savoir comment supprimer des données d’une table, au cas où un utilisateur voudrait faire jouer son droit à l’effacement de ses données personnelles par exemple.

Pour supprimer des données d’une table, nous allons utiliser l’instruction SQL DELETE FROM.

Pour préciser quelles entrées doivent être supprimées, nous allons accompagner DELETE FROM d’une clause WHERE nous permettant de cibler des données en particulier dans notre table.

Pour tester cette instruction, nous allons utiliser la table « Users » créée précédemment (table contenant 4 colonnes et 3 entrées).

En pratique, pour supprimer une entrée en particulier, nous utiliserons la clause WHERE sur une colonne « id » en ciblant un « id » précis.

Nous pouvons également supprimer plusieurs entrées en donnant une inégalité en condition de la clause WHERE (cibler tous les « id » supérieurs à 5 par exemple) ou en ciblant un autre type de données (supprimer toutes les entrées dont la valeur dans la colonne « Prenom » est « Pierre » par exemple).

Ici, nous allons vouloir supprimer tous les utilisateurs dont le nom est « Giraud ».

<!DOCTYPE html>
<html lang="fr">
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset='utf-8'>                
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
        define('MYSQL_SERVEUR', 'localhost');
        define('MYSQL_UTILISATEUR', 'root');
        define('MYSQL_MOTDEPASSE', '');
        define('MYSQL_BASE', 'test');
         
        $mysqli = new MySQLi(MYSQL_SERVEUR,
                            MYSQL_UTILISATEUR,
                            MYSQL_MOTDEPASSE,
                            MYSQL_BASE);

        if ($mysqli->connect_errno) {
            echo "Echec lors de la connexion à MySQL : (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
        }
        $sql = "DELETE FROM Users WHERE nom='Giraud'";
        if (!($stmt = $mysqli->prepare( $sql ))) {
            echo "Echec de la préparation : (" . $mysqli->errno . ") " . $mysqli->error;
        }
        $stmt->execute();
        ?>
    </body>
</html>

On peut aller vérifier dans phpMyAdmin que notre entrée a bien été effacée :

Supprimer toutes les données d’une table

Pour supprimer toutes les données d’une table sans pour autant supprimer la table ni sa structure, c’est très simple, il suffit d’utiliser l’instruction SQL DELETE FROM sans préciser de clause WHERE.

Essayons par exemple d’effacer toutes les données de la table « Users » d’un coup.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset='utf-8'>                
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
        define('MYSQL_SERVEUR', 'localhost');
        define('MYSQL_UTILISATEUR', 'root');
        define('MYSQL_MOTDEPASSE', '');
        define('MYSQL_BASE', 'test');
         
        $mysqli = new MySQLi(MYSQL_SERVEUR,
                            MYSQL_UTILISATEUR,
                            MYSQL_MOTDEPASSE,
                            MYSQL_BASE);

        if ($mysqli->connect_errno) {
            echo "Echec lors de la connexion à MySQL : (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
        }
        $sql = "DELETE FROM Users";
        if (!($stmt = $mysqli->prepare( $sql ))) {
            echo "Echec de la préparation : (" . $mysqli->errno . ") " . $mysqli->error;
        }
        $stmt->execute();
        ?>
    </body>
</html>

Attention lorsque vous effacez des données : n’oubliez pas que cette action est irréversible. Réfléchissez donc bien avant d’exécuter ce genre d’action et faites une sauvegarde de votre base de données.

Sélection simple de données dans une table MySQL en PHP

Il ne nous reste donc plus qu’une opération de base à voir : la sélection ou récupération de données dans une base de données.

La sélection de données va être l’une des opérations fondamentales et les plus courantes que nous allons avoir à effectuer. En effet, nous allons devoir sélectionner ou récupérer des données en base notamment pour les comparer aux données envoyées par un utilisateur lors d’une tentative de connexion à son espace personnel sur notre site par exemple.

La sélection simple de données dans une base de données

Pour sélectionner des données dans une base de données, nous allons utiliser l’instruction SQL SELECT… FROM

Pour tester cette nouvelle instruction, il va avant tout nous falloir une base de données avec au moins une table et des données à l’intérieur.

Créons ne nouvelle table « users » qui va contenir 5 colonnes :

  • Une colonne « id », type INT, UNISGNED, PRIMARY KEY, AUTO_INCREMENT
  • Une colonne « prenom », type VARCHAR(30) NOT NULL
  • Une colonne « nom », type VARCHAR(30) NOT NULL
  • Une colonne « mail », type VARCHAR(50)
  • Une colonne « dateInscrit », type TIMASTAMP.

Nous allons également en profiter pour insérer 3 entrées dans cette table. Voici le script qui va nous permettre de faire tout ça en une fois.

A partir de là, nous pouvons tester notre instruction SELECT…FROM en sélectionnant par exemple tous les prénoms et adresses mail de notre table « users ». 

<!DOCTYPE html>
<html lang="fr">
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset='utf-8'>                
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
        define('MYSQL_SERVEUR', 'localhost');
        define('MYSQL_UTILISATEUR', 'root');
        define('MYSQL_MOTDEPASSE', '');
        define('MYSQL_BASE', 'test');
        
        $mysqli = new MySQLi(MYSQL_SERVEUR,
                            MYSQL_UTILISATEUR,
                            MYSQL_MOTDEPASSE,
                            MYSQL_BASE);

        if ($mysqli->connect_errno) {
            echo "Echec lors de la connexion à MySQL : (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
        }
        //Crée la table Users
        $sql = "CREATE TABLE Users(
                  id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                  prenom VARCHAR(30) NOT NULL,
                  nom VARCHAR(30) NOT NULL,
                  mail VARCHAR(50),
                  dateInscrit TIMESTAMP)";
        $mysqli->query($sql);
        /* Requête préparée, étape 1 : la préparation */
        if (!($stmt = $mysqli->prepare("INSERT INTO Users (Prenom, Nom, Mail)
                          VALUES (?, ?, ?)"))) {
            echo "Echec de la préparation : (" . $mysqli->errno . ") " . $mysqli->error;
        }
        $stmt->bind_param("sss", $prenom, $nom, $mail);
         
        //Insère une première entrée
        $prenom = "Pierre"; $nom = "Giraud"; $mail = "pierre.giraud@edhec.com";
        $stmt->execute();

        //Insère une deuxième entrée
        $prenom = "Victor"; $nom = "Durand"; $mail = "v.durandd@edhec.com";
        $stmt->execute();

        //Insère une troisième entrée
        $prenom = "Julia"; $nom = "Joly"; $mail = "july@gmail.com";
        $stmt->execute();

        $stmt->close();

        echo "Parfait, tout s'est bien passé";

        $sql = 'SELECT * FROM Users';
        $stmt = $mysqli->prepare($sql);
        $stmt->execute();

        $res = $stmt->get_result();
        echo '<h2>get_result</h2>';
        echo '<pre>';
        print_r($get_result);
        echo '</pre>';

        while($row = $res->fetch_assoc()) {
          echo '<h2>row </h2>';
          echo '<pre>';
          print_r($row );
          echo '</pre>';
        }
        ?>
    </body>
</html>

Ne récupérer que les valeurs uniques (par colonne) dans une table

Parfois, nous ne voudrons récupérer que les valeurs distinctes d’une colonne dans une table parmi toutes les valeurs.

Nous allons pouvoir faire cela en utilisant l’instruction SQL SELECT DINSTINCT. Cette instruction ne va retourner qu’une seule fois un même résultat.

Pour tester cette nouvelle instruction, commençons déjà par ajouter une quatrième entrée dans notre table « users ». Notre quatrième utilisateur s’appellera également « Pierre ».

<!DOCTYPE html>
<html lang="fr">
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset='utf-8'>                
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
        define('MYSQL_SERVEUR', 'localhost');
        define('MYSQL_UTILISATEUR', 'root');
        define('MYSQL_MOTDEPASSE', '');
        define('MYSQL_BASE', 'test');
        
        $mysqli = new MySQLi(MYSQL_SERVEUR,
                            MYSQL_UTILISATEUR,
                            MYSQL_MOTDEPASSE,
                            MYSQL_BASE);

        if ($mysqli->connect_errno) {
            echo "Echec lors de la connexion à MySQL : (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
        }
        //Crée la table Users
        $sql = "CREATE TABLE Users(
                  id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                  prenom VARCHAR(30) NOT NULL,
                  nom VARCHAR(30) NOT NULL,
                  mail VARCHAR(50),
                  dateInscrit TIMESTAMP)";
        $mysqli->query($sql);
        /* Requête préparée, étape 1 : la préparation */
        if (!($stmt = $mysqli->prepare("INSERT INTO Users (Prenom, Nom, Mail)
                          VALUES (?, ?, ?)"))) {
            echo "Echec de la préparation : (" . $mysqli->errno . ") " . $mysqli->error;
        }
        $stmt->bind_param("sss", $prenom, $nom, $mail);
         
        //Insère une première entrée
        $prenom = "Pierre"; $nom = "Giraud"; $mail = "pierre.giraud@edhec.com";
        $stmt->execute();

        //Insère une deuxième entrée
        $prenom = "Victor"; $nom = "Durand"; $mail = "v.durandd@edhec.com";
        $stmt->execute();

        //Insère une troisième entrée
        $prenom = "Julia"; $nom = "Joly"; $mail = "july@gmail.com";
        $stmt->execute();

        //Insère une dernière entrée avec le prénom "Pierre"
        $prenom = "Pierre"; $nom = "Dupont"; $mail = "pierre.dupont@gmail.com";
        $stmt->execute();

        $stmt->close();

        echo "Parfait, tout s'est bien passé";

        $sql = 'SELECT DISTINCT prenom FROM Users';
        $stmt = $mysqli->prepare($sql);
        $stmt->execute();

        $res = $stmt->get_result();
        echo '<h2>get_result</h2>';
        echo '<pre>';
        print_r($get_result);
        echo '</pre>';

        while($row = $res->fetch_assoc()) {
          echo '<h2>row </h2>';
          echo '<pre>';
          print_r($row );
          echo '</pre>';
        }
        ?>
    </body>
</html>

Mettre en ordre les valeurs récupérées dans une table

Jusqu’à présent, nous avons retourné les données sélectionnées dans notre base de données selon l’ordre de leur écriture.

Nous allons cependant facilement pouvoir trier les données renvoyées selon un ordre croissant (de la plus petite valeur numérique à la plus grande, ou de A à Z) ou décroissant grâce à l’instruction SQL ORDER BY.

Pour signifier que l’on souhaite trier selon un ordre croissant, nous utiliserons le mot ASC (pour « ascending », l’équivalent anglais de « croissant »). Si l’on souhaite un ordre décroissant, nous utiliserons plutôt DESC (« descending » ou « décroissant » en français).

De plus, nous allons pouvoir indiquer plusieurs colonnes sur lesquelles notre tri doit être fait dans le cas où nous aurions beaucoup de fois la même valeur renvoyée. La première colonne indiquée sera considérée comme le filtre de tri primaire, la deuxième secondaire, etc.

Sélectionnons immédiatement tous les prénoms et noms de notre table « Users » et trions les résultats renvoyés selon l’ordre croissant des prénoms en tri principal puis selon l’ordre décroissant des noms en tri secondaire.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <title>Cours PHP / MySQL</title>
        <meta charset='utf-8'>                
    </head>
    <body>
        <h1>Bases de données MySQL</h1>  
        <?php
        define('MYSQL_SERVEUR', 'localhost');
        define('MYSQL_UTILISATEUR', 'root');
        define('MYSQL_MOTDEPASSE', '');
        define('MYSQL_BASE', 'test');
        
        $mysqli = new MySQLi(MYSQL_SERVEUR,
                            MYSQL_UTILISATEUR,
                            MYSQL_MOTDEPASSE,
                            MYSQL_BASE);

        if ($mysqli->connect_errno) {
            echo "Echec lors de la connexion à MySQL : (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
        }

        $sql = 'SELECT * FROM Users ORDER BY prenom ASC, nom DESC';
        $stmt = $mysqli->prepare($sql);
        $stmt->execute();

        $res = $stmt->get_result();
        echo '<h2>get_result</h2>';
        echo '<pre>';
        print_r($get_result);
        echo '</pre>';

        while($row = $res->fetch_assoc()) {
          echo '<h2>row </h2>';
          echo '<pre>';
          print_r($row );
          echo '</pre>';
        }
        ?>
    </body>
</html>

De manière concrète, les tris par ordre croissant ou décroissant vont s’avérer utiles lorsqu’il s’agira de trier une liste de commandes par prix par exemple ou encore les utilisateurs par pays.

Utiliser des critères de sélection pour sélectionner des données dans une table

Un des grands intérêts des bases de données est que les données sont organisées et classées. Lorsque nous sélectionnons des données dans nos bases de données, nous voudrons souvent tirer avantage de cette organisation et ainsi sélectionner des données précises.

Les critères de sélection vont nous aider à créer des requêtes SQL de sélection puissantes et précises. Dans cette leçon, nous allons nous intéresser aux critères de sélection SQL suivants :

  • WHERE ;
  • AND, OR et NOT ;
  • LIMIT ;
  • LIKE et les jokers (wildcards) ;
  • IN et BETWEEN ;
  • EXISTS ;
  • ANY et ALL.

La clause SQL WHERE

Nous connaissons déjà cette clause et je ne vais donc pas beaucoup m’étendre sur son fonctionnement.

La clause WHERE va nous permettre de rajouter un conditionnement à une requête SQL. On va ainsi pouvoir ne sélectionner que des valeurs égales, supérieures ou inférieures à une certaine valeur.

Notez que la clause WHERE peut être utilisée dans des requêtes de sélection SQL aussi bien que dans des requêtes de suppression, de mises à jour, etc.

Dans notre table « users » contenant 4 entrées, nous allons par exemple pouvoir sélectionner tous les utilisateurs dont le prénom est « Pierre ».

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  WHERE prenom = 'Pierre'
";
?>

Les opérateurs AND, OR et NOT

Nous allons pouvoir étendre les possibilités de la clause SQL WHERE grâce aux opérateurs AND, OR et NOT.

L’opérateur AND va nous permettre de rajouter des conditions supplémentaires. Seuls les résultats satisfaisant à toutes les conditions seront sélectionnés. Notez que vous pouvez utiliser autant de AND que vous souhaitez dans une requête SQL.

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  WHERE prenom = 'Pierre' AND nom = 'Giraud'
";
?>

L’opérateur SQL OR va lui nous permettre d’élargir notre condition de base en rajoutant d’autres conditions. A la différence de AND, tous les résultats satisfaisants au moins l’une des conditions mentionnées seront affichés.

Nous allons également pouvoir ajouter autant de OR qu’on le souhaite dans une requête SQL.

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  WHERE prenom = 'Pierre' OR nom = 'Joly'
";
?>

Finalement, l’opérateur SQL NOT va nous permettre d’afficher tous les résultats ne satisfaisant pas une condition. On peut par exemple afficher tous les utilisateurs dont le prénom n’est pas « Pierre ». 

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  WHERE NOT prenom = 'Pierre'
";
?>

Notez que nous allons également pouvoir utiliser plusieurs opérateurs ensemble dans une requête SQL.

Nous allons ainsi par exemple pouvoir sélectionner tous les utilisateurs de notre table dont l’id est supérieur à 1 et dont le prénom n’est pas « Pierre » ou dont le nom est « Giraud ».

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  WHERE id > 1 AND NOT prenom = 'Pierre' OR nom = 'Giraud'
";
?>

Ici, faites bien attention à l’ordre des opérations et à bien écrire / lire votre requête afin qu’elle affiche les résultats souhaités.

Notre requête va sélectionner tous les utilisateurs dont l’id est supérieur à 1 ET dont SOIT le prénom n’est pas « Pierre », SOIT le nom est « Giraud ». C’est pour cela que le résultat « Pierre Giraud » est renvoyé.

La clause LIMIT

La clause SQL LIMIT est généralement utilisée pour limiter le nombre de résultats retournés.

En effet, cette clause va nous permettre d’indiquer un nombre de résultats maximum à retourner. Cela peut être utile pour optimiser la performance de votre script dans le cas où un très grand nombre de résultats seraient retournés.

Par défaut, la clause LIMIT va sélectionner des résultats dans l’ordre des entrées de votre table. Cependant, on va pouvoir spécifier à partir de quelle entrée on souhaite commencer à récupérer des résultats grâce au mot OFFSET.

On peut ainsi par exemple récupérer deux résultats dans notre table « users » à partir de la deuxième entrée (comprenez bien « la deuxième entrée satisfaisant notre condition s’il y en a une ») de cette manière :

Notez que le premier résultat dans l’ordre des entrées de la table satisfaisant notre requête correspond à OFFSET 0. Pour commencer à récupérer des résultats à partir du deuxième résultat dans l’ordre des entrées de la table satisfaisant notre requête il faudra donc préciser OFFSET 1 et etc.

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  LIMIT 2 OFFSET 1
";
?>

L’opérateur SQL LIKE et les jokers (wildcards)

Nous allons utiliser l’opérateur SQL LIKE conjointement avec une clause WHERE afin de chercher un schéma spécifique dans une colonne.

Nous allons également généralement utiliser l’opérateur LIKE avec des jokers ou wildcards en anglais.

Les jokers sont des caractères de substitution qui vont nous permettre de rechercher un schéma précis. Vous pouvez comparer les wildcards aux différents caractères que nous utilisions dans nos expressions régulières plus tôt dans ce cours.

Il existe deux jokers que nous allons pouvoir utiliser avec LIKE :

  • Le signe % qui va représenter zéro, un o plusieurs caractères ;
  • Le signe _ qui va représenter un caractère exactement.

Nous allons bien entendu pouvoir combiner les jokers entre eux dans nos requêtes.

Pour bien comprendre l’utilisation de LIKE et des jokers, voici quelques exemples de parties de requêtes ainsi que leur signification :

RequêteSignification
WHERE users LIKE ‘p%’Cherche les valeurs qui commencent par un « p »
WHERE users LIKE ‘%e’Cherche les valeurs qui se terminent par « e »
WHERE users LIKE ‘%e%’Cherche les valeurs qui possèdent un « e »
WHERE users LIKE ‘p%e’Cherche les valeurs qui commencent par « p » et se terminent par « e »
WHERE users LIKE ‘p____e’Cherche des valeurs de 6 caractères exactement qui commencent par « p » et se terminent par « e »
WHERE users LIKE ‘p_%’Cherche des valeurs de 2 caractères ou plus qui commencent par « p »

On va ainsi par exemple pouvoir ne sélectionner que les utilisateurs dont le nom contient un « r » dans notre table « users » :

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  WHERE nom LIKE '%r%'
";
?>

Les opérateurs SQL IN et BETWEEN

L’opérateur SQL IN va s’utiliser conjointement avec une clause WHERE. Cet opérateur va nous permettre de préciser une liste de données parmi lesquelles nous devons sélectionner nos données.

Utiliser IN revient finalement à utiliser plusieurs conditions OR mais avec une notation allégée et plus rapide.

On va ainsi par exemple pouvoir facilement sélectionner tous les utilisateurs dont le prénom est « Pierre » ou « Victor » dans notre table « users ».

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  WHERE prenom IN ('Pierre', 'Victor')
";
?>

Notez qu’on va bien évidemment pouvoir combiner les différents opérateurs SQL entre eux et ainsi par exemple pouvoir utiliser IN avec NOT pour exclure certaines valeurs spécifiques de notre sélection.

L’opérateur SQL BETWEEN va lui nous permettre de sélectionner ou d’exclure d’une sélection des données dans un certain intervalle. Notez que cet opérateur est inclusif (la première et la dernière valeur font partie de l’intervalle).

Les valeurs d’intervalle peuvent être des nombres, des textes ou des dates.

On va par exemple pouvoir sélectionner tous les utilisateurs dont le nom se trouve entre « F » et « Joly », ces deux valeurs étant donc incluses dans notre sélection.

<?php
$sql = "
  SELECT prenom, nom, mail
  FROM Users
  WHERE nom BETWEEN 'F' AND 'Joly'
";
?>