PHP et les base de données

Dr N. BAME
 Introduction
• De nombreuses applications PHP utilisent une
base de données.
• Bien que la quasi-totalité des SGBD soit
supportée, le plus couramment utilisé avec PHP
est MySQL.
– Des systèmes permettant d’installer automatiquement
une plate-forme Apache/PHP/MySQL, tels que
WAMPServer et EasyPHP.
– MySQL est doté de nombreux avantages et ses
fonctionnalités sont généralement tout à fait suffisantes
et adaptées à la majorité des applications.
 phpMyAdmin
• Outil développé en PHP destiné à faciliter la gestion
d’un ensemble de bases de données MySQL et cela
à l’aide d’un simple navigateur.

permet de gérer l’ensemble d’un serveur MySQL

aussi bien qu’une simple base de données.

permet d’opérer facilement les tâches

d’administration courantes, de créer une structure de
tables rapidement ou de tester les requêtes pendant le
développement.
 Interactions PHP/BD
• Il existe plusieurs possibilités pour utiliser une base de
données avec PHP.

• On peut pour chaque type de SGBD, utiliser une

extension native dédiée (mysqli pour MySQL, oci8 pour
Oracle…).
Bien que ces extensions aient des similitudes entre elles, on
aura alors à manipuler des fonctions spéci ques différentes
selon le SGBD.

• L’autre solution récente avec PHP 5 est d’utiliser PDO.

extension qui permet de travailler de manière uni ée quel
que soit votre SGBD.
méthode résolument tournée vers l’avenir, offrant beaucoup
de souplesse et de puissance.
 Connexion à la base de données
• Pour pouvoir travailler avec la base de données en PHP, il faut
d'abord s'y connecter.

• Une fois que la connexion est établie, on peut faire toutes les
opérations que l’on veut sur la base de données

• Il existe plusieurs moyens de se connecter à une base de données

MySQL :
L'extension mysql: fonctions qui permettent d'accéder à une base de
données MySQL et donc de communiquer avec MySQL. Leur nom
commence toujours par mysql_.

L'extension mysqli: fonctions améliorées d'accès à MySQL. Elles

proposent plus de fonctionnalités et sont plus à jour.

L'extension PDO : outil complet qui permet d'accéder à n'importe quel

type de base de données. On peut donc l'utiliser pour se connecter aussi
bien à MySQL que PostgreSQL ou Oracle.
 PDO
• PDO (PHP Data Objects) est une interface pour
accéder à une base de données depuis PHP.
• Elle gère la connexion, l’envoie des requêtes, la
déconnexion à la base de données.
• Elle permet de changer plus facilement de
système de gestion de bases de données.
 L'extension PDO (1)
PDO = PHP Data Object
• apporte un confort d’utilisation et une abstraction plus importants
que les anciennes fonctions natives propres à chaque SGBD.

• API permettant un accès uniformisé aux di érentes bases de

données
– Le principal avantage de PDO est qu’on peut l'utiliser de la même
manière pour se connecter à n'importe quel autre type de base de
données (PostgreSQL, Oracle…)

• L’approche objet de PDO permet de plus d’étendre les fonctions

d’accès à la base facilement et de manière transparente.

• PDO fonctionne avec un ensemble d'extensions

– Une extension PDO de base qui définit l'interface commune.
– Une extension Driver PDO relative à chaque SGBD que l'on veut gérer.
L'extension PDO (2)
 L'extension PDO : Activation
• Généralement, PDO est activé par défaut pour
MySQL.
Pour l’activer ; dans le fichier de configuration de PHP
php.ini, dé-commenter (enlever le point virgule devant )
la ligne d’extension pdo du SGBD

;extension=php_pdo_firebird.dll
extension=php_pdo_mysql.dll
;extension=php_pdo_oci.dll
;extension=php_pdo_odbc.dll
extension=php_pdo_pgsql.dll
;extension=php_pdo_sqlite.dll
 L'extension PDO : les classes
3 classes
• PDO : une instance de PDO représente la
connexion à une base de données.
– le plus souvent une seule instance de PDO par exécution
de PHP
• PDOStatement : une instance de PDOStatement
représente une requête vers la base.
– permet de préparer la requête puis de consulter son
résultat.
• PDOException
 Connexion à une base de données
