Support tutoriel : Maîtriser PHP MySQL - Tome 3

Aucune représentation ou reproduction, même partielle, autre que celles prévues dans
l’article L. 122-5 2° et 3°a) du code de la propriété intellectuelle ne peut être faite sans
l’autorisation expresse de Mediaforma ou, le cas échéant, sans le respect des modalités
prévues dans l’article L. 122-10 dudit code.
Il est également interdit de vendre ou de donner cet eBook, ni les vidéos qui vont avec.
Aidez-moi à lutter contre le piratage et le vol en me contactant sur :
admin@mediaforma.com
Vos informations personnelles (nom, adresse et e-mail) ne seront aucunement divulguées ni
publiées.
Publié par Mediaforma Learning
Auteur : Michel Martin
Copyright © 2014
Mediaforma est une marque déposée
Tous droits réservés

1
Programmation Orientée Objet en PHP 5.............................................................................. 4
Définition d'une classe ....................................................................................................... 4
Instanciation d'une classe.................................................................................................. 4
Accès aux méthodes et propriétés publiques ................................................................. 5
Lecture et modification des propriétés de type private ....................................................... 5
Constructeur et destructeur................................................................................................ 6
Les autres méthodes magiques ......................................................................................... 7
Exercice............................................................................................................................. 7
Solution.......................................................................................................................... 7
Services Web .......................................................................................................................10
Définition d'un service Web...............................................................................................10
Utilisation du service Web.................................................................................................12
PARTIE 2 - MySQL .............................................................................................................14
La console d'administration Web phpMyAdmin ....................................................................15
Utilisateur et mot de passe................................................................................................16
Créer une table.................................................................................................................17
Entrer des données dans une table ..................................................................................18
Exercice............................................................................................................................20
Solution.........................................................................................................................20
Interroger une table...........................................................................................................21
Supprimer une table..........................................................................................................22
Importer et exporter des données .....................................................................................23
La console MySQL ...............................................................................................................25
Connexion en tant que root...............................................................................................25
Connexion autre que root..................................................................................................25
Modification du mot de passe associé à un utilisateur.......................................................26
Types de champs .............................................................................................................26
Les champs numériques peuvent être du type ..............................................................26
Les champs chaines de caractères peuvent être du type ..............................................27
Les champs date et heure peuvent être du type............................................................27
Quelques commandes intéressantes................................................................................28
Exercice............................................................................................................................30
Syntaxe du WHERE..........................................................................................................31
Administration des utilisateurs ..........................................................................................31
Exercice............................................................................................................................32

2
Solution.........................................................................................................................32
Affectation du mot de passe 'secret' à l'utilisateur root...................................................33
Suppression du mot de passe affecté à l'utilisateur root ................................................33
Création de l'utilisateur Pierre sur le serveur localhost ..................................................33
Affectation d'un mot de passe à l'utilisateur Pierre.........................................................33
Affectation de privilèges à l'utilisateur Pierre sur les tables de la base localhost............33
Suppression de l'utilisateur Pierre .................................................................................33
Se connecter à une table en PHP avec MySQL ...................................................................35
Activer PDO......................................................................................................................35
Connexion objet avec PDO...............................................................................................36
Exercice............................................................................................................................39
Solution.........................................................................................................................39
Exercice............................................................................................................................39
Solution.........................................................................................................................39
Exercice............................................................................................................................41
Solution.........................................................................................................................41
Utilisation de variables PHP dans des requêtes................................................................43
Exercice............................................................................................................................43
Solution.........................................................................................................................43
Manipuler les données d'une table avec MySQL ..................................................................45
Voyons comment interroger une table ..............................................................................45
Fonctions SQL..................................................................................................................46
Exercice............................................................................................................................48
Solution.........................................................................................................................49
GROUP BY ...................................................................................................................50
HAVING ........................................................................................................................51
Jointures...........................................................................................................................52
Jointures simples...........................................................................................................52
Exercice............................................................................................................................54
Solution.........................................................................................................................55
Jointures complexes .........................................................................................................57
Examinons une requête INNER JOIN............................................................................57
Examinons une requête LEFT JOIN..............................................................................58
Pour terminer, examinons les requêtes RIGHT JOIN ....................................................58
Exemples de jointures complexes .................................................................................58
Créer une base de données, une table et des enregistrements en PHP...............................62
Créer une base de données..............................................................................................62

3
Créer une table.................................................................................................................62
Ajouter des données dans une table.................................................................................63
Exercice............................................................................................................................63
Solution.........................................................................................................................64
Mise à jour et suppression des données...............................................................................67
Mise à jour de données.....................................................................................................67
Exercice............................................................................................................................67
Solution.........................................................................................................................67
Suppression de données ..................................................................................................68
Exercice............................................................................................................................69
Solution.........................................................................................................................69
Suppression d'une table et d'une base de données ..........................................................70
Organiser le code selon l'architecture MVC..........................................................................72
Qu'est-ce que MVC et pourquoi l'utiliser ? ........................................................................72
Développer un projet selon l'architecture MVC .................................................................73
Création de l'arborescence............................................................................................73
Modèle ..........................................................................................................................73
Contrôleur .....................................................................................................................74
Vue................................................................................................................................76
Frameworks MVC .............................................................................................................77
Annexes ...............................................................................................................................78
Modifier le fichier php.ini ...................................................................................................78
Sécurité ............................................................................................................................78
Protéger un dossier avec .htaccess et .htpasswd .............................................................78
Site officiel et documentation ............................................................................................80

4
Programmation Orientée Objet
en PHP 5
Il est temps de passer à la pratique. Dans cette partie, vous allez écrire plusieurs scripts pour
faire vos armes en POO PHP. Pour cela, nous allons travailler sur une classe spécialisée dans
le traitement des chaînes de caractères. Cette classe contiendra plusieurs méthodes
permettant de simplifier les manipulations des chaines de caractères.
Définition d'une classe
Pour définir une classe, il suffit d'utiliser le mot class suivi du nom de la classe. Par exemple :
class chainePlus {
// Une ou plusieurs instructions
}
Pour définir les propriétés de la classe, vous utiliserez le mot-clé :
 public si la propriété doit être accessible dans la classe, les classes dérivées et les
objets ;
 private si la propriété doit être accessible dans la classe seulement ;
 protected si la propriété doit être accessible dans la class et ses classes dérivées.
Par exemple :
private $nomProp;
Où nomProm est le nom d'une propriété.
Pour définir des fonctions membres, vous utiliserez cette syntaxe :
public function nom(){
// $this->nomProp permet d'accéder à la propriété nomProp
}
Remarque
Par convention, il est préconisé de sauvegarder la classe sous le nom nomClasse.class.php
(où nomClasse est le nom de la classe).
Instanciation d'une classe
Pour instancier une classe (c'est-à-dire pour créer un objet à partir d'une classe), vous devez
:

5
1) insérer le code de la classe à l'aide d'une instruction include_once :
include_once(nom);
où nom est le nom du fichier dans lequel a été définie la classe.
2) Créer un objet avec l'instruction new :
$objet = new classe();
où objet est le nom de l'objet créé et classe le nom de la classe à utiliser comme
modèle.
Accès aux méthodes et propriétés publiques
Pour accéder à une méthode ou une propriété publique, utilisez la syntaxe suivante :
$this -> nom;
Où nom est le nom de la méthode ou de la propriété publique à accéder.
Vous pouvez par exemple :
 Affecter une valeur à une propriété publique :
$this -> nomPropriete = 10;
 Afficher la valeur d'une propriété publique :
echo $this -> nomPropriete;
 Lancer une fonction publique :
$this -> nomFonction();
 Lancer une fonction publique en lui passant des paramètres :
$this -> nomFonction("a", 15, "x");
 Afficher la valeur retournée par une fonction publique :
echo $this -> nomFonction();
Lecture et modification des propriétés de type private
Par définition, les propriétés de type private ne peuvent être accédées que par les méthodes
de la classe dans laquelle elles ont été définies. Pour cela, on utilise des fonctions publiques
appelées getter et setter. Leur nom commence toujours par get pour le getter et par set pour
le setter.
Supposons que la propriété suivante soit définie dans la classe :
private $fyeo = "For Your Eyes Only";
Pour pouvoir lire et modifier cette propriété depuis une instanciation de la classe, vous définirez
les fonctions getFyeo() et setFyeo() comme ceci :
public function getFyeo(){
return $this -> fyeo;
}
public setFyeo($nouveau){
$this -> fyeo = $nouveau;
}

6
La fonction publique getFyeo lit le contenu de la propriété private $fyeo et
la retourne à l'appelant.
La fonction publique setFyeo affecte la valeur qui lui est passée en paramètre
à la propriété private fyeo.
Constructeur et destructeur
Le constructeur et le destructeur sont deux méthodes particulières dites "magiques". Elles
permettent respectivement d'initialiser un objet lors de sa création et d'effectuer les opérations
nécessaires lors de sa destruction.
Pour définir ces deux méthodes, vous utiliserez la syntaxe suivante :
public function __construct(param1, param2, … paramN){
}
public function __destruct(){
//Une ou plusieurs instructions
}
Par exemple, le constructeur pourrait initialiser les propriétés membres en utilisant les
paramètres qui lui sont transmis :
public function __construct($texte, $entier){
$this -> chaine = $texte;
$this -> numérique = $entier;
}
Quant au destructeur, il pourrait par exemple fermer un fichier ou une base de données qui
aurait été ouverte par les fonctions membres de la classe :
public function __destructor(){
fclose($handle);
}
Remarque
Les méthodes __construct et __destruct commencent toutes deux par un double caractère
de soulignement. Il en est de même pour toutes les autres méthodes magiques. Dans la
mesure du possible, ne faites jamais commencer le nom de vos méthodes et fonctions par
"__".

7
Les autres méthodes magiques
Plusieurs autres méthodes magiques peuvent être utilisées : __call(), __callStatic(),
__get(), __set(), __isset(), __unset(), __sleep(), __wakeup(), __toString(),
__invoke(), __set_state() et __clone(). Pour en savoir plus à leur sujet, consultez la
page suivante :
http://php.net/manual/fr/language.oop5.magic.php
Exercice
Définissez la classe chainePlus qui contient :
 Une propriété private nommée chaine ;
 quatre méthodes de type public nommées gras(), italique(), souligne() et
