PHP Accès Aux Données

Développement Web Langage PHP
Mohamed HARRANE Page 1

 Principe
 PHP propose de nombreux outils permettant de travailler avec la plupart
des SGBDR
• Oracle, Sybase, Microsoft SQL Server, PostgreSQL ou encore MySQL
 Lorsqu'une base de données n'est pas directement supportée par PHP, il est
possible d'utiliser un driver ODBC (pilote standard) pour communiquer avec
les bases de données
 PHP fournit un grand choix de fonctions permettant de manipuler les bases
de données.
• Quatre fonctions sont essentielles:
– La fonction de connexion au serveur
– La fonction de choix de la base de données
– La fonction de requête
– La fonction de déconnexion

Il existe 2 possibilités dans PHP : la classe mysqli et la classe PDO. L'avantage de PDO est de pouvoir
gérer différents SGBD. La classe mysqli permet de se connecter juste au SGBD MySQL.
 Principe
 Avec le SGBD MySQL, les fonctions de manipulation sont :
⁃ mysqli_connect
⁃ mysqli_select_db
⁃ mysqli_query
⁃ mysqli_close

 La connexion à un SGBDR
 La connexion à (un serveur) un système de gestion de base de
données s'effectue par l'entremise des fonctions spécialisées :
mysqli_connect("nom_serveur","nom_utilisateur","mot_passe");
mysqli_connect ( string host, string username, string passwd, string dbname,
int port , string socket )
La fonction mysqli_connect essaie d'ouvrir une connexion au serveur
MySQL de l'hôte host qui peut être un nom d'hôte ou une adresse IP.
Si la valeur NULL ou la chaîne "localhost« est passée à ce paramètre,
l'hôte local est sous-entendu. Lorsque c'est possible, les sockets seront
utilisées au lieu du protocole TCP/IP. mysqli_connect retourne une
ressource de connexion au serveur MySQL en cas de succès et,
sinon, FALSE .

<?php
$cn = mysqli_connect("localhost", "root", "123456", "maBD");
/* Vérification de la connexion */
if (!$cn) {
printf("Échec de la connexion : %s\n", mysqli_connect_error());
exit();
}
printf("Infos sur le serveur : %s\n", mysqli_get_host_info($cn));
/* Fermeture de la connexion */
mysqli_close($cn);
?>

 Déclarer les variables qui vont permettre la connexion à la base de

données
• Il est utile de créer un script PHP contenant les variables de connexion
sous forme de variables et lier ce script aux autres scripts en utilisant
l’instruction include().
<?php
$serveur="localhost";
$user="root";
$password="";
$bdd="ouvrage";
$cn = mysqli_connect($serveur, $user, $password, $bdd);
if (mysqli_connect_errno()) {
echo ("Échec de la connexion : ". mysqli_connect_error());
die ("Code d’erreur : ".mysqli_connect_errno());
}
?>
Lecture et récupération des données
<?php
$cn = mysqli_connect('localhost', 'root’, '','bts_laureaut’);
mysqli_set_charset($cn, "utf8");
/* Vérification de la connexion */
if (mysqli_connect_errno()) {
printf("Échec de connexion : %s\n", mysqli_connect_error());
exit();
}

Lecture et récupération des données
$sql="SELECT * FROM actualite";
$result = mysqli_query($cn, $sql);
echo "<table border=1>";
echo "<tr>";
echo "<td>N°</td>"; echo "<td>Titre</td>";
echo "<td>Résumé</td>"; echo "</tr>";
while ($row=mysqli_fetch_assoc($result)) {
echo "<tr>";
echo "<td>".$row['id_actualite']."</td>";
echo "<td>". $row['titre']."</td>";
echo "<td>".$row['resume']."</td>";
echo "</tr>";
}
echo "</table>";
?>

 Il existe deux façons de se connecter à une base de données
• Les connexions non-persistantes (base_connect)
• Les connexions persistantes (base_pconnect).
 Les deux types de connexions sont parfaitement identiques au

niveau des fonctionnalités qu'elles apportent
 Néanmoins, les connexions persistantes ne se referment pas
automatiquement à la fin du script
• PHP s'assure qu'il n'existe pas un processus semblable, déjà ouvert avec
les noms de serveur et d'utilisateur ainsi que le mot de passe. Si tel est le
cas, ce processus est réutilisé sinon un nouveau est ouvert
• le principal avantage des connexions persistantes est leur réutilisabilité

 La déconnexion des bases de données s'effectue par l'intermédiaire des
fonctions de fermeture.
• mysqli_close($id_connexion);
 Plusieurs fonctions PHP permettent de retourner des informations à propos

de la connexion en cours
• $chaine_numero_version = mysqli_get_client_info();
• $type_connexion = mysqli_get_host_info($id_connexion);
• $protocole_connexion = mysqli_get_proto_info($id_connexion);
• $chaine_version_serveur = mysqli_get_server_info($id_connexion);
• $nom_hote = pg_host($id_connexion);
• $option_connexion = pg_options($id_connexion);
• $num_port = pg_port($id_connexion);
• $encodage = pg_client_encoding($id_connexion);


 L'accès aux bases de données

 Certaines fonctions permettent de retourner la liste des bases de données et