• Pour se connecter à une base de données, on crée un nouveau objet PDO
avec quatre éléments :
l'adresse du serveur : host
le nom d'utilisateur : username
le mot de passe pour l'authentification : password
la base de données à utiliser : dbname
• Création de la connexion : new PDO(...)
• Syntaxe générale
$connexion= new PDO($argDSN, $user, $passwd);
ou
$bdd = new PDO(
'mysql:host= localhost;dbname=databaseName',
'username', 'userPassword'
);
Le premier paramètre (commençant ici par mysql)) qu’on appelle DSN (Data Source
Name) permet d’identifier le serveur de la base de données.
 Exemples de connexions
• Pour Mysql
<?php
$dsn = 'mysql:host=localhost;dbname=scolarite';
$db1 = new PDO($dsn, 'toto ', 'ptiti');
?>
Pour PosgreSQL
<?php
$dsn = "pgsql:host=localhost;dbname=scolarite";
$db2= new PDO($dsn, "ndiaga","ndiogou");
?>

Le DSN peut disposer de données facultatives comme le port ou le socket

(indiquant l’adresse de la socket unix pour la connexion locale) :
$port = '3307';
$socket = '/tmp/mysql.sock';
$dsn = "mysql:host=$hote;port=$port;dbname=$base";
$dsn2 = "mysql:unix_socket=$socket;dbname=$base";
 PDO : requêtes
PDO::exec
• méthode : int exec($requeteSQL)
• bien adaptée pour les requêtes autres que SELECT
• renvoie le nombre de lignes a ectées

PDO::query
• méthode : PDOStatement query($requeteSQL)
• bien adaptée pour les requêtes SELECT exécutées une
fois.
• l’objet PDOStatement permet d’explorer le résultat de la
requête.
 Requêtes
• Requêtes de manipulation : méthode exec
$req1="insert into etudiant values(12,’Diop’,’Moussa’)";
$res=$bdd->exec($req1);
…
$id=15;
$nom=‘Diassy’;
$prenom=‘Amadou’;
$req2="insert into etudiant values($id,’$nom’,’$prenom’)";
$res=$bdd->exec($req2);
 Requêtes
• Requêtes d’interrogation : méthode query
$req1="select * from etudiant" ;
$resultat=$bdd->query($sql);

$id=15;
$req2="select * from etudiant where ne= $id" ;
$resultat=$bdd->query($req2);

• Récupération du résultat : méthode fetch