majuscules() qui retournent respectivement la chaîne passée en argument mise en
gras, en italique, soulignée et mise en majuscules.
Définissez un script PHP qui crée un objet basé sur la classe chainePlus et qui l'exploite pour
obtenir le résultat suivant :
Solution
Faites une pause dans la vidéo et définissez la classe chainePlus et un objet basé sur cette
classe. Vous reprendrez la lecture de la vidéo pour prendre connaissance de la solution.
Voici le code de la classe chainePlus :
<?php
class chainePlus{
private $chaine = "Programmation orientée objet en PHP";
public function __constructor($laChaine){
$this -> chaine = $laChaine;
}

8
public function gras(){
return "<b>".$this->chaine."</b><br>";
}
public function italique(){
return "<i>".$this->chaine."</i><br>";
}
public function souligne(){
return "<u>".$this->chaine."</u><br>";
}
public function majuscules(){
return strtoupper($this->chaine)."<br>";
}
}
?>
La première instruction définit la propriété private $chaine et lui affecte la chaîne
"Programmation orientée objet en PHP". Cette variable ne sera accessible que par les
méthodes de la classe.
Les instructions suivantes définissent les méthodes gras, italique, souligne et majuscules. Ces
quatre méthodes fonctionnent sur le même principe : elles lisent le contenu de la propriété
$chaine, lui appliquent un traitement spécifique et retournent le résultat obtenu à l'appelant.
La méthode gras encadre la chaîne par les balises b et /b pour l'afficher en gras et lui ajoute
un passage à la ligne avec la balise br. La méthode italique encadre la chaine avec les balises
i et /i pour l'afficher en italique et lui ajoute un passage à la ligne. La méthode souligne encadre
la chaine avec les balises u et /u pour la souligner et lui ajoute un passage à la ligne. Enfin, la
méthode majuscules applique la fonction strtoupper à la chaine pour l'afficher en majuscules
et lui ajouter un passage à la ligne.
Voici le code du script objetChainePlus.php, qui crée un objet basé sur la classe chainePlus
et qui l'utilise :
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>Formulaire d'accès à la page protégée</title>
</head>

9
<body>
<?php
include_once("chainePlus.class.php");
$st = new chainePlus("Programmation orientée objet en PHP");
echo "Gras : ".$st->gras();
echo "Italique : ".$st->italique();
echo "Souligné : ".$st->souligne();
echo "Majuscules : ".$st->majuscules();
?>
</body>
</html>
Ce script est très simple. Après avoir inclus le code de la classe chainePlus avec l'instruction
include_once, une instance de la classe chainePlus est créée avec l'instruction new. L'objet
créé a pour nom $st.
Les méthodes Gras, Italique, Souligne et Majuscules de l'objet sont alors invoquées pour
afficher les différentes mises en forme de la chaîne. Exécutons ce code dans WAMP Server.
Les quatre mises en forme de la chaîne sont bien affichées.

10
Services Web
Le langage PHP permet de créer des services Web.
Mais au fait, savez-vous ce qu'est un service Web ? Il s'agit d'un programme libre d'accès, qui
s'exécute sur un serveur Web, et qui permet d'échanger des données avec le client qui
l'interroge.
Remarque
Pour être en mesure de créer et d'utiliser des services Web sur votre serveur local
WAMPServer, vous devez activer l'extension SOAP. Cliquez sur l'icône de WAMPServer
dans la zone de notifications, pointez PHP, Extensions PHP et assurez-vous qu'une coche
est affichée devant php_soap. Dans le cas contraire :
1) Fermez WAMPServer.
2) Editez le fichier wampbinapacheApache2.4.4binphp.ini.
3) Recherchez du terme "soap" et supprimez le ";" devant la ligne
;extension=php_soap.dll.
4) Redémarrez WAMPServer.
Définition d'un service Web
Nous allons créer un service Web ultra simple qui retourne l'heure UTC.
Dans un premier temps, nous définissons la classe horloge qui contient une seule méthode
publique nommée heure(). Cette méthode retourne l'heure au format UTC, en utilisant la
fonction date() :
<?php
class horloge{
public function heure(){
return date("e H:i:s");
}
}
Le service Web va reposer sur la classe horloge. Pour le mettre en place, quelques instructions
PHP suffisent :
try
{

11
$server = new SoapServer(null, array('uri' =>
'http://localhost/POO/horloge.class.php'));
$server->setClass("horloge");
$server->handle();
}
catch(Exception $e)
{
echo "Exception: " . $e;
}
?>
Dans un premier temps, l'objet SoapServer $server est créé, en précisant l'adresse URI du
service :
$server = new SoapServer(null, array('uri' =>
'http://localhost/POO/horloge.class.php'));
La syntaxe de l'instanciation d'un l'objet SoapServer se trouve ici :
http://www.php.net/manual/en/soapserver.soapserver.php.
Cinq syntaxes sont possibles. Les quatre premières utilisent un fichier WSDL (Web Service
Description Language). La cinquième syntaxe n'utilise pas de fichier WSDL. Elle pointe vers
l'URI de la classe utilisée pour définir le service Web. Nous utiliserons cette syntaxe. Ici, la
classe est stockée dans le fichier horloge.class.php, qui se trouve dans le dossier POO du
serveur Web local.
L'instruction suivante indique au serveur le nom de la classe qui gère les requêtes SOAP :

12
$server->setClass("horloge");
Enfin, la dernière instruction s'occupe de toutes les tâches nécessaires pour gérer les requêtes
SOAP :
$server->handle();
L'instanciation de l'objet SoapServer se fait à l'intérieur d'une instruction try. Si une erreur se
produit, elle est capturée par l'instruction catch et affichée sur l'écran avec une instruction
echo :
catch(Exception $e)
{
echo "Exception: " . $e;
}
Le service est entièrement défini. Sauvegardez-le sous le nom horloge.class.php et
sauvegardez-le dans le dossier c:wampwwwPOO.
Utilisation du service Web
Pour consommer le service, vous devez maintenant écrire un client en instanciant un objet
SoapClient. Voici le code utilisé :
<?php
try
{
echo "Le Webservice donne l'heure ";
$clientSOAP = new SoapClient( null,
array (
'uri' => 'http://localhost/',
'location' => 'http://localhost/POO/horloge.class.php',
'trace' => 1,
'exceptions' => 1
));
$ret = $clientSOAP->__soapCall('heure', array());
echo $ret;
}
catch(SoapFault $f)

13
{
echo $f;
}
?>
La syntaxe de l'instanciation d'un objet SoapClient se trouve ici :
http://php.net/manual/en/soapclient.soapclient.php.
Il ne reste plus qu'à appeler la méthode heure() de l'objet $clientSOAP :
$ret = $clientSOAP->__soapCall('heure', array());
Consultez la page http://www.php.net/manual/en/soapclient.soapcall.php pour en savoir plus
sur cette méthode.
Le résultat retourné par la méthode est enfin affiché :
echo $ret;
Exécutons ce code dans WAMP Server.
L'heure UTC est immédiatement affichée. Quelques secondes plus tard, vous pouvez appuyer
sur la touche F5 pour mettre à jour na page et afficher à nouveau l'heure.

14
PARTIE 2 - MySQL
Les bases de données permettent de stocker des données de tous types, de façon organisée
et durable, contrairement aux variables PHP.
Dans cette formation, vous allez apprendre à utiliser le SGBD (Système de Gestion de Bases
de Données) MySQLi (pour MySQL Improved). Apparu dans la version 4.1.3 de MySQL, cette
version améliorée de MySQL offre plusieurs avantages :
 Accès objet aux bases de données ;
 Support des instructions Prepared et Multiple ;
 Support des transactions ;
 Débogage avancé.
Pour créer une base de données, ou encore pour lire ou écrire dans une table, vous utiliserez
le langage SQL. Les commandes SQL seront passées au SGBD via des instructions PHP ou
"à la main", via la console d'administration Web phpMyAdmin ou la console MYSQL. Ces trois
possibilités vont être analysées en détail dans les pages suivantes.

15
La console d'administration Web
phpMyAdmin
Pour accéder à la console d'administration Web phpMyAdmin, cliquez sur l'icône de
WAMPServer dans la zone de notification et choisissez phpMyAdmin dans le menu.
Tapez root dans la zone de texte Utilisateur, laissez la zone de texte Mot de passe vide et
cliquez sur Exécuter. Vous êtes maintenant dans l'interface d'administration de phpMySQL :

16
Utilisateur et mot de passe
L'utilisateur root sans mot de passe est l'utilisateur par défaut de phpMySQL. Si vous le
souhaitez, vous pouvez sécuriser votre connexion en choisissant un autre nom d'utilisateur et
un mot de passe. Sélectionnez l'onglet Utilisateurs. Sur la ligne root/localhost, cliquez sur
Changer les privilèges.
Déplacez-vous dans le groupe d'options Changement des informations de
connexion/Copie d'utilisateur et choisissez un nom d'utilisateur et un mot de passe.
Assurez-vous de bien noter ces informations et cliquez sur Exécuter pour les mémoriser.

17
Cliquez sur l'icône Quitter dans la partie supérieure de l'onglet gauche pour vous déconnecter
:
Fermez la page de phpMyAdmin. Terminez WAMPServer et relancez-le, puis connectez-vous
sur phpMyAdmin en cliquant sur l'icône de WAMPServer dans la zone de notification et en
choisissant phpMyAdmin dans le menu. Il ne vous reste plus qu'à entrer vos informations de
connexion pour vous connecter.
Créer une table
Le volet gauche de la fenêtre dresse la liste des bases de données existantes.
Pour créer une nouvelle base de données, sélectionnez l'onglet Bases de données,
choisissez un nom pour la nouvelle base de données et cliquez sur Créer. Ici par exemple,
nous créons la base de données formation :
Pour créer une table dans la base de données formation, cliquez sur son nom dans le volet
gauche, choisissez un nom pour la table (Nom) et un nombre de champs (Nombre de
colonnes) et cliquez sur Exécuter. Ici par exemple, nous définissons table utilisateurs qui
contient cinq champs :

18
Maintenant, il ne vous reste plus qu'à choisir le nom et le type des champs et à valider pour
créer la table :
Pour l'instant, nous allons nous contenter de créer des champs très simples :
 nom, de type TEXT ;
 prenom, de type TEXT ;
 login, de type TEXT ;
 password, de type TEXT ;
 email, de type TEXT.
Une fois ces informations définies, cliquez sur Sauvegarder pour créer la table.
Entrer des données dans une table
Pour entrer des données dans la table utilisateurs de la base formation, développez
l'élément formation, cliquez sur utilisateurs, puis basculez sur l'onglet Insérer.
Utilisez les cinq zones de texte multilignes pour entrer les données :

19
Pour vous entraîner, saisissez les données suivantes :
nom prenom login password email
Durand Eric eDurand pass1 e.durand@fai.com
Terec Pierre pTerec pass2 p.terec@fai.com
Valmont Judy jValmont pass3 j.valmont@fai.com
Crouzet Patrick pCrouzet pass4 p.crouzet@fai.com
Vertec Pierre pVertec pass5 p.vertec@fai.com
Faites une pause dans la vidéo. Poursuivez la lecture lorsque toutes les données auront été
saisies.
Sélectionnez l'onglet Afficher. Voici ce que vous devriez obtenir :