de leurs tables.
$conx = mysqli_connect('localhost', 'admin’, ‘xx');
$liste_bases = mysql_list_dbs($conx );
$nb_bases = mysql_num_rows($liste_bases);
echo "<h3>Liste des bases de données</h3>";
for($i = 0; $i < $nb_bases; $i++){
$nom_base_donnee = mysql_db_name($liste_bases, $i);
$liste_tables = mysql_list_tables($nom_bd, $conx);
$nb_tables = mysql_num_rows($liste_tables);
echo "<h3>" . $nom_bd . "</h3>";
echo "<h4>Liste des tables :</h4>";
for($j = 0; $j < $nb_tables; $j++) {
echo mysql_tablename($liste_tables, $j) . "<br>"; }
}

 Les requêtes SQL

 Les requêtes doivent répondre à la syntaxe SQL en général et
éventuellement aux singularités des différents éditeurs de SGBDR.
 Les requêtes SQL permettent d'accomplir une action sur une base de
données comme
• la sélection d'informations,
• la création de tables,
• l'ajout, la suppression ou la modification des enregistrements.
 Les requêtes SQL sont envoyées à la base de données définie par un
identificateur de connexion
$requete = "SELECT * FROM table WHERE champ = \"valeur\"";

$id_resultat = mssql_query($requete, $id_connexion);
$id_resultat1 = mysql_query($requete, $id_connexion);

 Les requêtes SQL

• $requete1 = "CREATE TABLE tbl_nom ("
."nom_champ1 INTEGER PRIMARY KEY,"
. "nom_champ2 CHAR(50) UNIQUE,"
. "nom_champ3 DATETIME)";
• $requete2 = "INSERT INTO tbl_nom "

. "(nom_champ1, nom_champ2,.nom_champ3) "
. "VALUES('valeur','valeur2','valeur3')";
• $requete3 = "SELECT * FROM tbl_nom “

. "WHERE nom_champ2 = 'valeur'";
• $requete4 = "DELETE FROM tbl_nom “

. "WHERE nom_champ3 < SYSDATE - 7";

 Traitement des résultats d’une requête
 La variable contenant l'ensemble des enregistrements retournés

par une requête n'est pas exploitable telle quelle.
• On utilise la fonction mysql_fetch_row(), qui découpe les
lignes de résultat en colonnes (exemple Nom, adresse,...) et
les affecte à une variable tableau dans l'ordre où elles
arrivent.
 Exemple: une table appelée liens contenant le nom et l'URL de

sites internet.
• récupérer l'ensemble des enregistrements et de les afficher
dans un tableau.