while ($ligne= $resultat ->fetch()) {
echo $ligne[‘ne'].’ | ’.$ligne[‘nom'].’ | ’. $ligne[‘prenom'] ;
}
 PDOStatement->fetch()
• PDO::FETCH_ASSOC: tableau indexé par le nom de la
colonne
• PDO_FETCH_BOTH (défaut): retourne un tableau indexé par
les noms de colonnes mais aussi par les numéros de
colonnes (débutant à l'indice 0),
• PDO::FETCH_NUM: retourne un tableau indexé par le
numéro de la colonne comme elle est retourné dans votre
jeu de résultat, commençant à 0
• PDO_FETCH_OBJ: retourne un objet anonyme avec les noms
de propriétés qui correspondent aux noms des colonnes
retournés dans le jeu de résultats

• Exemple
$ligne = $resultats–>fetch(PDO::FETCH_ASSOC);
 Fermeture de la connexion
Affecter la valeur NULL à la ressource de connexion

$dsn = 'mysql:host=localhost;dbname=scolarite';
$bdd = new PDO($dsn, 'toto ', 'ptiti');

$sql="select * from etudiant" ;

$resultat=$bdd->query($sql);
while ($ligne= $resultat ->fetch()) {
echo $ligne[‘NE'].’ | ’.$ligne[‘nom'].’ | ’. $ligne[‘prenom'] ;
}
//Fermeture de la connexion
$bdd=NULL;
 Intérêt des requêtes préparées
• La requête ne doit être analysée (ou préparée) qu'une
seule fois, mais peut être exécutée plusieurs fois avec
des paramètres identiques ou différents.
– Lorsque la requête est préparée, la base de données va
analyser, compiler et optimiser son plan pour exécuter la
requête..
– En utilisant les requêtes préparées, vous évitez ainsi de
répéter le cycle analyser/compilation/optimisation.

• Les paramètres pour préparer les requêtes n'ont pas

besoin d'être entre guillemets ; le driver le gère pour
vous.
– Si votre application utilise exclusivement les requêtes
préparées, vous pouvez être sûr qu'aucune injection SQL
n'est possible
 Requêtes préparées : manipulation
1. Préparation de la requête avec des marqueurs
nommés: prepare
$sql="insert into etudiant values(:ne,:nom,:prenom)";
$stmt=$bdd->prepare($sql);

2. Liaison des variables et exécution :

$ne=15; $nom= 'Balde‘;$prenom='Samba‘;
ou
execute(array(…))
$stmt >execute( bindParam() puis execute()
array( 'ne' =>$ne, $stmt->bindParam(':ne', $ne);
'nom'=>$nom, $stmt->bindParam(':nom', $nom);
'prenom'=>$prenom)) ; $stmt->
bindParam(':prenom', $prenom);
$stmt >execute() ;
 Requêtes préparées : interrogation
1. Préparation de la requête avec des marqueurs : prepare
$sql2="select * from etudiant where NE=?" ;
$stmt=$bdd-> prepare($sql2);

2. Liaison des variables et exécution : execute(array(…))

$ne=10;
$stmt->execute(array($ne) ) ;
Ou
$stmt->bindParam(1, $ne);
$stmt->execute();
3. Récupération du résultat : fetch()
while ($row = $stmt->fetch() ) {
echo $row['ne'].’ | ’. $row[‘nom'].’ | ’. $row[‘prenom'] ;
}
 Requêtes préparées : interrogation
3. Récupération du résultat : fetch()
Lier les valeurs du résultat à des variables : bindColumn
/* Lie par les numéros de colonnes */
$stmt->bindColumn(1, $num);
$stmt->bindColumn(2, $name);

/* Lie par les noms de colonnes */

$stmt->bindColumn('prenom', $pname);

while ($row = $stmt->fetch(PDO::FETCH_BOUND))

{
$ligne = $num."\t".$name."\t".$pname."\n";
echo $ligne;
}
 Requêtes préparées
Pourquoi les requêtes préparées ?
Inconvénients:
– plus de lignes de code que pour une requête simple
– exécution unique : performances moindres par rapport à
une exécution directe
– résultat nal identique : exécuter une requête
– débogage de la requête légèrement plus complexe

Avantages:
– impose une certaine rigueur de programmation
– optimisation du temps d'exécutions requis pour les
requêtes exécutées plus d'une fois
– plus grande sécurité au niveau des requêtes
– séparation requête SQL des données
 Tester la présence d'erreurs
– S’il y a une erreur (on est trompé de mot de passe ou de
nom de base de données, par exemple), PHP risque
d'afficher toute la ligne qui pose l'erreur, ce qui inclut le
mot de passe
– Pour éviter que les visiteurs puissent voir le mot de
passe si une erreur survient lorsque le site est en ligne. Il
est préférable de traiter l'erreur.
– En cas d'erreur, PDO renvoie ce qu'on appelle une
exception qui permet de « capturer » l'erreur.
 Tester la présence d'erreurs
try
{
$bdd = new PDO('mysql:host=
localhost;dbname=databaseName', 'username', ‘pwd');
…
}
catch (Exception $e)
{
die(‘Erreur : ‘.$e->getMessage());
}
 Traquer les erreurs
• Pour afficher des détails sur l'erreur, il faut activer
les erreurs lors de la connexion à la base de
données via PDO.

• Lors de la création de l’objet de connexion, activer

un paramètre à la fin pour activer les erreurs :

<?php
$bdd = new PDO('mysql:host=localhost;dbname=test', 'root', '',
array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION ));
?>
Annexes
 La classe PDO
• __construct : Crée une instance PDO qui représente une
connexion à la base
• errorCode : Retourne le SQLSTATE associé avec la dernière
opération sur la base de données
• errorInfo : Retourne les informations associées à l'erreur lors
de la dernière opération sur la base de données
• getAttribute : Récupère un attribut d'une connexion à une
base de données
• setAttribute : Con gure un attribut PDO
• PDO::getAvailableDrivers : Retourne la liste des pilotes PDO
disponibles
• inTransaction : Véri e si nous sommes dans une transaction
• lastInsertId : Retourne l'identi ant de la dernière ligne
insérée ou la valeur d'une séquence
 La classe PDO
• exec : Exécute une requête SQL et retourne le
nombre de lignes affectées
• prepare : Prépare une requête à l'exécution et
retourne un objet
• query : Exécute une requête SQL, retourne un jeu
de résultats en tant qu'objet PDOStatement
• quote : Protège une chaîne pour l'utiliser dans une
requête SQL PDO
• beginTransaction : Démarre une transaction
• commit : Valide une transaction
• rollBack : Annule une transaction (même si le script
php plante) ou Abort()
 La classe PDOStatement
• bindColumn : Lie une colonne à une variable PHP
• bindValue : Associe une valeur à un paramètre
• closeCursor : Ferme le curseur, permettant à la requête d'être de nouveau
exécutée
• columnCount : Retourne le nombre de colonnes dans le jeu de résultats
• debugDumpParams : Détaille une commande préparée SQL
• errorCode : Récupère le SQLSTATE associé lors de la dernière opération sur
la requête
• errorInfo : Récupère les informations sur l'erreur associée lors de la
dernière opération sur la requête
• getAttribute : Récupère un attribut de requête
• getColumnMeta : Retourne les métadonnées pour une colonne d'un jeu de
résultats
• nextRowset : Avance à la prochaine ligne de résultats d'un gestionnaire de
lignes de résultats multiples
• setAttribute : Dé nie un attribut de requête
• setFetchMode : Dé nit le mode de récupération par défaut pour cette
requête
 La classe PDOStatement
• bindParam : Lie un paramètre à un nom de variable
spéci que
• execute : Exécute une requête préparée

• fetch : Récupère la ligne suivante d'un jeu de résultat PDO

• fetchAll : Retourne un tableau contenant toutes les lignes du
jeu d'enregistrements
• fetchColumn : Retourne une colonne depuis la ligne suivante
d'un jeu de résultats
• fetchObject : Récupère la prochaine ligne et la retourne en
tant qu'objet

• rowCount : Retourne le nombre de lignes affectées par le

dernier appel à la fonction PDOStatement::execute()
 Fetch styles
• PDO::FETCH_ASSOC: retourne un tableau indexé par le nom
de la colonne comme retourné dans le jeu de résultats
• PDO::FETCH_BOTH (défaut): retourne un tableau indexé par
les noms de colonnes et aussi par les numéros de colonnes,
commençant à l'index 0, comme retournés dans le jeu de
résultats
• PDO::FETCH_BOUND: retourne TRUE et assigne les valeurs
des colonnes de votre jeu de résultats dans les variables PHP
à laquelle elles sont liées avec la méthode
PDOStatement::bindParam()
• PDO::FETCH_CLASS: retourne une nouvelle instance de la
classe demandée, liant les colonnes du jeu de résultats aux
noms des propriétés de la classe. Si fetch_style inclut
PDO::FETCH_CLASS (c'est-à-dire PDO::FETCH_CLASS |
PDO::FETCH_CLASSTYPE), alors le nom de la classe est
déterminé à partir d'une valeur de la première colonne
 Fetch styles
• PDO::FETCH_INTO: met à jour une instance
existante de la classe demandée, liant les colonnes
du jeu de résultats aux noms des propriétés de la
classe
• PDO::FETCH_LAZY: combine PDO::FETCH_BOTH et
PDO::FETCH_OBJ, créant ainsi les noms des
variables de l'objet, comme elles sont accédées
• PDO::FETCH_NUM: retourne un tableau indexé par
le numéro de la colonne comme elle est retourné
dans votre jeu de résultat, commençant à 0
• PDO::FETCH_OBJ: retourne un objet anonyme avec
les noms de propriétés qui correspondent aux noms
des colonnes retournés dans le jeu de résultats
 La classe PDOException
• PDOException::getMessage : Récupère le message de
l'exception
• PDOException::getPrevious : Retourne l'exception
précédente
• PDOException::getCode : Récupère le code de l'exception
• PDOException::getFile : Récupère le chier dans lequel
l'exception est survenue
• PDOException::getLine : Récupère la ligne dans laquelle
l'exception est survenue
• PDOException::getTrace : Récupère la trace de la pile
• PDOException::getTraceAsString : Récupère la trace de la pile
en tant que chaîne
• PDOException::__toString : Représente l'exception sous la
forme d'une chaîne
• PDOException::__clone : Clone l'exception
 Approche classique PHP 4 : mysql
Il faut noter qu’en utilisant l’extension mysql classique
on n’aura pas accès :
aux fonctionnalités de MySQL 5 ;
à la version objet ;
aux requêtes préparées.
 L'extension mysql (1)
• Connexion à la base de données
1. Connexion au serveur
La fonction mysql_connect(), permet de se connecter à un serveur MySQL
et possède trois arguments principaux :
l'adresse du serveur
le nom d'utilisateur
le mot de passe pour l'authentification

2. Choix de la base de données

La fonction mysql_select_db(), permet de choisir une base de données à
utiliser sur un serveur MySQL. Elle prend deux arguments principaux :
Le nom de la base de données à utiliser
La ressource retournée par mysql_connect() : optionnel
<?php
$link =mysql_connect(‘localhost', ‘toto', ‘ptiti');
$db = mysql_select_db(‘scolarite‘, $link);
?>
 L'extension mysql (2)
Requêtes
• On exécute une (seule) requête SQL avec la fonction
mysql_query().
– Cette fonction prend au moins un paramètre : une requête SQL
sous forme de chaîne.
– La fonction retourne FALSE en cas d'échec (colonne ou table
invalide, droits insuffisants, pas de connexion, etc).
• Remarque : La requête SQL ne doit pas finir par un point-
virgule.
• La requête peut être de n'importe quel type (sélection,
mise à jour, destruction, etc.).
• Dans le cas d'un SELECT, SHOW, EXPLAIN ou DESCRIBE,
mysql_query() retourne une ressource qui sera ensuite
utilisée pour lire le résultat.
 Exemple

<?php
$link = mysql_connect(‘localhost', ‘toto', ‘ptiti');
$db = mysql_select_db(‘scolarite‘, $link);

$req = "SELECT nom, prenom FROM etudiant WHERE classe=

‘L3GL'";

$resultat = mysql_query ($req, $db);

?>
 L'extension mysql (3)
Récupération du résultat
• La fonction mysql_fetch_array() permet de récupérer les
enregistrements après l'exécution d'une sélection est
Elle prend en paramètre la ressource résultat (résultat de
mysql_query).
Elle retourne une ligne de résultat sous forme d'un tableau
associatif, d'un tableau indexé ou des deux.
• Par défaut, le tableau retourné est à la fois associatif et indexé.
• Dans un tableau associatif, l'index du tableau est le nom du champ
correspondant à la colonne.
• Dans un tableau indexé, les colonnes sont numérotées à partir de zéro.

• Remarque : mysql_fetch_array() ne retourne qu'une seule

ligne de résultat.
Pour passer à la suivante, il faut exécuter la fonction à nouveau.
Elle retournera FALSE quand il n'y aura plus de lignes à lire.
 Exemple
<?php
$link = mysql_connect(‘localhost', ‘toto', ‘ptiti' );
$db = mysql_select_db(‘scolarite‘, $link);
$req = "SELECT nom, prenom FROM etudiant WHERE classe= ‘L3GL'";
$resultat = mysql_query ($req );

$ligne = mysql_fetch_array($resultat);
while ($ligne) {
// Affiche le champ prenom
echo $ligne['prenom'], ' ';
// Affiche le champ nom
echo $ligne['nom'], '<br>';

echo $ligne[0].', '. $ligne[1]; //Idem

$ligne = mysql_fetch_array($resultat);
}
?>
 L'extension mysql (4)
• Si plusieurs colonnes portent le même nom, la dernière colonne
sera prioritaire.
Dans une requête affichant des noms de colonnes identiques, le mieux
est de les renommer

• Le second paramètre de mysql_fetch_array() peut être :

MYSQL_ASSOC : le résultat est uniquement un tableau associatif
(index=nom de colonne)
MYSQL_NUM : le résultat est uniquement un tableau indexé
numériquement.
MYSQL_BOTH (par défaut) : les deux

Il existe deux autres fonctions possibles :

• mysql_fetch_row() :
– équivaut à mysql_fetch_array($resultat, MYSQL_NUM)
• mysql_fetch_assoc() :
– équivaut à mysql_fetch_array($resultat, MYSQL_ASSOC)
 L'extension mysql (5)
Insertion avec auto-incrément
• L'identifiant unique d'une table peut être un entier
auto-incrémenté.

L'avantage est qu'il n'y a pas besoin de gérer cet

identifiant, c'est MySQL qui le détermine tout seul.

Mais dans certains cas, il peut être nécessaire de

récupérer la valeur de ce champ auto-incrémenté après
une insertion pour, par exemple, mettre à jour un autre
enregistrement (liste chaînée, jointure, etc).

Pour cela, on utilise la fonction mysql_insert_id().

 Exemple
$resultat=mysql_query("insert into etudiant (nom, prenom)
values (‘Diagne', Modou ')");
$id=mysql_insert_id();
$resultat=mysql_query("select nom, prenom from etudiant
where mat=$id");
$ligne=mysql_fetch_array($resultat);
echo $ligne[‘prenom'].', '. $ligne[‘nom']; // Modou, Diagne
 L'extension mysqli (1)
• Permet de profiter des fonctionnalités de MySQL
4.1 et +

• Disponible à partir de PHP 4.1.3

• PHP doit être compilé avec le support de l'extension

mysqli (linux)

• L'extension mysqli doit être activée dans php.ini

(windows)
 L'extension mysqli A (1)
• Connexion
La fonction mysqli_connect(), possède 4 arguments
principaux :
l'adresse du serveur
le nom d'utilisateur
le mot de passe pour l'authentification
la base de données à utiliser

<?php
$link = mysqli_connect(‘localhost', ‘toto', ‘ptiti', ‘scolarite');
…
?>
 L'extension mysqli A (2)
Requêtes
• La fonction mysqli_query() permet d'envoyer une
requête au serveur MySQL
• Elle prend deux paramètres :
– un identifiant de connexion vers le serveur
– une requête SQL

<?php
$bd = mysqli_connect(‘localhost', ‘toto', ‘ptiti', ‘scolarite');

$req = "SELECT nom, prenom FROM etudiant WHERE classe= ‘L3GL'";

$resultat = mysqli_query( $bd, $req );
?>
 L'extension mysqli A (3)
Récupération du résultat
• Trois fonctions pour récupérer le résultat d'une requête :
– mysqli_fetch_assoc() : Récupère le résultat sous forme de tableau associatif
– mysqli_fetch_row() : Récupère le résultat sous forme de tableau indexé
– mysqli_fetch_object() : Récupère le résultat sous forme d'objet
<?php
$bd = mysqli_connect(‘localhost', ‘toto', ‘ptiti', ‘scolarite');
$req = "SELECT nom, prenom FROM etudiant WHERE classe = ‘L3GL'";
$resultat = mysqli_query( $bd, $req );

$ligne = mysqli_fetch_assoc($resultat);
while ($ligne ) {
// Affiche le champ prenom
echo $ligne ['prenom'], ' ';
// Affiche le champ nom
echo $ligne ['nom'], '<br>';
$ligne = mysqli_fetch_assoc($resultat);
}
?>
 L'extension mysqli A (4)
Récupération du résultat
• Trois fonctions pour récupérer le résultat d'une requête :
– mysqli_fetch_assoc() : Récupère le résultat sous forme de tableau
associatif
– mysqli_fetch_row() : Récupère le résultat sous forme de tableau indexé
– mysqli_fetch_object() : Récupère le résultat sous forme d'objet

<?php
$link = mysqli_connect(‘localhost', ‘toto', ‘ptiti', ‘scolarite');
$req = "SELECT nom, prenom FROM etudiant WHERE classe = ‘L3GL'";
$resultat = mysqli_query( $link, $req );

while ($ligne = mysqli_fetch_row($resultat) ) {

// Affiche le champ prenom
echo $ligne [1], ' ';
// Affiche le champ nom
echo $ligne [0], '<br>';
}
?>
 L'extension mysqli A (5)
Récupération du résultat
• Trois fonctions pour récupérer le résultat d'une requête :
– mysqli_fetch_assoc() : Récupère le résultat sous forme de tableau
associatif
– mysqli_fetch_row() : Récupère le résultat sous forme de tableau indexé
– mysqli_fetch_object() : Récupère le résultat sous forme d'objet
<?php
$link = mysqli_connect(‘localhost', ‘toto', ‘ptiti', ‘scolarite');
$req = "SELECT nom, prenom FROM etudiant WHERE classe = ‘L3GL'";
$resultat = mysqli_query( $link, $req );

while ($ligne = mysqli_fetch_assoc($resultat)) {

// Affiche le champ prenom
echo $ligne ['prenom'], ' ';
// Affiche le champ nom
echo $ligne ['nom'], '<br>';
}
?>
 L'extension mysqli B (1)
Requêtes préparées
• L’exécution d’une requête préparée s’effectue en six
étapes:
1. Préparation de la requête,
• $req_pre = mysqli_prepare($bd, 'SELECT Nom, Prenom FROM
etudiant WHERE nom = ?');
2. Liaison des variables à la requête,
$name= "DIOUF" ;
mysqli_stmt_bind_param($req_pre, "s", $name);
• $req_pre est la variable de la requête préparée. s est le type de la
variable qui suit : (i:entier, d : décimal, s:chaîne)
• La variable correspond à ce qui va remplacer le point d'interrogation
dans la requête.
• Ces lettres doivent être placées selon l’ordre dans lequel
apparaissent les variables après, tel que les variables doivent
apparaître dans l'ordre des points d'interrogation dans la requête.
Les lettres doivent être dans le même paramètre.
 L'extension mysqli B (2)
Requêtes préparées
3. Exécution de la requête
mysqli_stmt_execute($req_pre);
4. liaison des variables de résultat
mysqli_stmt_bind_result($req_pre, $nom, $pnom);
5. Lecture des valeurs
while (mysqli_stmt_fetch($req_pre)) {
echo $nom .’ ’. $pnom;
}
6.Fermeture de la commande
mysqli_stmt_close($req_pre);
 L'extension mysqli (8)
Fermeture de la connexion
• La fonction mysqli_close() permet de fermer la connexion.
• Elle prend en argument l'identifiant de connexion
<?php
$link = mysqli_connect(‘localhost', ‘toto', ‘ptiti', ‘scolarite');
$req = "SELECT nom, prenom FROM etudiant WHERE classe = ‘L3GL'";
$resultat = mysqli_query( $link, $req );
$ligne = mysqli_fetch_assoc($resultat);
while ($ligne ) {
// Affiche le champ prenom
echo $ligne ['prenom'], ' ';
// Affiche le champ nom
echo $ligne ['nom'], '<br>';
}

//ferme la connexion
mysqli_close($link);
?>
 Mysqli : accès objet (1)
1. Initialisation de la connexion
$db = new mysqli(’localhost’,’Moussa’,’mnd94’,’Scolarite’);

2. Envoi d’une requête au serveur MySQL

$resultat = $db->query("SELECT FROM Etudiants");

3. Si la requête est un SELECT, lecture ligne par ligne du résultat

reçu
while ($ligne = $resultat->fetch_assoc() ) {…}

4. La fermeture de la connexion est automatiqu en n de

page. Sinon affecter la valeur NULL à la ressource de
connexion
$db = NULL;
 Mysqli : accès objet (2)
Requête préparées
1. Initialisation de la connexion
$db = new mysqli(’localhost’,’Moussa’,’mnd94’,’Scolarite’);
2. Préparation de la requête
$req_pre = $mysqli->prepare("INSERT INTO Etudiant VALUES (?, ?)");
3. Liaison des variables à la requêtes
$prenom=‘Mady’;$nom="Cissé";
$req_pre->bind_param("ss", $nom,$prenom);
4. Exécution de la requête
$req_pre->execute();
5. liaison des variables de résultat pour des sélections
$req_pre2->bind_result( $nom, $pnom);
6. Lecture des valeurs
while ($req_pre2 ->fetch()) {
echo $nom .’ ’. $pnom; }
7. Fermeture de la commande
$req_pre2 ->close();