20
Exercice
Pour vous entraîner à manipuler l'interface phpMyAdmin, trouvez la technique permettant de
modifier le contenu de la table utilisateurs.
Solution
Faites une pause dans la vidéo. Poursuivez la lecture pour prendre connaissance de la
technique à utiliser.
Pour être en mesure de modifier les données de la table utilisateurs, vous devez au préalable
créer un champ indexé à valeurs uniques :
1) Sélectionnez l'onglet Structure.
2) Sous la liste des champs, sélectionnez l'option En début de table et cliquez sur
Exécuter pour ajouter le nouveau champ en début de table.
3) Définissez un champ nommé (par exemple) index, choisissez UNIQUE dans la liste
Index et cochez la case A_I (AUTO_INCREMENT) :
4) Cliquez sur Sauvegarder puis basculez sur l'onglet Afficher.

21
Maintenant, vous pouvez modifier les données stockées dans les enregistrements en cliquant
sur les liens Modifier correspondants :
Remarque
Toutes les tables doivent avoir un champ qui permet de les identifier de façon unique.
Interroger une table
Pour sélectionner certains enregistrements d'une table en fonction de leur contenu,
sélectionnez l'onglet SQL. Une requête vous est proposée par défaut :
SELECT * FROM 'utilisateurs' WHERE 1
Cliquez sur Exécuter pour l'exécuter. Comme vous pouvez le voir, tous les enregistrements
de la table sont sélectionnés et affichés :

22
Sans entrer dans le détail, je vais vous montrer comment sélectionner les enregistrements
dont le champ prenom a pour valeur Pierre.
Cliquez sur l'onglet pour réinitialiser son contenu. Modifiez la requête SQL comme ceci :
SELECT * FROM `utilisateurs` WHERE prenom="Pierre"
Cliquez sur Exécuter. Seuls les deux enregistrements dont le champ prenom vaut Pierre sont
maintenant sélectionnés :
Supprimer une table
Pour supprimer une table, cliquez sur la base de données dans laquelle elle est stockée dans
le volet droit de phpMyAdmin, cochez la case affichée devant le nom de la table à supprimer
puis cliquez sur Supprimer :
Remarque
Vous pouvez également vider la table, c'est-à-dire supprimer son contenu en conservant sa
structure. Pour cela, sélectionnez la table à vider et cliquez sur Vider.

23
Importer et exporter des données
Il peut parfois être utile d'importer des données dans une table depuis un fichier CSV, SQL,
XML, etc. Pour cela, sélectionnez la table dans laquelle doit se faire l'importation dans le volet
gauche, basculez sur l'onglet Importer, remplissez le formulaire d'importation et cliquez sur
Exécuter :
Inversement, pour exporter le contenu d'une table dans un fichier CSV, JSON (JavaScript
Object Notation), SQL, XML, etc., sélectionnez la table à exporter dans le volet gauche,
basculez sur l'onglet Exporter, choisissez un format d'exportation dans la liste et cliquez sur
Exécuter :

25
La console MySQL
La console MySQL peut être utilisée pour lancer rapidement des commandes SQL.
Connexion en tant que root
Pour ouvrir la console MySQL, cliquez sur l'icône de WAMPServer dans la zone de
notifications, pointez MySQL et cliquez sur Console MySQL. La console se connecte à
MySQL en utilisant le compte root. Le mot de passe de ce compte vous est demandé. Comme
aucun mot de passe n'est affecté au compte root, appuyez simplement sur la touche Entrée
du clavier :
Connexion autre que root
Si vous voulez vous connecter sous un autre nom d'utilisateur, ouvrez une fenêtre Invite de
commandes dans le dossier c:wampbinmysqlmysql5.6.12bin et tapez la commande
suivante :
mysql –u 'nom' –p
Où nom est le nom d'utilisateur avec lequel vous voulez vous connecter.
Entrez le mot de passe associé à l'utilisateur et appuyez sur la touche Entrée pour vous
connecter. Si aucun mot de passe n'est associé à l'utilisateur, appuyez simplement sur la
touche Entrée :

26
Modification du mot de passe associé à un utilisateur
Reportez-vous à la section intitulée "Administration des utilisateurs" pour savoir comment
changer le mot de passe associé à un utilisateur quelconque (y compris root).
Types de champs
Lorsque vous créez une table MySQL, vous devez définir le type de données des champs de
la table. Il existe trois grands types de données :
 Numérique
 Chaine de caractères
 Date et heure
Les champs numériques peuvent être du type
Type Signification
tinyint Occupe 1 octet. Peut stocker des nombres entiers compris entre -128 à 127
si l'attribut UNSIGNED n'est pas spécifié, ou compris entre 0 et 255 dans le
cas contraire.
smallint Occupe 2 octets. Ce type de données peut stocker des nombres entiers
compris entre -32 768 à 32 767 si l'attribut UNSIGNED n'est pas spécifié,
ou compris entre 0 et 65 535 dans le cas contraire.
mediumint Occupe 3 octets. Ce type de données peut stocker des nombres entiers
compris entre -8 388 608 et 8 388 607 si l'attribut UNSIGNED n'est pas
spécifié, ou compris entre 0 et 16 777 215 dans le cas contraire.
int Occupe 4 octets. Ce type de données peut stocker des nombres entiers
compris entre -2 147 483 648 et 2 147 483 647 si l'attribut UNSIGNED n'est
pas spécifié, ou compris entre 0 à 4 294 967 295 dans le cas contraire.
bigint Occupe 8 octets. Ce type de données stocke les nombres entiers compris
entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807 si l'attribut

27
UNSIGNED n'est pas spécifié, ou compris entre 0 à 18 446 744 073 709
551 615 dans le cas contraire.
float Occupe 4 octets. Ce type de données permet de stocker des nombres
flottants à précision simple, compris entre -1.175494351E-38 et
3.402823466E+38 (non UNSIGNED) ou entre 0 et 3.402823466E+38
(UNSIGNED).
double ou
real
Occupe 8 octets. Stocke des nombres flottants à double précision compris
entre -1.7976931348623157E+308 et -2.2250738585072014E-308, et
entre 2.2250738585072014E-308 et 1.7976931348623157E+308 (non
UNSIGNED). Si l'attribut UNSIGNED est précisé, les nombres négatifs sont
retirés.
Les champs chaines de caractères peuvent être du type
Type Signification
Char Chaîne de caractères de taille fixe
Varchar Chaîne de caractères de longueur variable comprise entre 1 et 255
caractères
tinyblob Chaîne de 0 à 255 caractères (sensible à la casse)
tinytext Chaîne de 0 à 255 caractères (insensible à la casse)
Blob Chaîne de 0 à 65 535 caractères (sensible à la casse)
Text Chaîne de 0 à 65 535 caractères (insensible à la casse)
mediumblob Chaîne de 0 à 16 777 215 caractères (sensible à la casse)
mediumtext Chaîne de 0 à 16 777 215 caractères (insensible à la casse)
longblob Chaîne de 0 à 4 294 967 295 caractères (sensible à la casse)
longtext Chaîne de 0 à 4 294 967 295 caractères maximum (insensible à la casse)
Les champs date et heure peuvent être du type
Type Signification
date Occupe 3 octets. Date au format AAAA-MM-JJ, entre 1000-01-01 et 9999-
12-31
time Occupe 3 octets. Date au format AAAA-MM-JJ entre1000-01-01 et 9999-
12-31

28
datetime Occupe 8 octets. Date et heure au format AAAA-MM-JJ HH:MM:SS entre
1000-01-01 00:00:00 et 9999-12-31 23:59:59
year Occupe 1 octet. Année à 2 ou 4 chiffres entre 1901 et 2155 ( 4 chiffres) ou
entre 1970 et 2069 (2 chiffres)
timestamp Occupe 4 octets. Date codée sous une forme numérique et comprise entre
1970-01-01 00:00:00 et l'année 2037
Quelques commandes intéressantes
Dans cette rubrique, vous allez découvrir quelques commandes SQL intéressantes. Il ne s'agit
que du B.A. BA. Pour avoir une vision plus globale des commandes SQL, consultez le
document http://oandreau.free.fr/supports/sql.pdf ou interrogez votre moteur de recherche
Web préféré sur le terme "commandes SQL".
Commande Effet
SHOW DATABASES; Affiche toutes les bases de données
USE nom; Sélectionne la base de données nom
SHOW tables; Affiche les tables de la base de données
sélectionnée
CREATE DATABASE nom; Crée une base de données
CREATE TABLE nom[
champ1 type1(taille),
champ2 type2(taille),
etc.);
Crée la table nom dans la base de données
courante
DROP DATABASE nom Supprime la base de données nom
DROP TABLE nom; Supprime la table nom
SELECT * FROM table; Affiche tous les enregistrements de la table
spécifiée
SELECT nom FROM table; Affiche toutes les valeurs du champ nom de
la table spécifiée.
SELECT * FROM table WHERE ch=valeur; Affiche tous les champs de la table spécifiée
pour lesquels le champ ch vaut valeur.

29
SELECT * FROM table WHERE ch=valeur
ORDER BY ch2 ASC;
Affiche tous les champs de la table spécifiée
pour lesquels le champ ch vaut valeur, en
classant les réponses par champ ch2
croissants.
SELECT COUNT(*) FROM table; Compte le nombre d'enregistrements de la
table spécifiée.
DESCRIBE nom; Donne des informations sur les champs de
la table nom
ALTER TABLE nom MODIFY(champ,
type(taille));
Modifie le type de données du champ
spécifié de la table nom
INSERT INTO nom VALUE(val1, … valN); Insère un enregistrement dans la table nom.
Les valeurs à insérer sont précisées entre
les parenthèses.
UPDATE nom SET champ=valeur; Met à jour le champ spécifié avec la valeur
spécifiée dans tous les enregistrements de
la table nom
UPDATE nom SET champ1=valeur1,
champ2=valeur2, champ3=valeur3;
Met à jour les champs champ1 à champ3
dans tous les enregistrements de la table
nom
UPDATE nom SET champ=valeur WHERE
champ2=valeur2;
Dans la table nom, met à jour le champ
spécifié avec la valeur spécifiée dans les
enregistrements pour lesquels champ2 vaut
valeur2
UPDATE nom SET champ1=valeur1,
champ2=valeur2 WHERE
champ3=valeur3;
Dans la table nom, met à jour les champs
champ1 et champ2 dans les enregistrements
pour lesquels champ3 vaut valeur3
DELETE FROM nom; Supprime tous les enregistrements de la
table nom.
DELETE FROM nom WHERE
champ=valeur;
Supprime tous les enregistrements de la
table nom pour lesquels champ vaut nom
ROLLBACK Annule la suppression d'enregistrements
COMMIT Valide la suppression d'enregistrements
Voici deux exemples élémentaires pour comprendre comment utiliser des requêtes SQL dans
la console MySQL.