<html>
<head> <title>Liens</title> </head>
<body>
<table border="1" cellpadding="0" cellspacing="0">
<tr>
<th>Nom du site</th>
<th>URL</th>
</tr>
<?php
// Déclaration des paramètres de connexion
$host = la_machine;
$user = votre_login;
$bdd = Nom_de_la_base_de_donnees;
$password = Mot_de_passe;
// Connexion au serveur
mysql_connect($host, $user,$password) or die("erreur de connexion au
serveur");
mysql_select_db($bdd) or die("erreur de connexion a la base de données");

// Création et envoi de la requête
$query = "SELECT nom,url FROM sites ORDER BY nom";
$result = mysql_query($query);
// Récupération des résultats
while($row = mysql_fetch_row($result)){
$Nom = $row[0];
$Url = $row[1];
echo "<tr>\n
<td><a href=\"$Url\">$Nom</a></td>\n
<td>$Url</td>\n
</tr>\n";
}
// Déconnexion de la base de données
mysql_close();
?>
</tr>
</table>
</body>
</html>
 Les propriétés de colonnes

 Certaines instructions permettent de récupérer diverses
informations à propos des champs d'une table résultant d'une
requête SQL.
• Le nom d'un champ peut être retourné par l'intermédiaire de certaines
fonctions.
$nom = msql_fieldname($id_resultat, $num_champ);
$nom = mysql_field_name($id_resultat, $num_champ);
$nom = ociColumnName($id_resultat, $num_champ);
$nom = pg_FieldName($id_resultat, $num_champ);
• Le type du champ est obtenu en utilisant des fonctions spécifiques.

$type_donnee = msql_fieldtype($id_resultat, $num_champ);
$type_donnee = mysql_field_type($id_resultat, $num_champ);
$type_donnee = ociColumnType($id_resultat, $num_champ);
$type_donnee = pg_FieldType($id_resultat, $num_champ);

 Les propriétés de colonnes

 D'autres fonctions renvoient la longueur d'un champ
$longueur = mssql_field_length($id_resultat, $num_champ);
$longueur = msql_fieldlen($id_resultat, $num_champ);
$longueur = mysql_field_len($id_resultat, $num_champ);
$longueur = ociColumnSize($id_resultat, $num_champ);
 D'autres propriétés peuvent être recueillies par des instructions relatives à

certains gestionnaires de bases de données
// nom de la table parente de la colonne
$nom_table = mssql_fieldtable($id_resultat, $num_champ);
$nom_table = msql_tablename($id_resultat, $num_champ);
$nom_table = mysql_field_table($id_resultat, $num_champ);
$nom_table = mysql_tablename($id_resultat, $num_champ);
// sémaphore du champ comme NOT NULL, PRIMARY KEY
$semaphore = msql_fieldflags($id_resultat, $num_champ);
$semaphore = mysql_field_flags($id_resultat, $num_champ);

<?php
$id_connexion = mysql_connect("localhost","root",“xxx");
mysql_select_db("bd_user");
$requete = "SELECT * FROM utilisateur";
$id_resultat = mysql_query($requete, $id_connexion)
or die ("La requête est invalide : ".$requete."<br>");
$nb_champs = mysql_num_fields($id_resultat);
$ligne = mysql_fetch_row($id_resultat);
$type = array();
$propriete = array();
for ($i = 0; $i < $nb_champs; $i++) {
$propriete[$i]['nom'] = mysql_field_name($id_resultat, $i);
$propriete[$i]['type'] = mysql_field_type($id_resultat, $i);
$propriete[$i]['longueur'] = mysql_field_len($id_resultat, $i);}
for($i = 0; $i < $nb_champs; $i++)
{
echo "<h3>Colonne n°" . $i . "</h3>";
foreach($propriete[$i] as $cle => $valeur){
echo "<u>" . $cle . " :</u> <b>" . $valeur . "</b><br>";}
}
?>
 L'exploitation des données :

 Le décompte total des enregistrements ou des champs d'une table, peut
être obtenu par l'intermédiaire de certaines fonctions
$nb_champs = msql_num_fields($id_resultat);
$nb_lignes = msql_num_rows($id_resultat);
$nb_champs = mysql_num_fields($id_resultat);
$nb_lignes = mysql_num_rows($id_resultat);
$nb_champs = ociNumCols($id_resultat);
$nb_lignes = ociRowCount($id_resultat);
$nb_champs = pg_NumFields($id_resultat);
$nb_lignes = pg_NumRows($id_resultat);
$nb_champs = sybase_num_fields($id_resultat);
$nb_lignes = sybase_num_rows($id_resultat);

 L'exploitation des données :

 A partir des enregistrements, chacun des champs devient accessible aisément
par des fonctions appropriées. Certaines fonctions sont capables d'extraire
directement un champ déterminé
$valeur = mssql_result($id_resultat, $num_ligne, $num_col)
$valeur = msql_result($id_resultat, $num_ligne, $num_col);
$valeur = mysql_result($id_resultat, $num_ligne, $num_col);
$valeur = pg_result($id_resultat, $num_ligne, $num_col);
$valeur = sybase_result($id_resultat, $num_ligne, $num_col);
 Afin d'éviter une surcharge de la suite au terme de leur utilisation. mémoire,

des instructions PHP permettent de libérer les ressources
mssql_free_result($id_resultat);
msql_free_result($id_resultat);
mysql_free_result($id_resultat);
sybase_free_result($id_resultat);

 La gestion des erreurs

 Les erreurs générées par la plupart des SGBDR ne sont plus traitées comme
des alertes. Elles sont stockées et disponibles à partir d'une fonction
spécifique
 Il est possible d'interrompre le script afin d'éviter les erreurs en cascade. Deux
méthodes permettent d'effectuer cette opération
• Le stockage du résultat de l'exécution de la fonction dans une variable
$connect = mysql_connect($host,$user,$password);
• L'utilisation de la fonction die() en cas d'erreur d'exécution. Si la fonction

retourne la valeur 0 (c'est-à-dire s'il y a une erreur) la fonction die() renvoie
un message d'erreur.
mysql_connect($host,$user,$password) or die("erreur de
connexion au serveur $host");
• En général, deux fonctions PHP retournent respectivement le numéro et le
message de l'erreur en cours. Certains SGBDR ne gèrent que le message d'erreur
tels que PostgreSQL et Sybase.

 La gestion des erreurs

// message d'erreur généré par Microsoft SQL Server
$message = mssql_get_last_message();
// numéro et message d'erreur due à la dernière action pour MySQL
$num_erreur = mysql_errno([$id_connexion]);
$message = mysql_error([$id_connexion]);
// message d'erreur généré par mSQL
$message = msql_error();
// message d'erreur pour une connexion ou une requête Oracle
$message = ociError([$id_connexion | $id_requete]);
// message d'erreur généré par PostgreSQL
$message = pg_ErrorMessage($id_connexion);
// message d'erreur généré par Sybase
$message = sybase_get_last_message();

<?php
$id_connexion = mysql_connect("localhost", "root", “xxx");
if (!$id_connexion)
{
$message = "<h3>Une erreur est survenue :</h3>" . "<b><u>Erreur numéro
" . mysql_errno() . ":</u> " . mysql_error() . "</b>";
echo $message;}
else {$reussite = mysql_select_db("utilsateur");
if (!$reussite)
{
$message = "<h3>Une erreur est survenue :</h3>" . "<b><u>Erreur numéro
" . mysql_errno() . ":</u> " . mysql_error() . "</b>";
echo $message;}
else{$id_requete = mysql_query("SELECT date_nais, email, nom " .
"FROM utilsateur");
if (!$id_requete) {
$message = "<h3>Une erreur est survenue :</h3>" . "<b><u>Erreur numéro "
. mysql_errno()
. ":</u> " . mysql_error() . "</b>";
echo $message;
}}}?>

<?php
function gestion_erreur($identifiant){
echo "Une erreur est survenue :<br>"
. mysql_errno() . " : " . mysql_error();
mysql_close($identifiant);
exit;
}
$id_connexion = mysql_connect("localhost","root",“xxx");
if(!$id_connexion) gestion_erreur($id_connexion);
$id_liste_bases = mysql_list_dbs($id_connexion);
if(!$id_liste_bases) gestion_erreur($id_liste_bases);
$nb_bases = mysql_num_rows($id_liste_bases);
echo '<table width="640" border="1">';
for($i = 0; $i < $nb_bases; $i++){
$nom_base = mysql_db_name($id_liste_bases, $i);
$id_liste_tables = mysql_list_tables($nom_base, $id_connexion);
if(!$id_liste_tables) gestion_erreur($id_liste_tables);
$nb_tables = mysql_num_rows($id_liste_tables);
echo '<tr><th valign="top" width="140"><u>' . $nom_base
. '</u></th><td valign="top" width="500">';

for($j = 0; $j < $nb_tables; $j++){

$nom_table = mysql_tablename($id_liste_tables, $j);
$id_liste_champs=mysql_list_fields($nom_base, $nom_table, $id_connexion);
if(!$id_liste_champs) gestion_erreur($id_liste_champs);
$nb_champs = mysql_num_fields($id_liste_champs);
echo '<table width="500" border="1"><tr><th valign="top" width="200">'
. $nom_table . '</th><td valign="top" width="300">';
for($k = 0; $k < $nb_champs; $k++){
$nom_champ = mysql_field_name($id_liste_champs, $k);
$type_champ = mysql_field_type($id_liste_champs, $k);
$longueur_champ = mysql_field_len($id_liste_champs, $k);
$semaphore_champ = mysql_field_flags($id_liste_champs, $k);
echo '<u>' . $nom_champ . '</u>('
. $type_champ . ' '
. $longueur_champ . ' '
. $semaphore_champ . ')<br>';}
echo '</td></tr></table>';} echo '</td></tr>'; } echo '</table>';
mysql_free_result($id_liste_bases);
mysql_free_result($id_liste_tables);
mysql_free_result($id_liste_champs);
mysql_close($id_connexion); ?>

 Principe
 Est un mécanisme permettant de mettre en relation les différentes requêtes du
même client sur une période de temps donnée.
 Les sessions permettent de conserver des informations relatives à un utilisateur
lors de son parcours sur un site web.
 Des données spécifiques à un visiteur pourront être transmises de page en page
afin d'adapter personnellement les réponses d'une application PHP.
 Chaque visiteur en se connectant à un site reçoit un numéro d'identification
dénommé identifiant de session (SID).
 La fonction session_start() se charge de générer automatiquement cet
identifiant unique de session et de créer un répertoire. Elle doit être placée au
début de chaque page afin de démarrer ou de continuer une session.
<?php
session_start();
$Session_ID = session_id();
// $Session_ID = 7edf48ca359ee24dbc5b3f6ed2557e90
?>
 Principe
 Un répertoire est créé sur le serveur à l'emplacement désigné par le fichier
de configuration php.ini, afin de recueillir les données de la nouvelle
session.
[Session]
session.save_path= C:\PHP\sessiondata
; Rép session = \sess_7edf48ca359ee24dbc5b3f6ed2557e90
 Le fichier php.ini peut également préciser un nom de session par l'option

session.name ou sa durée de vie par session.gc_maxlifetime
 La session en cours peut être détruite par la fonction session_destroy().

Cette commande supprime toutes les informations relatives à l'utilisateur.
session_destroy();

 Le traitement des variables de session

 Les variables de session sont chargées dans une session par l'intermédiaire de
la fonction session_register()
<?php
session_start();
session_register("nom_variable");
...
session_register("nom_variableN");
?>
 Une fois la variable enregistrée, elle est accessible à travers le tableau

associatif $_SESSION["nom_variable"]

Le transport des informations entre les documents est réalisé par l'entremise
 soit d'un cookie
 soit d'une requête HTTP
• Cette dernière solution est la plus fiable puisque les cookies peuvent ne pas être
acceptés par le client ou celui-ci pourrait les détruire en cours de session.
• Il suffit de concaténer l'identifiant de session à l'adresse URL de la page cible pour
que cette dernière puisse accéder aux informations conservées par la session.
echo '<a href=” http://www.site.com/doc.php? ’. session_name(). ’=‘ . session_id().‘>
lien</a>‘

 Par défaut, PHP tente de passer par les cookies pour sauvegarder
l'identifiant de session dans le cas où le client les accepterait. Il est
possible d’éviter cela, il suffit de désactiver l'option de
configuration session.use_cookies dans le fichier php.ini.
[Session]
session.use_cookies 0; //désactive la gestion des sessions par
cookie

Exemple

<html><body>
<form method="post" action="traitement.php">
<table border="0">
<tr>
<td><u>Nom :</u></td>
<td><input type="text" name="Nom" size="20" value="RIVES"></td></tr>
<tr>
<td><u>Prénom :</u></td>
<td><input type="text" name="Prenom" size="20" value=“Aloui ali"></td></tr>
<tr>
<td><u>eMail :</u></td>
<td><input type="text" name="cEmail" size="20" value=”ali@go.com"></td></tr>
<tr><td> </td>
<td><input type="submit" name="soumettre" value="Envoyer"></td></tr></table>
</form>
</body
</html>

<?
session_start();
$nom = $_POST["Nom"];
$prenom = $_POST["Prenom"];
$email = $_POST["cEmail"];
session_register("nom");
session_register("prenom");
session_register("email");
$_SESSION["nom"]=$nom;
$_SESSION["prenom"]=$prenom;
$_SESSION["email"]=$email;
header("Location: session.php?" . session_name() . "=" .
session_id());
?>

<?
session_start();
?>
<html><body><?
echo("<u>Identifiant de session :</u> <b>"
. session_id() . "</b><br>");
echo("<u>Nom de la session :</u> <b>"
. session_name() . "</b><br><br>");
echo("<u>Nom :</u> <b>". $_SESSION["nom"] . "</b><br>");
echo("<u>Prénom :</u> <b>" . $_SESSION["prenom"]
. "</b><br>");
echo("<u>eMail :</u> <b>" . $_SESSION["email"]
. "</b><br>");
//session_destroy();
?>
</body>
</html>
 Les fonctions de sessions

session_start() : Initialise les données de session
session_id() : Affecte et/ou retourne l'identifiant de session courante
session_name() : Affecte et/ou retourne le nom de la session courante
session_register() : Enregistre une variable dans la session courante
session_destroy() : Détruit toutes les données enregistrées d'une session
session_is_registered() : Indique si une variable a été enregistrée dans la session ou pas
session_unregister() : Supprime une variable dans la session courante
session_unset() : Détruit toutes les variables de session
session_cache_expire() : Retourne la date d'expiration du cache de la session
session_save_path() : Affecte et/ou retourne le chemin de sauvegarde de la session
courante
session_decode() : Décode les données de session à partir d'une chaîne
session_encode() : Encode les données de session dans une chaîne
 Quelles sont les erreurs possibles ?

 Répertoire de session inaccessible
Warning: open(/tmp\sess_3c80883ca4e755aa72803b05bce40c12, O_RDWR) failed:
m (2) in c:\phpdev\www\bp\header.php on line 2
Le répertoire de sauvegarde est défini dans le php.ini : session.save_path = /tmp
Il faut donc
Créer un répertoire
Lui donner les droits d'écriture pour tous
En spécifier le chemin dans le php.ini
 PHP n'est pas autorisé à utiliser les sessions

Il faut s'assurer que le PHP est bien autorisé a créer des sessions. C'est juste un paramètre à activer.
Faire un phpinfo() pour voir ces paramètres. La commande phpinfo() se contente d'afficher dans
le navigateur le contenu du fichier de configuration php.ini.

 Quelles sont les erreurs possibles ?

 Avoir déjà écrit dans la page
Warning: Cannot send session cookie - headers already sent by (output started at
/home/SiteWeb/SiteAnalyse/index.php:3) in /home/SiteWeb/SiteAnalyse/index.php
on line 6
Cette erreur survient lorsqu'on tente d'ouvrir une session après avoir déjà écrit dans le
document, ce qui interdit.
Ce qu'il ne faut pas faire :
<html>
<body>
<?php session_start();
...
ceci non plus :
<?php echo "<html>";
...
session_start();

 Principe
 Le langage PHP dispose de plusieurs outils permettant de gérer les
connexions des utilisateurs sur un site web
• Il existe trois états possibles en ce qui concerne le statut des connexions.
1. NORMAL : signifie que la connexion est ouverte et le script est en cours
d'exécution.
2. ABORTED : signifie que le client a annulé la connexion et le script est arrêté
par défaut.
3. TIMEOUT : signifie que le script a provoqué une déconnexion due à la fin de
la durée d'exécution convenue.
• Les deux états ABORTED et TIMEOUT peuvent survenir en même temps dans
le cas ou d'une part si PHP est configuré de telle sorte à ignorer les déconnexions
et d'autre part lorsque le script arrive à expiration

 Principe
 Le langage PHP dispose de plusieurs outils permettant de gérer les
connexions des utilisateurs sur un site web
• L'état ABORTED en principe interrompt logiquement le script dès que
l'utilisateur se déconnecte du site. Toutefois, il est possible de modifier ce
comportement en activant l'option de configuration ignore_user_abort dans le
fichier php.ini.
• Si une fonction de fermeture a été enregistrée avec l'instruction

register_shutdown_function, le moteur de script se rendra compte après que le
client se soit déconnecté puis lors de la prochaine exécution du script que celui ci
n'est pas terminé, ce qui provoquera l'appel de la fonction de fermeture mettant
fin au script.
• Lorsque le script se termine normalement, cette fonction sera également appelée.

 Principe
 L'instruction connection_aborted permet d'exécuter une fonction spécifique
à la déconnexion d'un client. Si la déconnexion est effective, la fonction
connection_aborted retourne true.
 Un script expire par défaut après une durée de 30 secondes. Néanmoins, ce

temps peut être modifié par l'intermédiaire de l'option de configuration
max_execution_time dans le fichier php.ini.
 Une fonction se chargeant de terminer le script sera appelée si le délai arrive

à expiration ou si le client se déconnecte.
 Les fonctions connection_timeout, connection_aborted et connection_status

permettent respectivement de vérifier si l'état de la connexion est
ABORTED, TIMEOUT et les trois états possibles.

 Les fonctions de connexions

connection_aborted();
vérifie si le client a abandonné la connexion.
connection_status();
retourne le statut de la connexion.
connection_timeout();
vérifie l'expiration du script en cours.
ignore_user_abort(paramètre);
détermine si lors de la déconnexion d'un client, le script doit continuer ou arrêter son
exécution.
Le paramètre peut valoir soit '0' pour un comportement normal, '1' pour un
abandon et '2' pour une expiration.

 Principe
 Les entêtes sont des informations envoyées lors de chaque échange par le
protocole HTTP entre un navigateur et un serveur
• Informations sur les données à envoyer dans le cas d'une requête
 Permettent aussi d'effectuer des actions sur le navigateur comme le

transfert de cookies ou bien une redirection vers une autre page
• Ce sont les premières informations envoyées au navigateur (pour une
réponse) ou au serveur (dans le cas d'une requête),
– elles se présentent sous la forme: en-tête: valeur
 la syntaxe doit être rigoureusement respectée

• aucun espace ne doit figurer entre le nom de l'en-tête et les deux points
(:). Un espace doit par contre figurer après celui-ci

 Principe
 PHP fournit une fonction permettant d'envoyer des en-tête HTTP
manuellement du serveur au navigateur
• booléen header(chaîne en-tête HTTP)
 La fonction header() doit être utilisée avant tout envoi de données HTML
au navigateur
 Exemples
• Rediriger le navigateur vers une nouvelle page:
<?
header("location: http://www.monsite.fr/"); ?>
• Pour envoyer au navigateur une image créé à la volée

<?
header("Content-Type: image/gif");
imagegif($image); // envoi de l'image au navigateur // code générant l'image
?>

 Récupérer les en-têtes de la requête

 Alors que la fonction header() permet d'envoyer des en-têtes HTTP au
navigateur, PHP fournit une seconde fonction permettant de récupérer
dans un tableau l'ensemble des en-têtes HTTP envoyées par le navigateur
Tableau getallheaders();
• Le tableau retourné par la fonction contient les en-têtes indexés par leur
nom
• Exemple : un script permettant par exemple de récupérer des en-têtes
particuliers.
<?
$headers = getallheaders();
foreach ($headers as $nom => $contenu) {
echo "headers[$nom] = $contenu<br />\n";
}
?>

 Les fonctions HTTP
header(chaîne);
envoie une entête HTTP avant toute commande PHP.
true | false = headers_sent();

vérifie si les entêtes HTTP ont bien été envoyés
setcookie(nom, valeur [, date_expiration [, chemin [, domaine [, sécurisation]]]]);

envoie un cookie.

 PHP ne se limite pas à la génération de pages HTML

 Il peut aussi servir à créer et manipuler d’autres types de
documents
 Notamment des images, au travers dans un grand choix de formats,
comme GIF , PNG , JPEG , WBMP…
 PHP peut même générer directement des images pour le
navigateur, avec la bibliothèque GD .
 GD et PHP auront aussi besoin d'autres bibliothèques, en fonction
des formats que vous souhaitez utiliser.
 Vous pouvez utiliser les fonctions PHP pour obtenir les tailles des
images aux formats JPEG , GIF , PNG , SWF, TIFF et JPEG2000 .

 PHP doit définir, dans l’entete HTTP, le type du document envoyé

au navigateur
fichier rotation_test.php
<?php
header("Content-type: image/png");
$im = imagecreatefrompng("test.png");
$im = imagerotate($im, 90, 0);
imagepng($im);
?>
fichier test.htm
<html><body><img src=‘rotation_test.php></body></html>

 Chargement d’images depuis des fichiers existants

 imagecreatefromgif ( string filename )
 imagecreatefromjpeg ( string filename )
 imagecreatefrompng ( string filename )
 imagecreatefromwbmp ( string filename )
 imagecreatefromstring ( string filename )
le type est automatiquement détecté
 Création d’une image vierge
 imagecreate ( int x_size , int y_size )
 imagecreatetruecolor ( int x_size , int y_size )

 Redimensionnement
int imagecopyresized ( resource dst_image , resource src_image , int dst_x , int
dst_y , int src_x , int src_y , int dst_w , int dst_h , int src_w , int src_h )
imagecopyresized copie une partie rectangulaire d'une image dans une autre
image.
Si les dimensions de la source et de la destination ne sont pas égales,
un étirement adéquat est effectué pour faire correspondre
bool imagecopyresampled ( resource dst_image , resource src_image , int dst_x ,

int dst_y , int src_x , int src_y , int dst_w , int dst_h , int src_w , int src_h )
copie une zone rectangulaire de l'image src_im vers l'image dst_im . Durant
la copie, la zone est rééchantillonnée de manière à conserver la clarté de l'image .
Cette fonction retourne TRUE en cas de succès, FALSE en cas d'échec.

 Dessiner sur une image

 imagechar ( resource image , int font , int x , int y , string c , int
color )
 imagestring ( resource image , int font , int x , int y , string c , int
color )
 imagearc ( resource image , int cx , int cy , int w , int h , int s , int e
, int color )

 La fonction mail envoie un message électronique.

Syntaxe :
mail($recipient, $subject, $message[, $headers, $params]);
Exemple :
$message = "Bonjour, ceci est mon message.’’;
$objet ="Bonjour"
mail(‘’info@aricia.fr’’, $objet, $message);
Cette fonction ne marche que si un programme de messagerie

électronique (appelé « mailer ») est préalablement installé sur le
serveur.

 Exemple plus complet :

<?php
$recipient = ‘’ali <ali@ecole.ma>, ‘’;
$recipient .= ‘‘’farid <farid@ecole.ma>’’;
$subject = ‘’Notre rendez-vous’’;
$message = ‘‘’Je vous propose le samedi 15 juin \n’’;
$message .= ’’--\r\n’’; // Délimiteur de signature
$message .= ‘’Mohamed’’;
$headers = ‘’From: Mohamed <med@ecole.ma>\n’’;
$headers .= ‘’Content-Type: text/html; charset=iso-8859-
1\n’’ ;
$headers .= ‘’Cc: layla@ecole.ma\n’’;
mail($recipient, $subject, $message, $headers);
?>
 veiller à limiter au strict nécessaire les droits et permissions de

l'utilisateur : il vaut mieux l'entendre se plaindre de son manque de liberté plutôt que de
constater les dégâts causés par une trop grande libéralité (principe universel)
 ne jamais faire confiance aux données transmises par l'utilisateur

(encore moins à l'internaute !)
 SQL Injection
 Javascript injection
 toujours tester l'existence / la validité d'un fichier / code à
inclure : et s'il n'était pas celui que vous croyiez ?
 Regarder régulièrement les fichiers journaux (logs)
 Mettre des “alarmes” dans votre code, aux endroits stratégiques
(authentification), envoyées par mail ou stockées dans une base
de données
 un contrôle des données côté client est bien pratique, mais

illusoire : quoi de plus simple que de désactiver Javascript ? Seul
un contrôle côté serveur peut prétendre être efficace.
 préférer, quand cela est possible, la méthode POST à la méthode

GET : les variables dans l'url, ça fait mauvais genre.
 ne pas confondre complexité et sécurité : si votre système de

sécurité vous échappe, considérez que vous n'êtes pas en sécurité.
De toute façon, vous n'êtes jamais en sécurité.
 s'efforcer de tenir à jour système serveur et interpréteur PHP avec

les dernières versions stables : quand la catastrophe aura eu lieu,
ce sera ça de moins à vous reprocher...
 Masquer PHP
Configurer le serveur web pour qu'il utilise plusieurs extensions de fichiers avec PHP
Vous pouvez utiliser des informations déroutantes comme ceci :
 Masquer PHP avec un autre langage
# Faire que le code PHP ressemble à un autre langage
AddType application/x-httpd-php .asp .py .pl
 Masquer PHP avec des types inconnus
# Faire que le code PHP ressemble à un autre langage qui n'existe pas
AddType application/x-httpd-php .bop .foo .133t
 cachez-le sous forme de html.
Cela a un léger impact négatif sur les performances générales, car tous
les fichiers HTML seront aussi analysés et traités par le moteur PHP :
Utiliser le type html pour les extensions PHP
# Faire que le code PHP ressemble à du html
AddType application/x-httpd-php .htm .html

<html> body> 

<form action="traitement.php" method="POST">
<table>
<tr> <td>Nom </td>
<td> <input type="text" size="20" name="nom_utilisateur"></td> </tr>
<tr> <td>Mot de passe</td>
<td>: <input type="password« size="20" name="mot_de_passe"></td> </tr>
<tr> <td>Serveur hôte</td>
<td> <input type="text" size="20" name="nom_serveur" value="<?php echo
$SERVER_NAME ?>“ ></td> </tr>
<tr> <td>Numéro de port</td>
<td> <input type="text" size="20" name="num_port" value="<?php echo $SERVER_PORT ?>“
></td> </tr>
<tr> <td>Nom SGBDR</td>
<td> <input type="text" size="20" name="nom_sgbdr“ ></td> </tr>
<tr> <td>Autre paramètre </td>
<td> <input type="text" size="20" name="autre_param“ ></td> </tr>
<tr> <td> </td>
<td><input type="submit" name="Soumission“ value="Soumettre"> </td></tr>
</table> </form> </body></html>

<?php
// Fichier : traitement.php
function connexion($sgbdr, $hote, $port, $user, $m_passe,$param_sup){

if ($type == "") {
echo ("Aucun SGBDR n'a été spécifié !");
return false; }
else {
switch ($type) {
case "MySQL" : {
if ($port != "") $hote .= ":". $port;
$id_connexion = mysql_connect($hote, $user, $m_passe);
}
case "mSQL" : {
if ($port != "") $hote .= ":". $port;
$id_connexion = msql_connect ($hote, $user, $m_passe);
}
case "SQLSever" : {
$id_connexion = mssql_connect($hote, $user, $m_passe);
}

case "ODBC" : {
if ($param_sup == "")
$id_connexion = odbc_connect($hote, $user, $m_passe);
else
$id_connexion = odbc_connect($hote, $user, $m_passe, $param_sup); }
case "Oracle" : { $id_connexion = ocilogon($user, $mot_passe); }
case "PostgreSQL" : {
$chaine_connexion = "host=" . $hote . " ";
if ($port != "") $chaine_connexion .= "port=" . $port . " ";
$chaine_connexion .= "user=" . $utilisateur ." password=" .
$mot_passe";
if ($param_sup != "") $chaine_connexion .= " ".$param_sup;
$id_connexion = pg_connect($chaine_connexion); }
case "Sybase" : {
if ($param_sup == "")
$id_connexion = sybase_connect($hote, $utilisateur, $mot_passe);
else $id_connexion = sybase_connect($hote, $utilisateur, $mot_passe,
$param_sup); }
default : { echo ("Le SGBDR " . $sgbdr . " n'est pas géré.");
return false; } }
return true; } }
connexion($nom_sgbdr, $nom_serveur, $num_port, $nom_utilisateur,
$mot_de_passe, $autre_param);
?> Page 60
Mohamed HARRANE

 Suite à la connexion à un SGBDR, il faut soit sélectionner la base
de données si elle existe déjà, soit la créer.
 La sélection de bases de données s'effectue par des fonctions
adaptées :
• msql_select_db($nom_base_donnee,$id_connexion);
• mysql_select_db($nom_base_donnee,$id_connexion);
• sybase_select_db($nom_base_donnee,$id_connexion);
• pg_connect( "dbname=nom_base " . "host=nom_serveur ".
"port=num_port " . "user=nom_utilisateur"."password=mot_passe");
 La création des bases de données peut être réalisée par des

fonctions PHP dévolues à cette tâche
• msql_create_db($nom_base_donnee,$id_connexion);
• mysql_create_db ($nom_base_donnee, $id_connexion);


 Création d’une base de données
• la fonction create_db() attend deux paramètres :
– Une variable de type String portant le nom de la base de données à
créer
– L’identificateur de connexion de la connexion courante
function creatdb($db, $lkid) {

if (! $res=mysql_create_db($db, $lkid) {
echo mysql_error ($lkid);
exit; }
return $res;
}
?>


 Si la création d'une base de données n'est pas possible à l'aide de fonctions, il
est possible de créer une base à l'aide d'une requête SQL.
$requete = "CREATE DATABASE nom_base_donnee";
$id_requete = ociparse($requete, $id_connexion);
ociexecute($id_requete);
 La suppression des bases de données est permise, de la même façon qu'il est
possible de les créer.
• msql_drop_db($nom_base_donnee, $id_connexion);
• mysql_drop_db ($nom_base_donnee, $id_connexion);

PHP Accès Aux Données

Transféré par

Droits d'auteur :

Formats disponibles

PHP Accès Aux Données

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

PHP Accès Aux Données

Transféré par

Droits d'auteur :

Formats disponibles

Développement Web Langage PHP

Mohamed HARRANE Page 1

Mohamed HARRANE Page 2

Mohamed HARRANE Page 4

Mohamed HARRANE Page 5

Mohamed HARRANE Page 6

 Déclarer les variables qui vont permettre la connexion à la base de

Lecture et récupération des données

Mohamed HARRANE Page 8

Lecture et récupération des données

Mohamed HARRANE Page 9

 Les deux types de connexions sont parfaitement identiques au

Mohamed HARRANE Page 10

 Plusieurs fonctions PHP permettent de retourner des informations à propos

Mohamed HARRANE Page 11

Mohamed HARRANE Page 12

 L'accès aux bases de données

Mohamed HARRANE Page 13

 Les requêtes SQL

$requete = "SELECT * FROM table WHERE champ = \"valeur\"";

Mohamed HARRANE Page 14

 Les requêtes SQL

• $requete2 = "INSERT INTO tbl_nom "

• $requete3 = "SELECT * FROM tbl_nom “

• $requete4 = "DELETE FROM tbl_nom “

Mohamed HARRANE Page 15

 Traitement des résultats d’une requête

 La variable contenant l'ensemble des enregistrements retournés

 Exemple: une table appelée liens contenant le nom et l'URL de

Mohamed HARRANE Page 16

Mohamed HARRANE Page 17

 Les propriétés de colonnes

• Le type du champ est obtenu en utilisant des fonctions spécifiques.

Mohamed HARRANE Page 19

 Les propriétés de colonnes

 D'autres propriétés peuvent être recueillies par des instructions relatives à

Mohamed HARRANE Page 20

 L'exploitation des données :

Mohamed HARRANE Page 22

 L'exploitation des données :

 Afin d'éviter une surcharge de la suite au terme de leur utilisation. mémoire,

Mohamed HARRANE Page 23

 La gestion des erreurs

• L'utilisation de la fonction die() en cas d'erreur d'exécution. Si la fonction

Mohamed HARRANE Page 24

 La gestion des erreurs

Mohamed HARRANE Page 25

Mohamed HARRANE Page 26

Mohamed HARRANE Page 27

for($j = 0; $j < $nb_tables; $j++){

Mohamed HARRANE Page 28

 Le fichier php.ini peut également préciser un nom de session par l'option

 La session en cours peut être détruite par la fonction session_destroy().

Mohamed HARRANE Page 30

 Le traitement des variables de session

 Une fois la variable enregistrée, elle est accessible à travers le tableau

Mohamed HARRANE Page 31

 Le traitement des variables de session

Mohamed HARRANE Page 32