30
1) Pour afficher tous les enregistrements de la table utilisateurs, commencez par
sélectionner la table formation avec la commande SQL USE, puis lancez une requête
SELECT comme ceci :
2) Supposons maintenant que vous vouliez sélectionner les enregistrements de la table
utilisateurs dont le champ prenom vaut "Pierre". Tapez la requête SQL suivante :
Exercice
Utilisez la console MySQL pour effectuer les actions suivantes :
1) Créez la base de données testconsole
2) Créez la table testtable composée des champs suivants :
Champ Type
nom varchar(50)
prenom varchar(50)
compteurVisite smallint
derniereVisite timestamp
3) Affichez la structure de la table.
4) Ajoutez les valeurs suivantes dans la table testtable :
Pierre, Dubur, 34, NOW()

31
Chantal, Garnier, 128, NOM()
Jean, Dupont, 2, NOW()
Belle, Vercor, 45, NOW()
5) Lister les données contenues dans la table
6) Affecter la valeur 200 au champ compteurdevisite de Jean Dupont
7) Supprimer l'enregistrement de Pierre Dubur
8) Compter le nombre d'enregistrements dans la table testtable
9) Supprimer la base de données testconsole
USE testconsole
Syntaxe du WHERE
Jusqu'ici, les conditions utilisées dans la clause WHERE étaient élémentaires. Le langage SQL
permet cependant d'indiquer de façon précise les éléments à sélectionner en utilisant un ou
plusieurs opérateurs dans la clause WHERE. Vous pouvez utiliser les opérateurs suivants :
Opérateur Description Exemple
= Egal à WHERE prenom='Jean'
<> Différent de WHERE prenom<>'Pierre'
> Supérieur à WHERE visites>15
< Inférieur à WHERE total<100
>= Supérieur ou égal à WHERE visites>=100
<= Inférieur ou égal à WHERE prix<=25
BETWEEN A l'intérieur de la plage spécifiée WHERE prix BETWEEN 10 AND 20
NOT BETWEEN A l'extérieur de la plage spécifiée WHERE date NOT BETWEEN
#10/01/2013# AND #10/06/2013#
LIKE Compatible avec le modèle
spécifié
WHERE prenom LIKE 'P%'
WHERE prenom LIKE '%re%'
IN Egal à une des valeurs
spécifiées
WHERE prix in (10, 20, 30)
AND ET logique WHERE ville='Paris' AND
prix<1000
OR OU logique WHERE prix<100 OR visites>1000
NOT NON logique WHERE prenom NOT IN ('Jean',
'Pierre')
Administration des utilisateurs
Plusieurs commandes SQL peuvent être utilisées pour :
 créer un utilisateur ;
 lui affecter des droits pour déterminer ce qu'il peut faire ;
 supprimer un utilisateur.
Voici les commandes les plus courantes.

32
Commande Effet
USE mysql;
SELECT * FROM user;
Liste les utilisateurs MySQL
SELECT * FROM mysql.user; Une variante monoinstruction des deux
commandes précédentes
USE mysql;
SELECT host, user FROM user;
Affiche les champs host et user des
utilisateurs MySQL
SELECT host, user FROM mysql.user; Une variante monoinstruction des deux
commandes précédentes
SELECT current_user(); Affiche le nom de l'utilisateur en cours
CREATE USER 'nom'@'serveur'; Crée l'utilisateur nom sans mot de passe sur
le serveur spécifié. Par exemple :
CREATE USER 'Pierre' @ 'localhost';
CREATE USER 'nom'@'serveur'
IDENTIFIED BY 'p';
Crée l'utilisateur avec le mot de passe p sur
le serveur spécifié. Par exemple :
CREATE USER 'Paul'@'localhost'
IDENTIFIED BY 'monpass';
GRANT ALL PRIVILEGES ON base.*
TO 'nom'@'serveur'
IDENTIFIED BY 'passe';
Donne à l'utilisateur nom sur le serveur
spécifié avec le mot de passe spécifié le droit
d'accéder à la base de données base. Par
exemple :
GRANT ALL PRIVILEGES ON testconsole.*
TO 'Pierre'@'localhost';
SHOW GRANTS; Affiche les droits du compte utilisé pour se
connecter au serveurcreatedatabase
DROP USER 'nom'@'base'; Supprime l'utilisateur nom de la base
spécifiée. Par exemple :
DROP USER 'pierre'@'localhost';
SET PASSWORD FOR 'nom'@'base' =
PASSWORD('pass');
Affecte le mot de passe pass à l'utilisateur
nom de la base de données base.
Remarque
Si vous avez perdu le mot de passe de l'utilisateur root, suivez la procédure décrite ici pour le
réinitialiser :
http://www.commentcamarche.net/forum/affich-23919767-se-connecter-a-wampserver
Exercice
1) Affectez le mot de passe 'secret' à l'utilisateur root
2) Annulez le mot de passe de l'utilisateur root
3) Créez l'utilisateur Pierre sur le serveur localhost
4) Affectez le mot de passe 'monpass' à l'utilisateur Pierre
5) Affectez tous les privilèges à l'utilisateur Pierre sur les tables de la base localhost
6) Supprimez l'utilisateur Pierre
Solution
Faites une pause dans la vidéo et répondez à ces six questions. Vous pourrez reprendre le
visionnage de la vidéo pour prendre connaissance des solutions.

33
Affectation du mot de passe 'secret' à l'utilisateur root
Pour savoir à quel serveur est attaché l'utilisateur root, on utilise la commande suivante :
select host, user from mysql.user;
Voici la réponse retournée par MySQL :
L'utilisateur root est donc rattaché au serveur '::1'.
Il suffit maintenant d'utiliser la commande suivante pour affecter le mot de passe 'secret' à
l'utilisateur root :
set password for 'root'@'::1' = PASSWORD('secret');
Suppression du mot de passe affecté à l'utilisateur root
Utilisez la commande suivante :
set password for 'root'@'::1' = PASSWORD('');
Création de l'utilisateur Pierre sur le serveur localhost
CREATE USER 'Pierre'@'localhost';
Vérifiez que cet utilisateur a bien été créé avec la commande suivante :
SELECT host, user FROM mysql.user;
Affectation d'un mot de passe à l'utilisateur Pierre
Lancez la commande suivante :
SET PASSWORD FOR 'Pierre'@'localhost' = PASSWORD('monpass');
Affectation de privilèges à l'utilisateur Pierre sur les tables de la base localhost
GRANT ALL PRIVILEGES ON localhost.* TO 'Pierre'@'localhost' IDENTIFIED BY
'monpass';
Suppression de l'utilisateur Pierre

34
DROP USER 'Pierre'@'localhost';
Vérifiez que l'utilisateur Pierre a bien été supprimé avec cette commande :
SELECT host, user FROM mysql.user;

35
Se connecter à une table en PHP avec
MySQL
Pour se connecter à une base de données MySQL, nous utiliserons une approche objet avec
l'extension PDO (PHP Data Object). La technique étudiée ici est utilisable sur d'autres bases
de données. Par exemple PostgreSQL ou Oracle.
Activer PDO
Avant de pouvoir utiliser PDO, vous devez
activer cette extension. En principe, elle
devrait être activée par défaut par
WampServer. Pour le vérifier, cliquez sur
l'icône de WampServer dans la zone de
notification, pointez PHP puis Extensions
PHP. Une coche devrait être affichée
devant php_pdo_mysql, comme dans la
figure ci-contre.
Si l'extension php_pdo_mysql n'est pas
précédée d'une coche, cliquez dessus,
fermez puis redémarrez WampServer.
L'extension php_pdo_mysql devrait
maintenant être activée.

36
Remarque
Si vous n'utilisez pas WampServer, vous pouvez activer/désactiver l'extension php_mysql en
agissant sur le fichier php.ini (dossier Apache 2.x.xbin). Recherchez la ligne contenant le
terme "php_pdo_mysql". Supprimez le ";" qui la précède pour activer l'extension ou insérez un
";" pour la désactiver. Ici par exemple, l'extension php_pdo_mysql est active :
Connexion objet avec PDO
Nous allons établir une connexion avec la table testtable de la base testconsole définie dans
une section précédente. Si vous avez supprimé cette table, créez-la dans la console MySQL
et insérez-y les données suivantes :
Chantal, Garnier, 128, NOM()
La connexion avec la base de données se fait en créant une instance de la classe PDO :
$base = new PDO('mysql:host=nomserveur; dbname=nombase', 'nomutilisateur',
'motdepasse');
Où :
 nomserveur est le nom du serveur de base de données ;
 nombase est le nom de la base de données ;
 nomutilisateur est le nom d'utilisateur avec lequel se connecter sur la base de
données ;
 motdepasse est le mot de passe associé au nom d'utilisateur choisi.

37
Par exemple, pour se connecter sur la base testconsole du serveur localhost en utilisant le
nom d'utilisateur root auquel aucun mot de passe n'est associé, vous utiliserez l'instruction
suivante :
$base = new PDO('mysql:host=localhost; dbname=testconsole', 'root', '');
Pour identifier les erreurs qui pourraient se produire sur cette instruction, vous utiliserez une
structure try catch :
<?php
try {
$base = new PDO('mysql:host=localhost; dbname=testconsole', 'root', '');
}
catch(exception $e) {
die('Erreur '.$e->getMessage());
}
?>
Exécutez ce code. Si aucun message d'erreur n'est affiché, la base de données est bien
accessible.
Avant de lire les données dans la base de données, vous allez indiquer l'encodage à utiliser
avec la méthode exec() :
$base->exec("SET CHARACTER SET utf8");
Pour lire les données contenues dans une table, vous utiliserez une requête SQL. Cette
requête sera passé à l'objet PDO $base avec la méthode query() :
$retour = $base->query('requete');
Où requête est la requête SQL à exécuter.
Par exemple, pour obtenir toutes les données de la table testtable, vous utiliserez
l'instruction suivante :
$retour = $base->query('SELECT * FROM testtable');
Il ne reste plus qu'à traiter les données retournées avec une boucle while :
while ($data = $retour->fetch()){
echo $data['prenom'].' '.$data['nom'].' : connecté
'.$data['compteurvisite'].' fois (dernière connexion le
'.$data['dernierevisite'].')<br>';
}

38
Lorsque les données auront été extraites de la base de données, vous pourrez supprimer
l'objet PDO $base pour mettre fin à la connexion :
$base = null;
Voici le code complet :
<!DOCTYPE html>
<html>
<head>
<title>Accès à la bdd testconsole avec PDO</title>
</head>
<body>
<?php
try {
$base = new PDO('mysql:host=localhost; dbname=testconsole', 'root',
'');
}
}
$retour = $base->query('SELECT * FROM testtable');
echo $data['prenom'].' '.$data['nom'].' : connecté
'.$data['compteurvisite'].' fois (dernière connexion le
'.$data['dernierevisite'].')<br>';
}
$base = null;
?>
</body>
</html>
La boîte de dialogue est bien accessible et la requête produit plusieurs enregistrements qui
sont affichés sur l'écran avec l'instruction echo.

39
Exercice
Pour travailler sur des données plus consistantes, vous allez utiliser plusieurs tables fournies
en exemple par Microsoft dans la base de données Northwind.
Commencez par télécharger les fichiers suivants :
Fichier Emplacement
customers.csv http://www.mediaforma.com/encours/customers.csv
orders.csv http://www.mediaforma.com/encours/orders.csv
order_details.csv http://www.mediaforma.com/encours/order_details.csv
Ouvrez phpMyAdmin en tant qu'utilisateur root. Importez ces trois tables dans la base de
données northwind, sous les noms customers, orders et order_details.
Solution
Faites une pause dans la vidéo pour vous permettre de créer la base de données northwing
et d'y importer les trois tables que vous aurez téléchargées. Poursuivez la lecture de la vidéo
pour avoir des informations détaillées sur l'importation.
1) Une fois connecté à phpMyAdmin en tant que root, sélectionnez l'onglet Importer et
importez les fichiers customers.csv, orders.csv et order_details.csv . Vous utiliserez
le paramétrage suivant :
- Jeu de caractères UTF8
- Format CSV
- Colonnes séparées par des points-virgules
- Colonnes entourées par des guillemets
- Cochez la case "La première ligne du fichier contient le nom des colonnes de la table"
2) Renommez la base de données csv_db en northwind. Pour cela, cliquez sur csv_db
dans le volet gauche, sélectionnez l'onglet Opérations et utilisez le groupe d'options
Changer le nom de la base de données pour :
3) Modifiez le nom des tables en customers, orders et order_details. Pour cela, cliquez sur
leur nom dans le volet gauche, basculez sur l'onglet Opérations et utilisez le groupe
d'options Copier la table vers :
Exercice
Affichez tous les champs de tous les enregistrements de la table customers dans un tableau.
Solution
Faites une pause dans la vidéo pour vous permettre de définir le code. Vous pourrez
poursuivre le visionnage de la vidéo pour prendre connaissance de la solution.

40
Voici le code à utiliser :
<!DOCTYPE html>
<html>
<head>
<title>Accès à la bdd testconsole avec PDO</title>
</head>
<body>
<?php
try {
$base = new PDO('mysql:host=localhost; dbname=northwind', 'root',
'');
}
}
$retour = $base->query('SELECT * FROM customers');
echo "<table>";
echo "<tr><td>".$data['CustomerID']."</td>";
echo "<td>".$data['CompanyName']."</td>";
echo "<td>".$data['ContactName']."</td>";
echo "<td>".$data['ContactTitle']."</td>";
echo "<td>".$data['Address']."</td>";
echo "<td>".$data['City']."</td>";
echo "<td>".$data['PostalCode']."</td>";
echo "<td>".$data['Country']."</td></tr>";
}
echo "</table>";

41
$base = null;
?>
</body>
</html>
La base de données est ouverte en créant un objet PDO.
Si une erreur se produit à l'ouverture de la base, elle est affichée et le programme s'arrête
Si tout s'est bien passé, on indique que l'encodage à utiliser est UTF-8
Puis une requête SQL est appliquée à la table customers. Cette requête retourne tous les
champs de tous les enregistrements de la table customers.
Les données filtrées par la requête sont obtenues avec la fonction fetch. Une boucle while
permet de parcourir toutes les données de la table. Les champs de chaque enregistrement
sont alors affichés dans les colonnes d'un tableau HTML.
Enfin, l'objet PDO $base est supprimé pour mettre fin à la connexion.
Exercice
Interrogez la table orders et affichez les champs OrderID, Customer et ShipCity des
enregistrements dont le champ ShipCountry vaut France.
Solution
<!DOCTYPE html>
<html>
<head>
<title>Accès à la table orders de la bdd Northwind avec PDO</title>
<style>
td { padding-right: 30px;}
</style>
</head>
<body>
<?php

42
try {
'');
}
}
$retour = $base->query('SELECT OrderID, Customer, ShipCity FROM orders
WHERE ShipCountry="France"');
echo "<table>";
echo "<tr><td>".$data['OrderID']."</td>";
echo "<td>".$data['Customer']."</td>";
echo "<td>".$data['ShipCity']."</td></tr>";
}
echo "</table>";
$base = null;
?>
</body>
</html>
La base de données est ouverte en créant un objet PDO.
Si une erreur se produit à l'ouverture de la base, elle est affichée et le programme s'arrête
Si tout s'est bien passé, on indique que l'encodage à utiliser est UTF-8
Puis une requête SQL est appliquée à la table orders. Cette requête récupère les champs
OrderID, Customer et Shipcity pour lesquels le champ shipcountry vaut France.
Les données filtrées par la requête sont obtenues avec la fonction fetch. Une boucle while
permet de parcourir toutes les données de la table. Les champs de chaque enregistrement
sont alors affichés dans les colonnes d'un tableau HTML.
Enfin, l'objet PDO $base est supprimé pour mettre fin à la connexion.
Exécutons ce script dans WAMP Server. Voici le résultat.

43
Utilisation de variables PHP dans des requêtes
Pour insérer des variables dans une requête MySQL, vous utiliserez des "requêtes préparées"
:
$retour = $base->prepare('requête');
Où requête est une requête MySQL qui contient un ou plusieurs caractères "?". Par exemple
:
SELECT * FROM base WHERE champ1=? AND champ2=?
Les caractères "?" seront remplacés par des valeurs lors de l'exécution de la méthode execute
:
$retour->execute(array($var1, $var2));
Exercice
Reprenez l'exercice précédent, mais cette fois-ci, utilisez une requête préparée.
Solution
<?php
try {
$base = new PDO('mysql:host=localhost; dbname=northwind', 'root', '');
}
}
$retour = $base->prepare('SELECT OrderID, Customer, ShipCity FROM orders
WHERE ShipCountry=?');
$retour->execute(array("France"));
echo "<table>";
echo "<td>".$data['ShipCity']."</td></tr>";

44
}
echo "</table>";
$base = null;
?>
La plupart des instructions sont conservées. Notez cependant que la méthode query est
remplacée par la méthode prepare. La valeur affectée au champ ShipCountry dans la clause
WHERE n'est pas spécifiée en clair. Un point d'interrogation remplace la valeur à utiliser.
Pour indiquer que les enregistrements sélectionnés doivent avoir un champ ShipCountry égal
à France, on invoque la méthode execute en lui passant la chaîne France.
Exécutons ce code dans WAMP Server. Le résultat est bien entendu identique à celui de
l'exercice précédent.

45
Manipuler les données d'une table
avec MySQL
Vous avez découvert et expérimenté les requêtes SQL dans la console MySQL. Tout ce qui a
été dit est également utilisable en PHP.
Voyons comment interroger une table
Après avoir créé un objet PDO :
$base = new PDO('mysql:host=localhost; dbname=nombdd', 'root', '');
Vous pouvez effectuer des sélections dans une table en utilisant la méthode query() :
$retour = $base->query("requête");
Où requete représente la requête SQL que vous voulez exécuter. Vous pouvez par exemple
utiliser les requêtes suivantes :
Requête Effet
SELECT * FROM table; Affiche tous les enregistrements de la table
spécifiée
SELECT nom FROM table; Affiche toutes les valeurs du champ nom de
la table spécifiée.
SELECT * FROM table WHERE ch=valeur; Affiche tous les champs de la table spécifiée
pour lesquels le champ ch vaut valeur.
SELECT * FROM table WHERE ch=valeur
ORDER BY ch2 ASC;
Affiche tous les champs de la table spécifiée
pour lesquels le champ ch vaut valeur, en
classant les réponses par champ ch2
croissants.
SELECT COUNT(*) FROM table; Compte le nombre d'enregistrements de la
table spécifiée.
Pour parcourir le résultat de la requête, vous utiliserez la méthode fetch() :
while ($data = $retour->fetch()) {
echo $data['champ']."<br>"; // Liste les valeurs du champ spécifié
}
Une fois les traitements effectués, détruisez l'objet PDO avec cette instruction :

46
Fonctions SQL
Arrivés à ce point dans la formation, vous utilisez couramment les fonctions du langage PHP.
Mais saviez-vous que le langage SQL possède ses propres fonctions ? Ces dernières pourront
être utilisées dans des requêtes pour affiner les recherches.
Il existe deux types de fonctions SQL :
 Les fonctions scalaires. Elles s'appliquent à chacune des valeurs qui lui sont
passées. Quelques exemples : UPPER(), LOWER(), LENGTH(), ROUND().
 Les fonctions d'agrégat. Elles effectuent des calculs sur une table et retournent un
résultat. Quelques exemples : AVG(), SUM(), MAX(), MIN(), COUNT().
Voyons comment utiliser ces fonctions sur des exemples précis.
Nous allons convertir en minuscules les valeurs du champ CustomerID et en majuscules les
valeurs du champ Country de la table northwind . Voici la table northwind avant et après la
conversion :

47
Pour arriver à ce résultat, vous utiliserez les fonctions scalaires LOWER() et UPPER() :
<!DOCTYPE html>
<html>
<head>
<title>Utilisation de fonctions SQL</title>
<style>
</style>
</head>
<body>
<?php
try {
'');
}
}
$retour = $base->query('SELECT LOWER(CustomerID) as CustomerID_min,
UPPER(Country) as Country_maj FROM customers');
echo "<table>";
echo "<tr><td>".$data['CustomerID_min']."</td>";
echo "<td>".$data['Country_maj']."</td></tr>";
}
echo "</table>";
$base = null;
?>
</body>

48
</html>
Exécutons ce code dans WAMP Server. Le résultat est bien conforme à ce qui était attendu.
Un autre exemple. Supposons que vous vouliez connaître la valeur moyenne du champ
Quantity de la table order_details de la base de données northwind.
Vous utiliserez pour cela la fonction d'agrégat AVG() :
SELECT AVG(Quantity) FROM order_details;
Pour saisir facilement cette requête, rien de tel que l'interface d'administration phpMyAdmin.
Cliquez sur la base de données northwind dans le volet gauche. Basculez sur l'onglet SQL.
Entrez la requête dans la zone dédiée, puis cliquez sur Exécuter. Le résultat est
immédiatement affiché dans la partie inférieure de la fenêtre.
Exercice
Utilisez l'onglet SQL de l'interface d'administration phpMyAdmin pour lancer des requêtes sur
les tables de la base de données northwind. Voici les quatre exercices que je vous propose
de résoudre :
1) Afficher la valeur du champ Product de l'enregistrement qui contient la plus grande
valeur du champ Quantity.
2) Compter le nombre d'enregistrements de la table Orders.

49
3) Affichez le nom de chaque employé (champ Employee de la table Customers, dans
labase de données northwind) suivi de la taille en caractères de ce nom.
4) Dans la table customers de la base de données northwind, affichez en majuscule le
champ Customer pour tous les enregistrements dont le champ ShipCountry vaut
France.
Solution
Faites une pause dans la vidéo pour vous permettre de définir les requêtes. Vous pourrez
poursuivre le visionnage de la vidéo pour prendre connaissance des solutions.
Exercice 1 : Pour afficher la valeur du champ Product de l'enregistrement qui contient la plus
grande valeur du champ Quantity, utilisez cette requête :
SELECT Product, MAX(Quantity) FROM order_details;
Exercice 2 : Pour compter le nombre d'enregistrements de la table Orders,
utilisez cette requête :
SELECT COUNT(OrderID) FROM orders;
Exercice 3 : Pour afficher le nom de chaque employé (champ Employee de la table
Customers, dans labase de données northwind) suivi de la taille en caractères de ce nom,
utilisez la requête suivante :
SELECT Employee, LENGTH(Employee) FROM orders;

50
Exercice 4 : Pour afficher en majuscule le champ Customer pour tous les enregistrements
dont le champ ShipCountry vaut France dans la table customers de la base de données
northwind, utilisez la requête suivante :
SELECT UPPER(Customer) FROM orders WHERE ShipCountry='France';
GROUP BY
Couplée avec une fonction d'agrégat, la clause GROUP BY permet d'obtenir plusieurs résultats
en fonction de la valeur d'un champ.

51
Par exemple, pour compter le nombre de commandes passées par pays dans la table orders
de la base de données northwind, vous utiliserez la requête suivante :
SELECT ShipCountry, COUNT(OrderID) FROM orders GROUP BY ShipCountry;
Voici le résultat :
HAVING
La clause HAVING permet d'appliquer un critère supplémentaire sur une clause GROUP BY. Par
exemple, pour afficher la moyenne des frais de port par pays, à condition que cette moyenne
soit suypérieure à 50 (table orders, base de données northwind), vous utiliserez la requête
suivante :
SELECT ShipCountry, AVG(Freight) AS port_moyen
FROM orders
GROUP BY ShipCountry
HAVING port_moyen > 50
Ici, le champ calculé AVG(Freight) est inclus dans les résultats sous la forme d'un champ
nommé port_moyen. Seuls les enregistrements dont le champ calculé port_moyen est
supérieurà 50 sont affichés.
Voici le résultat :

52
Jointures
Les bases de données relationnelles (comme MySQL) permettent d'insérer plusieurs tables
dans une base de données et de définir des relations entre les tables. Cette section va vous
montrer comment travailler simultanément sur plusieurs tables en PHP en utilisant des
"jointures", c'est-à-dire en reliant les tables par l'intermédiaire d'un champ commun.
Jointures simples
A titre d'exemple, nous allons relier les tables orders et order_detail de la base de données
northwind :

53
Comme vous pouvez le voir, ces deux tables sont reliées par le champ OrderID. En utilisant
une requête SQL appropriée, il sera donc possible d'extraire des données de chacune des
deux tables en reliant leurs enregistrements sur les valeurs communes du champ OrderID.
Plusieurs syntaxes sont possibles.
Sélection de tous les champs des tables orders et order_details pour lesquels le champ
OrderID est identique dans les deux tables :
SELECT * FROM orders, order_details
WHERE orders.OrderID=order_details.OrderID;
Instruction identique à la précédente, mais on utilise des alias sur les tables pour simplifier
l'écriture :

54
SELECT * FROM orders as o, order_details as d
WHERE o.OrderID=d.OrderID;
Sélection des champs OrderID de la table orders, Customer de la table orders et Product
de la table order_details pour lesquels le champ OrderID est identique dans les deux tables
:
SELECT orders.OrderID, orders.Customer, order_details.Product
FROM orders, order_details
Instruction identique à la précédente, mais on utilise des alias sur les champs pour simplifier
l'écriture. Ces alias seront utilisés par la suite dans la boucle while qui récupère les données
de la méthode fetch() :
SELECT orders.OrderID AS id,
orders.Customer AS nom,
order_details.Product AS produit
FROM orders, order_details
Passons à la pratique.
Nous allons lancer une requête SQL pour obtenir les champs suivants : OrderID (table
orders), Customer (table orders) et Product (table order_detail).
Après avoir créé un objet PDO sur la base de données northwind :
Une requête SELECT est exécutée pour obtenir des informations des tables orders et
order_details :
$retour = $base->query("SELECT * FROM orders as o, order_details as d WHERE
o.OrderID=d.OrderID");
Les données retournées sont alors parcourues avec une boucle while :
while ($data = $retour->fetch())
Exécutons ce code dans WAMP Server. Voici le résultat.
Exercice
Ecrivez le code permettant d'afficher les résultats sous la forme d'un tableau dans lequel les
champs OrderID et Customer ne sont pas répétés s'ils sont identiques. Voici le résultat
demandé :

55
Solution
Faites une pause dans la vidéo et écrivez le code demandé. Vous pourrez reprendre le
visionnage de la vidéo pour prendre connaissance de la solution.
<!DOCTYPE html>
<html>
<head>
<title>Jointure entre deux tables</title>
<style>
</style>
</head>

56
<body>
<?php
try {
'');
}
}
$retour = $base->query("SELECT * FROM orders as o, order_details as
d WHERE o.OrderID=d.OrderID");
echo "<table>";
$memoid=0;
if ($memoid == $data['OrderID']){
echo "<tr><td></td><td></td>";
echo "<td>".$data['Product']."</td></tr>";
}
else{
$memoid=$data['OrderID'];
echo "<td>".$data['Product']."</td></tr>";
}
}
echo "</table>";
$base = null;
?>
</body>
</html>

57
Une grande partie du code de la rubrique précédente est conservé. Seule la logique
d'affichage diffère.
Pour ne pas répéter les champs OrderId et Customer, il suffit de comparer la valeur du
champ OrderID de l'enregistrement courant et de l'enregistrement précédent. S'ils sont
égaux, les champs OrderID et Customer ne doivent pas être affichés. Dans le cas contraire,
ils doivent être affichés.
Pour mémoriser la valeur du champ orderId de l'enregistrement précédent, on utilise une
variable tampon nommée $memoid.
Avant d'accéder au premier enregistrement de la réponse, cette variable est initialisée à 0.
L'instruction fetch retourne le premier enregistrement de la réponse. Le champ OrderID est
comparé à la variable $memoid. Comme ils sont différents, OrderID est mémorisé dans
$memoid, puis les champs OrderID, Customer et Product sont affichés.
A la prochaine itération, si orderId est égal à $memoid, seul le champ product est affiché.
Ainsi de suite jusqu'à ce que tous les enregistrements aient été passés en revue.
Exécutons ce code dans Wamp server. Le résultat est bien celui qui était attendu.
Jointures complexes
Les requêtes SQL traditionnelles sont construites sur cette syntaxe :
SELECT [un ou plusieurs champs] FROM [une ou plusieurs tables]
WHERE [une ou plusieurs conditions];
Les jointures simples sont effectuées dans la clause WHERE. Par contre, les jointures
complexes se font entre le FROM et le WHERE via des mots clés spécifiques : INNER JOIN, LEFT
JOIN ou RIGHT JOIN.
Les requêtes SQL complexes ont donc une syntaxe différente :
SELECT [un ou plusieurs champs] FROM [une ou plusieurs tables]
[INNER | LEFT | RIGHT] JOIN [champ de jointure]
WHERE [une ou plusieurs conditions]
Examinons une requête INNER JOIN
La requete SELECT simple :
Devient :

58
SELECT * FROM orders INNER JOIN order_details
ON orders.OrderID=order_details.OrderID
Seule la syntaxe change : le comportement à l'exécution est identique.
Examinons une requête LEFT JOIN
Les requêtes de type LEFT JOIN sont plus permissives que les autres requêtes. Supposons
qu'il existe des enregistrements dans la première table pour lesquels le champ sur lequel
s'effectue la jointure ne soit pas renseigné. Dans une jointure simple, ils seront purement et
simplement ignorés. Dans une jointure de type LEFT JOIN, ils seront retenus, mais la valeur
NULL apparaîtra pour ces enregistrements dans le champ utilisé pour effectuer la jointure ainsi
que dans tous les champs de la deuxième table.
Devient :
SELECT * FROM orders LEFT JOIN order_details
Pour terminer, examinons les requêtes RIGHT JOIN
Les requêtes de type RIGHT JOIN sont comparables aux requêtes LEFT JOIN. Supposons
qu'il existe des enregistrements dans la deuxième table pour lesquels le champ sur lequel
s'effectue la jointure ne soit pas renseigné. Dans une jointure simple, ils seront purement et
simplement ignorés. Dans une jointure de type RIGHT JOIN, ils seront retenus, mais la valeur
NULL apparaîtra pour ces enregistrements dans le champ utilisé pour effectuer la jointure ainsi
que dans tous les champs de la première table.
Devient :
SELECT * FROM orders RIGHT JOIN order_details
Exemples de jointures complexes
Pour mieux comprendre les différences entre les jointures simples et les jointures complexes,
rien de tel que quelques exemples.
En utilisant l'interface Web phpMyAdmin, définissez la table categories composée de deux
champs :
 id_categorie de type int(11), auto incrémenté ;
 nom de type text.
Et la table articles, composée de trois champs :

59
 id_categorie de type int(11), auto incrémenté ;
 titre de type text ;
 catégorie de type int(11).
Ajoutez les données suivantes dans la table categories :
Et ajoutez les données suivantes dans la table articles :
Vous allez maintenant utiliser l'onglet SQL pour appliquer des requêtes SQL sur les tables
categories et articles.
Commencez par définir une jointure simple sur les champs categorie de la table articles
et id_categories de la table categories :
SELECT * FROM articles, categories
WHERE articles.categorie = categories.id_categorie
Exécutez cette requête.

60
Voici le résultat. Vous remarquez que les articles d'id 8 et 9 ainsi que la catégorie 5 ne font
pas partie des résultats. Ceci est "normal" puisqu'aucune correspondance n'existe entre les
champs categorie de la table articles et id_categorie de la table categories :
Essayons la même requête, mais cette fois-ci en utilisant un INNER JOIN :
SELECT * FROM articles INNER JOIN categories
ON articles.categorie = categories.id_categorie;
Vous pouvez vérifier que le résultat est identique.
Essayons la même requête mais cette fois-ci en utilisant un LEFT JOIN :
SELECT * FROM articles LEFT JOIN categories
Cette fois-ci, les enregistrements de la première table qui n'ont pas de correspondance dans
la deuxième font partie des résultats :
Notre quatrième et dernier essai utilisera un RIGHT JOIN :
SELECT * FROM articles RIGHT JOIN categories

61
Cette fois-ci, les enregistrements de la deuxième table qui n'ont aucune correspondance dans
la première font partie des réponses :

62
Créer une base de données, une table
et des enregistrements en PHP
Créer une base de données
Pour créer une base de données, commencez par définir une instance de la classe PDO avec
cette instruction :
$base = new PDO('mysql:host=localhost', 'root', '');
Puis exécutez une instruction SQL CREATE DATABASE :
$base->exec("CREATE DATABASE nom DEFAULT CHARACTER SET utf8 COLLATE
utf8_general_ci");
Où :
 nom est le nom de la base de données que vous voulez créer ;
 DEFAULT CHARACTER SET définit le jeu de caractères à utiliser par défaut dans la base
de données ;
 COLLATE définit l'interclassement (on dit aussi la collation) du jeu de caractères. C'est-
à-dire le sous-jeu de caractères correspondant à une langue ou un ensemble de
langues.
Créer une table
Pour créer une table, commencez par définir une instance de la classe PDO qui pointe vers la
base de données qui a été définie dans l'étape précédente :
$base = new PDO('mysql:host=localhost; dbname=nom', 'root', '');
Où nom est le nom de la base de données dans laquelle vous voulez créer une table.
Cette étape accomplie, vous exécuterez une instruction SQL CREATE TABLE :
$base->exec("CREATE TABLE nomTable(champ1 type1(taille1), …, champN
typeN(tailleN))");
Où :
 nomTable est le nom de la table à créer ;
 champI sont les noms des champs de la table ;
 typeI sont les types des champs ;
 tailleI sont les tailles associées à chacun des types.
Pour améliorer les performances d'accès aux tables MySQL, vous pouvez définir un champ
unique incrémenté de façon automatique chaque fois qu'un enregistrement est ajouté dans la
table.

63
Par exemple, pour ajouter le champ entier autoincrémenté id, vous utiliserez la syntaxe
suivante :
$base->exec("CREATE TABLE nomTable(id INT NOT NULL AUTO_INCREMENT, …)");
Vous pouvez également indexer le champ id en définissant une clé primaire. L'accès aux
enregistrements sera bien plus rapide. Pour cela, utilisez la syntaxe suivante :
$base->exec("CREATE TABLE nomTable(id INT NOT NULL AUTO_INCREMENT,
PRIMARY KEY(id), …)");
Ajouter des données dans une table
La table étant définie, il suffit d'exécuter une instruction SQL INSERT INTO pour chaque
enregistrement :
$base->exec("INSERT INTO nomTable VALUE('val1', … 'valN')");
Où nomTable est le nom de la table dans laquelle doit se faire l'insertion et les valI
correspondent aux différentes valeurs à insérer dans les champs de la table pour créer un
enregistrement.
Cette instruction suppose que tous les champs sont renseignés entre les parenthèses qui
suivent le mot VALUE. Si une partie seulement des champs est renseignée, spécifiez-les entre
parenthèses à la suite du nom de la table :
$base->exec("INSERT INTO nomTable(champ1, champ3, champ4) VALUE('val1',
'val3', 'val4')");
Enfin, si vous le souhaitez, il est possible de définir plusieurs enregistrements en une seule
instruction, en remplaçant le mot VALUE par le mot VALUES :
$base->exec("INSERT INTO nomTable VALUES('val11', … 'val1N'),
('val21', … 'val2N'), ('val31', … 'val3N'), … ");
Exercice
A l'aide d'instructions PHP, définissez :
 La base de données basephp
 La table tablephp, composée des champs suivants :
o id de type entier autoincrémenté non nul, utilisé comme index de la table
;
o nom de type varchar(50) ;
o prenom de type varchar(50) ;
o compteurvisite de type smallint ;
o dernierevisite de type timestamp.
Ajoutez les données suivantes dans la table :

64
Chantal, Garnier, 128, NOW()
Affichez le contenu de la table pour confirmer que tout s'est bien passé.
Solution
Faites une pause dans la vidéo et effectuez les actions demandées dans l'exercice. Vous
pourrez reprendre le visionnage de la vidéo pour avoir des détails sur le code mis en œuvre.
Voici le code utilisé :
<!DOCTYPE html>
<html>
<head>
<title>Création d'une base de données, t'une table et d'enregistrements
dans la table</title>
<style>
</style>
</head>
<body>
<?php
// Création de la base de données
try {
$base = new PDO('mysql:host=localhost', 'root', '');
}
}
$base->exec("CREATE DATABASE basephp DEFAULT CHARACTER SET utf8 COLLATE
utf8_general_ci");
$base = null;

65
// Création de la table
try {
$base = new PDO('mysql:host=localhost; dbname=basephp', 'root', '');
}
}
$base->exec("CREATE TABLE tablephp(id INT NOT NULL AUTO_INCREMENT,
PRIMARY KEY(id), prenom varchar(50), nom varchar(50), compteurvisite
smallint, dernierevisite timestamp)");
// Ajout de données dans la table
$base->exec("INSERT INTO tablephp(prenom, nom, compteurvisite,
dernierevisite) VALUE('Pierre', 'Dubur', 34, NOW())");
dernierevisite) VALUE('Chantal', 'Garnier', 128, NOW())");
dernierevisite) VALUE('Jean', 'Dupont', 2, NOW())");
dernierevisite) VALUE('Belle', 'Vercor', 45, NOW())");
$retour = $base->query('SELECT * FROM tablephp');
echo "<table>";
echo "<tr><td>".$data['prenom']."</td>";
echo "<td>".$data['nom']."</td>";
echo "<td>".$data['compteurvisite']."</td>";
echo "<td>".$data['dernierevisite']."</td>";
}
echo "</table>";
$base = null;
?>
</body>

66
</html>
Le code commence par la définition d'une instance de la classe PDO.
La méthode exec est alors exécutée pour créer la base de données basephp.
La base de données basephp est alors fermée en affectant la valeur null à
son handle.
L'instruction suivante ouvre la base de données basephp.
SI tout s'est bien passé, la méthode exec est utilisée pour créer la table
tablephp.
Le bloc d'instructions suivant ajoute des données dans la table tablephp.
Il ne reste plus qu'à afficher le contenu de la table tablephp. Pour cela,
nous lançons une requête sur la table tablephp et nous affichons son contenu
à l'aide d'une boucle while.
Enfin, la base de données est fermée en en affectant la valeur null à son
handle.
Exécutons ce code dans WAMP Server.
La base de données basephp est créée. La table tablephp est créée. Des données
y sont mémorisées puis son contenu est affiché.

67
Mise à jour et suppression des
données
Mise à jour de données
Vous utiliserez la commande SQL UPDATE pour mettre à jour un enregistrement :
UPDATE table SET champ1=valeur1, champ2=valeur2, champ3=valeur3 WHERE
champN=valeurN;
Où :
 table est le nom de la table concernée par la mise à jour ;
 champ1 à champ3 sont les champs à modifier ;
 valeur1 à valeur3 sont les valeurs à affecter aux champs champ1 à champ3 ;
 champN et valeurN définissent la condition permettant de sélectionner le ou les
enregistrements à modifier.
Exercice
Vous allez travailler sur la table tablephp définie dans l'exercice précédent. Modifiez la casse
du champ nom comme ceci :
 Tous les enregistrements dont le champ compteurvisite est supérieur à 35 doivent avoir
un champ nom écrit en majuscules.
 Tous les enregistrements qui ne répondent pas à cette condition doivent rester
inchangés.
Solution
Faites une pause dans la vidéo et résolvez l'exercice. Vous pourrez poursuivre la vidéo pour
prendre connaissance de la solution.
<?php
try {
}
}

68
$base->exec("UPDATE tablephp SET nom=UCASE(nom) WHERE compteurvisite>35");
echo "<table>";
}
echo "</table>";
$base = null;
?>
Après avoir ouvert la base de données basephp,
une requête SQL met à jour le champ nom de la table tablephp.
Le nom est mis en majuscules pour tous les enregistrements dont le champ
compteurdevisite a une valeur supérieure à 35
Les instructions suivantes affichent les données de la table tablephp.
Exécutons ce code dans WAMP Server. Le résultat escompté est bien celui qui
est obtenu.
Seuls les enregistrements dont le champ compteur de visiute a une valeur
supérieure à 35 ont un champ nom en majuscules.
Suppression de données
Pour supprimer des enregistrements, vous utiliserez l'instruction SQL DELETE :
DELETE FROM table WHERE condition;
Où :
 table est le nom de la table concernée par la suppression ;
 condition est la condition permettant de sélectionner le ou les enregistrements à
supprimer.

69
Exercice
Supprimez les enregistrements de la table tablephp pour lesquels le champ
compteurdevisite est inférieur à 35.
Solution
Faites une pause dans la vidéo et résolvez l'exercice. Vous pourrez poursuivre la vidéo pour
prendre connaissance de la solution.
<?php
try {
}
}
$base->exec("DELETE FROM tablephp WHERE compteurvisite<35");
echo "<table>";
}
echo "</table>";
$base = null;
?>
Après avoir ouvert la base de données basephp, une instruction SQL est
exécutée pour supprimer les enregistrements de la table tablephp pour lesquels
le champ compteurvisite est inférieur à 35.
Les données contenues dans la table tablephp sont alors affichées.

70
Exécutons ce code dans WAMP Server. Comme vous pouvez le constater, seuls les
enregistrements dont le champ compteurvisite a une valeur supérieur à 35
subsistent.
Suppression d'une table et d'une base de données
Pour supprimer une table, connectez-vous à la base de données où elle est stockée en
définissant un objet PDO puis utilisez l'instruction SQL DROP TABLE :
$base = new PDO('mysql:host=localhost; dbname=nomBase', 'root', '');
$base->exec("DROP TABLE nom");
Où nom est le nom de la table à supprimer.
Pour supprimer une base de données, vous devrez utiliser la console MySQL ou la console
d'administration Web phpMyAdmin. Dans le premier cas, utiliserez l'instruction SQL DROP
DATABASE :
DROP DATABASE nom;
Dans le deuxième cas, sélectionnez l'onglet Bases de données, cochez la case de la base
de données à supprimer et cliquez sur Supprimer.

72
Organiser le code selon l'architecture
MVC
Dans des projets de grande envergure, il est important de bien structurer le code PHP pour
faciliter sa maintenabilité. L'architecture MVC apporte une réponse élégante à cette
problématique.
Qu'est-ce que MVC et pourquoi l'utiliser ?
MVC est un design pattern (un modèle de conception) qui permet d'organiser son code selon
trois parties bien précises : Modèle, Vue et Contrôleur. En suivant les directives du modèle
MVC, vous saurez quels fichiers créer et quels rôles leur donner :
 Modèle : Cette partie gère les données du site. Elle récupère les données dans la base
de données (via des requêtes SQL) et les met en forme pour qu'elles puissent être
traitées par la partie Contrôleur.
 Vue : Cette partie est dédiée à l'affichage sur l'écran. Elle est généralement composée
d'un mélange de code HTML et PHP.
 Contrôleur : Cette partie contient la portion "intelligente" du code. Elle reçoit les
données du visiteur, demande au Modèle de trouver les données correspondantes
dans la base de données, analyse les données fournies par le Modèle et décide ce qui
doit être affiché par la partie Vue.

73
Développer un projet selon l'architecture MVC
A titre d'exemple, vous allez développer un projet qui interroge de façon paramétrable la table
orders de la base de données northwind. Le but recherché est d'afficher le contenu de la table
orders, classée selon un de ses champs, en fonction du paramètre passé dans l'URL :
 index.php?tri=0 classe les données par ordre alphabétique sur le premier champ ;
 index.php?tri=1 classe les données par ordre alphabétique sur le deuxième champ
;
 etc.
Création de l'arborescence
Commencez par créer un dossier intitulé MVC dans le dossier c:wampwww. Définissez les
sous-dossiers modele, vue et controleur dans le dossier MVC :
Modèle
La partie modèle du projet va récupérer les données dans la base de données MySQL et les
retourner au contrôleur. Définissez le fichier trier.php dans le dossier MVCmodèle et insérez
les instructions suivantes dans ce fichier.
<?php
function trier($champ) {
$nomchamp=array("OrderID", "Customer", "Employee", "OrderDate",
"RequiredDate", "ShippedDate", "ShipVia", "Freight", "ShipName",
"ShipAddress", "ShipCity", "ShipPostalCode", "ShipCountry");
try {
}

74
}
$retour = $base->query("SELECT * FROM orders ORDER BY
".$nomchamp[$champ]);
$data = $retour->fetchAll();
return $data;
}
?>
Comme vous pouvez le voir, le fichier trier.php contient une seule fonction nommée trier().
Cette fonction admet un paramètre : l'index du champ sur lequel les données doivent être
triées.
Le code est extrêmement simple.
Dans un premier temps, on définit le tableau $nomchamp qui contient le nom des champs de la
table orders. Cette étape est nécessaire, car il faudra spécifier le nom du champ selon lequel
les données doivent être triées dans la requête SQL.
Le code définit alors un accès PDO à la base de données northwind :
Les données sont lues selon l'encodage UTF-8 :
La requête SQL obtient toutes les données de la table orders, classées selon le champ passé
en paramètre de la fonction :
$retour = $base->query("SELECT * FROM orders ORDER BY ".$nomchamp[$champ]);
Le résultat de la requête est stocké dans le tableau $data et retourné à l'appelant :
$data = $retour->fetchAll();
return $data;
Contrôleur
C'est autour du contrôleur que s'articule tout le code. Voici les actions accomplies :
 récupération du paramètre dans l'URL ;
 demande de données au modèle, en fonction du paramètre récupéré dans l'URL ;
 mise en gras de la colonne triée ;
 demande à la vue d'afficher les résultats.
Créez le fichier index.php dans le dossier MVCcontroleur et insérez les instructions
suivantes dans ce fichier :

75
<?php
$tri = $_GET['tri'];
include_once("../modele/trier.php");
// Modèle
// Demande de données au modèle
$donnees = trier($tri);
// Contrôleur
// Mise en gras de la colonne triée
foreach($donnees as &$ligne){
$ligne[$tri] = "<b><i>".$ligne[$tri]."</i></b>";
}
// Vue
// Affichage des résultats
include_once('../vue/resultat.php');
?>
Après avoir récupéré le paramètre tri dans l'URL et l'avoir mémorisé dans la variable $tri :
$tri = $_GET['tri'];
Le fichier modèle/tri.php est inclus dans le code :
include_once("../modele/trier.php");
Les données sont alors extraites de la base de données avec la fonction tri() du modèle :
$donnees = trier($tri);
Pour bien discerner le champ qui a été trié, on le met en gras avec une boucle foreach.
Remarquez l'accès par référence aux données (&$ligne). Ainsi, il sera possible de modifier
les données du tableau donnees de façon durable et pas seulement à l'intérieur de la boucle
foreach :
foreach($donnees as &$ligne){
$ligne[$tri] = "<b><i>".$ligne[$tri]."</i></b>";

76
}
Enfin, les données triées sont affichées en incluant le fichier vue/resultat.php dans le code
:
include_once('../vue/resultat.php');
Vue
La vue est responsable de l'affichage des données sur l'écran. Définissez le fichier
vueresultats.php et insérez les instructions suivantes dans ce fichier :
<!DOCTYPE html>
<html>
<head>
<title>Accès à la table orders de la bdd Northwind avec PDO</title>
<style>
th { padding-right: 30px;}
</style>
</head>
<body>
<?php
echo "<table
border><tr><th>OrderID</th><th>Customer</th><th>Employee</th><th>OrderDate<
/th><th>RequiredDate</th><th>ShippedDate</th><th>ShipVia</th>
<th>Freight</th><th>ShipName</th><th>ShipAddress</th><th>ShipCity</th><th>S
hipPostalCode</th><th>ShipCountry</th></tr>";
foreach($donnees as $ligne){
echo "<tr>";
for ($i=0; $i<13; $i++)
echo "<td>".$ligne[$i]."</td>";
echo "</tr>";
}
echo "</table>";
?>
</body>

77
</html>
Ce code n'a rien de bien compliqué : il affiche le contenu du tableau $donnees dans un tableau
HTML.
Il ne vous reste plus qu'à invoquer le contrôleur avec des URL du type suivant :
http://localhost/MVC/controleur/index.php?tri=valeur
Où valeur représente un nombre compris entre 0 et 11, pour indiquer le champ selon lequel
les données seront triées. Voici le résultat pour un tri sur le champ Customer :
Frameworks MVC
Pour développer des projets selon une architecture MVC, vous pouvez créer tous les fichiers
manuellement, comme nous venons de le faire, ou vous simplifier la tâche en utilisant un
framework dédié, comme par exemple Zend Framework, CakePHP, Symfony ou Jelix.

78
Annexes
Modifier le fichier php.ini
Pour modifier le fichier php.ini sur un serveur privé, vous devez vous connecter en SSH
(Secure Shell) à votre serveur. Pour cela, vous utiliserez le programme PuTTY, librement
téléchargeable ici : http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html.
Entrez l'adresse IP du serveur dans la zone de texte Host Name et cliquez sur Open. Entrez
votre login et votre mot de passe et validez. Une fois la connexion établie, vous pouvez éditer
le fichier php.ini et y faire les modifications souhaitées.
Sécurité
Protéger un dossier avec .htaccess et .htpasswd
Les fichiers .htaccess et .htpasswd permettent de protéger des dossiers et des fichiers sur
un site Web.
Pour interdire l'accès à un dossier, définissez le fichier .htaccess comme ceci et stockez-le
dans le dossier à protéger :

79
Options –Indexes
Si un utilisateur essaye d'afficher le contenu de ce dossier avec son navigateur, il obtiendra
une erreur 403 en retour :
Pour protéger un dossier et les fichiers qu'il contient par un mot de passe, vous devez définir
un fichier .htaccess et un fichier .htpasswd.
Voici le contenu du fichier .htaccess :
AuthName "Zone protégée"
AuthType Basic
AuthUserFile "C:/wamp/www/admin/.htpasswd"
Require valid-user
La première ligne indique le message à afficher dans la boîte de dialogue où sera saisi le login.
La troisième ligne indique l'adresse du fichier .htpasswd.
Sous WAMP, il suffit de donner le chemin complet du fichier. Sur un serveur en ligne, utilisez
la fonction PHP realpath() pour connaître le chemin absolu du fichier .htpasswd :
<?php echo realpath('.htpasswd'); ?>
Voici le contenu du fichier .htpasswd :
user1:pass1
user2:pass2
user3:pass3
etc.
Sous WAMP, le mot de passe est spécifié en clair. Sur un serveur en ligne, le mot de passe
doit être crypté avec la fonction PHP crypt(). Par exemple, si votre mot de passe est
monmotdepasse, vous obtiendrez sa version cryptée avec cette instruction :

80
<?php echo crypt('monmotdepasse'); ?>
Site officiel et documentation
Pour terminer, voici quelques adresses Web indispensables. Vous y trouverez toute la
documentation nécessaire pour aller encore plus loin avec PHP et MySQL.
Le site officiel dédié au langage PHP se trouve http://fr.php.net/
La documentation sur le langage PHP se trouve http://www.php.net/manual/fr/
Le sommaire des fonctions PHP se trouve http://www.php.net/manual/fr/funcref.php
Enfin, l'actualité et la documentation sur MySQL se trouve sur http://www.mysql.fr/
Cette formation est maintenant terminée. J'espère que vous y avez appris beaucoup de
choses.
Si vous le désirez, vous pouvez m'envoyer votre feedback sur admin@mediaforma.com.
Pour terminer ce troisième et dernier tome, sachez que tous les jours, Mediaforma Learning
publie de nouveaux articles sur Windows 7, Windows 8, Office 2010 et 2013, les langages
HTML5, CSS3 et JavaScript, WordPress, PhotoFiltre et OSX Mavericks. Retrouvez- nous sur
http://www.mediaforma.com/testez-nos-produits/.
Tous nos produits (packs eBook + vidéos, livres et CD) sont disponibles à cette adresse :
http://www.mediaforma.com/.
Pour toute remarque ou question, n'hésitez pas à nous joindre en vous rendant sur la page
http://www.mediaforma.com/contact/.
Bonne continuation !

Support tutoriel : Maîtriser PHP MySQL - Tome 3

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Support tutoriel : Maîtriser PHP MySQL - Tome 3

Similaire à Support tutoriel : Maîtriser PHP MySQL - Tome 3 (20)

Plus de SmartnSkilled

Plus de SmartnSkilled (20)

Dernier

Dernier (20)

Support tutoriel : Maîtriser PHP MySQL - Tome 3