Vous êtes ici :
Accueil Cours Développement web Création d'un site web en PHP et MySQL MySQL

Création d'un site web en PHP et MySQL : MySQL

Présentation


MySQL est un SGBDR : « Système de Gestion de base de Données Relationnel » qui se définit lui même comme  étant  « La base  de  données  Open Source  la  plus  populaire  au  monde ».  Rien  que  ça. Et c'est vrai! Edité par la société MySQLAB, MySQL est un produit Open Source libre d'utilisation sous licence GPL pour les projets libres. Cependant une licence commerciale est nécessaire dans les autres   cas,   notamment   si   on   souhaite   redistribuer   MySQL   avec   un   produit   non   libre   ou   si   on souhaite un support technique.
La version de production actuelle de MySQL est la version 4 (4.0.17 à l'écriture de ce cours), mais la  grande  majorité  des   serveurs   des  hébergeurs   sont  encore  dans  les  dernières  versions  de  MySQL 3.23   (3.23.58).   La  future   version   actuellement   en   développement   est   la   5  et   n'est   surtout   pas   à
utiliser en production. Les   principales   qualités   de   MySQL  sont   sa   simplicité   et   sa   rapidité.   Son   principale   défaut   est   le manque   de   fonctionnalités   dites   avancées   (dans   les   versions   précédentes)   :   clé   étrangères, procédures   stockées,   triggers   et   selects   imbriqués   notamment.   Mais   cela   ne   doit   pas   occulter   sa puissance avec  l'ajout de  fonctionnalités avancées comme une syntaxe SQL étendue  (replace,  limit, delete), les index de recherche« fulltext » permettant de créer des moteurs de recherche, ...
La   prochaine   version   stable   (5.0)   comblera   les   lacunes   des   précédentes   versions   avec   le   support complet de la syntaxe SQLANSI-99.

 

Les outils

 

  • PhpMyAdmin

 

S'il reste bien entendu possible d'utiliser MySQL en ligne de commande, un peu comme « sqlplus » de  Oracle,  on  est   bien  plus à  l'aise  avec  un environnement  plus  intuitif.   Ainsi,   l'outil   phpMyAdmin est   une   interface   web   à   MySQL   permettant   d'effectuer   la   plupart   des   tâches   de   maintenance   et
d'utilisation.   Cette   solution   fonctionne   depuis   n'importe   quel   navigateur   et   est   indépendante   de   la machine.

  • MysqlCC

 

MysqlCC (MySQL  Control Center) est  le front-end graphique officiel de MySQL, développé par la même   société.   Basé   sur   le   toolkit   Qt,   il   est   disponible   sous   Windows,   Unix   (linux)   et   bientôt   sur MacOS.  Il permet l'administration du serveur,  la gestion des bases et  tables,  l'exécution de requêtes
SQL interactives avec coloration syntaxique...

 

Créer une base


A partir  de  l'écran  d'accueil  de phpMyAdmin,  on saisit   le  nom  de  la  base  dans  « Créer  une base de données ».  Il faut de préférence choisir un nom simple et intuitif. Puis on clique sur « Créer ».  Après la création une nouvelle page s'affiche : c'est la page principale d'administration de la base. En haut seront toujours présents après l'exécution d'une commande les résultats de celle-ci. Cet écran permet notamment l'exécution de commandes SQL,et le travail sur les tables

 

Utilisateurs et droits


Dans  le  menu  de  gauche,   on  choisit   le   « - » (tiret)   qui  correspond  à  la  racine  ou  administration  du serveur   MySQL  par   lui-même.   Dans   la   nouvelle   page,   on   choisit   « Utilisateurs   et   privilèges ».  La page suivante permet d'ajouter un utilisateur. Il faut faire attention à une chose : le serveur. En effet,
suivant  la configuration  initiale (sur Linux par exemple)  les droits dépendent de  la  façon  dont a été accédée   la   base.   Ainsi   si   localhost   et   127.0.0.1   sont   identiques,   si   la   base   est   appelée   depuis   une autre  IP ou un autre nom,   l'utilisateur n'aura pas  tous  les droits.  En cas de  doute,  il suffit de choisir
« Toutserveur ». Pour   créer   un   administrateur,   le   mieux   est   de   donner   tous   les   privilèges.   Pour   un   utilisateur « standard »  (requêtes  de  sélection,  d'ajout,   de  mises  à  jour  et   de  suppression  d'enregistrements)   on choisira les privilèges Select, Insert, Update et Delete.

Une fois l'utilisateur créé, et si plusieurs bases sont présentes,on peut affiner les droits pour chacune des bases.  La  liste des  utilisateurs et  de  leurs  droits sur une base est  affiché en haut.  En choisissant « modifier »  on  peut  affiner   la  sélection  notamment  en  passant  par   « autres  privilèges »  :   droits   sur des bases, tables ou même colonnes.

 

Créer et modifier des tables


On  retourne  par  le  menu de gauche dans  une  base existante.  Dans  l'écran d'administration on saisit (bas  de  la  page)   le  nom  de  la  table  et   le  nombre  de  champs  (colonnes).   Il  sera   possible  après  coup d'en rajouter ou d'en supprimer. Puis on choisit « Créer ». L'étape   suivante   consiste   à   définir   la   table.   Intéressons-nous   aux   différents   types   de   champs possibles.

 

  • Types Numériques

 

  • Types entiers

Pour   chaque   entier   on   peut   ajouter   le   mot   clé   « UNSIGNED »   :   non   signé.   Attention   au   type BIGINT   qui   a   des   limitations   (voir   documentation   MySQL).   Entre   parenthèses   :   les   valeurs UNSIGNED.   Il  est   possible de  fournir  une  précision  d'affichage  (nombre de chiffres).  Par  exemple une taille de 2 pour un TINYINT équivaut à une valeur de 0 à 99.

 

  •  TINYINT:-128 à127 (0 à255)
  •  SMALLINT:-32768 à32767 (0 à65535)
  •  MEDIUMINT:-8388608 à8388607 (0 à16777215)
  •  INTou INTEGER :-2147483648 à2147483647 (0 à4294967295)
  •  BIGINT:-9223372036854775808 à9223372036854775807 (0 à18446744073709551615)

 

  • Types réels (flottants)

 

 

  •  FLOAT: nombre en virgule flottante
  •  DOUBLE,DOUBLEPRECISION,REAL:nombre en virgule flottante double-précision.
  •  DECIMAL,DEC, NUMERIC: spécial, les valeurs sont« unpacked »:c'est une chaîne texte

 

  • Types booléens

 

  • BIT,BOOL,BOOLEAN(depuis la version 4.1) :Un bit,équivaut à TINYINT(1)

 

  • Types caractères


Ces types méritent un peu plus d'explications

  •  Types CHAR

CHAR : une chaîne de caractère dont la taille peut être de 1 à 255 caractères. La taille est définie à la création de la table. Dans la table, le champ prend effectivement le nombre de caractères indiqué, même si la taille réelle est inférieure.
VARCHAR  : une chaîne de caractère dont la taille maximale peut être de 1 à 255 caractères  mais dont la longueur  peut être variable. MySQL stocke en plus un octet contenant la longueur  de  la chaîne. C'est une optimisation, une chaîne de 100 caractères va donc prendre 100+1 octets en place dans la table. On peut rajouter la définition BINARY. Par défaut les champs CHAR et VARCHAR sont triés sans tenir compte de la casse. L'attribut BINARY permet de trier en tenant compte de la casse selon la machine. Avec ces champs, les espaces finaux sont supprimés.

  •  Types TEXT

Les   types   TEXT   et   BLOB  permettent   de  stocker   des   quantités  variables   de  texte   selon  leurs définitions. Ici « L » est la longueur du texte :
TINY(BLOB/TEXT) : L+1 octets avec L<2^8
BLOB/TEXT : L+2 octets avec L<2^16
MEDIUM(BLOB/TEXT) : L+3 octets avec L<2^24
LONG(BLOB/TEXT) : L+4 octets avec L<2^32
TEXT et BLOB s'utilisent de manière identique mais il faut respecter les rêgles suivantes : Lors de tris, un champ BLOB tient compte de la casse, pas un champ TEXT.
On ne peut pas faire de recherche FULLTEXT sur un champ de type BLOB. Il faudra utiliser les champs TEXT. Les champs de type TEXT et BLOB ne prennent pas de valeurs par défaut. Les espaces finaux ne sont pas supprimés.
 

 

  • Type ENUM

Un champ de type ENUM  ne  peut contenir  qu'une chaîne  de texte par plusieurs prédéfinies à la création de la table. Voici un exemple :

CREATE TABLE test (
id int NOT NULL auto_increment,
c_enum enum('oui','non'),
PRIMARY KEY  (id)
);


 Le champ c_enum ne pourra prendre que deux valeurs : "oui" ou "non". Si  on tente d'y mettre autre chose :

insert into text (c_enum) values('toto');

Dans ce cas une chaîne vide est insérée à la place. Si le champ est déclaré NOT NULL, la valeur par défaut devient la première de la liste d'énumération.

 

  • Type SET

Un type set ressemble un peu au type ENUM sauf que le champ peut avoir une ou plusieurs valeurs parmi  une  liste  prédéfinie  à  la  création de  la  table. Dans  le  type ENUM  une  seule valeur  est autorisée  dans  le  champ.   Avec  le  type   SET,  plusieurs   valeurs   séparées   par   des  espaces  sont autorisées.

CREATE TABLE test (
id int(11) NOT NULL auto_increment,
c_set set('oui','non'),
PRIMARY KEY  (id)
);
insert into test (c_set) values ('oui,non');
insert into test (c_set) values ('non,oui');
insert into test (c_set) values ('oui);


on effectue une recherche d'un élément SET soit avec LIKE, soit avec la fonction FIND_IN_SET :
 

select * from test where c_set LIKE '%oui%';
select * from test where FIND_IN_SET('oui',c_set)>0;

 

  • Types date


Attention avec les dates : la logique de MySQL est de laisser aux développeurs le soin de contrôler la validité de leurs dates. Ainsi MySQL autorisera l'enregistrement d'une date de type 2004-02-30 ! Les seuls tests effectués sont la validité du mois (entre 0 et 12) et la validité du jour (entre 0 et 31). Le   zéro   (0)  est   autorisé pour   des   raisons   pratiques:   stockage  de   l'année,   ou  de  l'année/mois seulement par exemple. Voici quelques autres informations :
MySQL, dans  les  comparaisons  notamment, essaie « d'interpréter » le format de date qu'on lui passe. C'est  le cas  pour les comparaisons  entre  des champs de type date et des  champs  texte. Dans la plupart des cas le résultat sera celui attendu mais attention tout de même au formalisme. Les  dates  doivent être données  de préférence au format année-mois-jour. L'année doit toujours apparaître en premier. Dans le cas d'un année-jour-mois attention : MySQL ne peut pas deviner si
2004-02-05 est le 5 février ou le 2 mai... Si une date est utilisée dans un calcul numérique, elle est convertie en nombre (timestamp). Si une valeur illégale est transmise, c'est la valeur zéro (0) qui est retenue. La valeur  zéro dépend du type de champ. La gestion de l'an 2000 se fait ainsi : Dans  le cas d'années  à  4 chiffres, aucun souci. Il vaut mieux TOUJOURS  utiliser  des années sur 4 chiffres. Dans le cas d'une année à deux chiffes, 00-69 sont converties en 2000-2069, 70-99 sont
converties en 1970-1999.

  • Formats supportés

AAAA-MM-JJ  HH:MM:SS ou AA-MM-JJ  HH:MM:SS. Les séparateurs peuvent être n'importe quoi : AAAA/MM/JJ HH.MM.SS est valable AAAA-MM-JJ ou AA-MM-JJ, même remarque pour les séparateurs.
AAAAMMJJHHMMSS ou AAMMJJHHMMSS si la chaîne ou le nombre ont une signification en tant que date AAAAMMJJ ou AAMMJJ, même remarque
 

  • Type DATETIME

Le type DATETIME permet de stocker la date et l'heure sous le format AAAA-MM-JJ HH:MM:SS. Son zéro est donc 0000-00-00 00:00:00.

  • Type DATE

Avec ce type seule la date est stockée au format AAAA-MM-JJ. Son zéro est 0000-00-00.

  • Type TIMESTAMP

Le type TIMESTAMP permet de stocker  implicitement et automatiquement un timestamp (heure courante) lors d'un enregistrement de données avec INSERT ou UPDATE. Si une table dispose d'un champ TIMESTAMP, lors de l'ajout ou de la mise à jour de celui-ci sera automatiquement mis  à jour pour cette ligne d'enregistrement. La colonne n'a pas besoin d'être explicitement spécifiée. Si on la spécifie, alors on peut lui mettre n'importe quelle valeur.

CREATE TABLE test (
id int(11) NOT NULL auto_increment,
c_ts timestamp(14) NOT NULL,
c_txt varchar(10) NOT NULL default '',
PRIMARY KEY  (id)
)

 

insert into test (c_txt) values('toto');

on affiche 20040112143212

update test set c_txt='truc';
select c_ts from test;

à l'écran on a 20040112143339

On remarque que le résultat retourné par MySQL sur la colonne TIMESTAMP n'est pas une valeur timestamp Unix (bien que telle en interne) mais une valeur  formatée. Par défaut un TIMESTAMP retourne une valeur (numérique)  sur  14 caractères. On peut choisir  cette taille à la création de la table :
TIMESTAMP ou TIMESTAMP(14) : AAAAMMJJHHMMSS
TIMESTAMP(12) : AAMMJJHHMMSS
TIMESTAMP(10) : AAMMJJHHMM
TIMESTAMP(8) : AAAAMMJJ
TIMESTAMP(6) : AAMMJJ
TIMESTAMP(4) : AAMM
TIMESTAMP(2) : AA
Avec tous ces formats, spécifiez toujours l'année le mois et le jour même avec un timestamp de 4 ou de 2 sinon la date sera invalide.

  • Type TIME

Le type TIME peut être utilisé pour  stocker une information horaire. Son format est HH:MM:SS ou HHH:MM:SS et la valeur  peut être négative. Les valeurs maximales possibles vont de -838:59:59 à 838:59:59. TIME ne sert pas qu'à stocker une heure de la journée mais un intervalle ou une durée ce qui explique la plage horaire. On y accède comme ceci : D HH:MM:SS.fraction : D est le jour. La fraction n'est pas stockée. Ou encore : HH:MM:SS, HH:MM, D HH:MM:SS, D HH:MM, D HH, D SS, HHMMSS, .SS, MMSS, ...

  • Type YEAR

Le type YEAR stocke uniquement l'année, sur une plage allant de 1901 à 2155. L'interprétation des valeurs à deux chiffres et soumise à l'interprétation de la gestion de l'an 2000.

  • Création : Syntaxe SQL

On utilise la commande SQL CREATE.

CREATE TABLE [IF NOT EXIST] nom_table
(
champ1 TYPE [NOT NULL| NULL] [DEFAULT valeur_defaut] [AUTO_INCREMENT] [PRIMARY
KEY],
...,
PRIMARY KEY(nom_champ),
KEY [nom] (col1, col2, ...),
INDEX [nom] (col1, col2, ...),
UNIQUE [INDEX] [nom] (col1, col2, ...),
FULTEXT [INDEX] [nom] (col1, col2, ...)
) TYPE=type_table;

 

Notez que :

KEY et INDEX sont des synonymes. Un PRIMARY KEY est un index UNIQUE dont toutes les colonnes doivent être NOT NULL. Un PRIMARY KEY peut contenir plusieurs colonnes. Dans ce cas, PRIMARY KEY ne doit pas apparaître au niveau de la définition d'une colonne mais la syntaxe PRIMARY KEY(cols,...) doit être utilisée Il ne peut y avoir qu'un seul index PRIMARY KEY, mais plusieurs index UNIQUE. Si une application veut obtenir le PRIMARY KEY d'une table et qu'il n'existe pas, alors MySQL retournera le premier index UNIQUE  trouvé. Si on ne donne pas de noms à un index, celui-ci est généré automatiquement en prenant le nom de la première colonne de l'index suivi d'un suffixe numérique (col_1, col_2, ...). Bien que cela soit déconseillé, on peut établir un index sur une colonne TEXT ou BLOB. Mais dans ce cas il faut obligatoirement spécifier une longueur d'index.

par exemple :

CREATE TABLE f_message (
id_message int(10) unsigned NOT NULL auto_increment,
id_msg_initial int(11) unsigned NOT NULL default '0',
id_msg_prec int(10) unsigned NOT NULL default '0',
id_forum int(10) NOT NULL default '0',
login varchar(20) NOT NULL default '',
date datetime NOT NULL default '0000-00-00 00:00:00',
sujet varchar(200) NOT NULL default '',
texte text,
PRIMARY KEY  (id_message),
KEY precedent (id_msg_prec),
KEY login (login),
KEY forum (id_forum),
KEY initial (id_msg_initial),
FULLTEXT KEY ft1 (sujet,texte)
) TYPE=MyISAM;

 

  • Types de tables (MyISAM et InnoDB)

Le Type de table est particulier  à MySQL. Le type par  défaut est « MyISAM », le gestionnaire de tables originel de MySQL, simple et rapide, correspondant à la majorité des besoins. Le second type principal est « InnoDB » et permet une gestion des  transactions et verrouillage des données. Les « commit », « rollback », restauration après crash, et surtout les contraintes d'intégrité avec clés étrangères sont possibles.

CREATE TABLE parent(id INT NOT NULL, PRIMARY KEY (id)) TYPE=INNODB;
CREATE TABLE child(id INT, parent_id INT, INDEX par_ind (parent_id),
FOREIGN KEY (parent_id) REFERENCES parent(id)ON DELETE SET NULL
) TYPE=INNODB;

 

On peut  aussi utiliser  les  clauses  « ON  DELETE CASCADE » et « ON  DELETE  SET  NULL ».

Quelques règles sont à respecter pour l'utilisation :
 
- Avec un ON DELETE CASCADE, si une ligne de la  table  parente est supprimée, les  lignes correspondantes  à la clé étrangère sont automatiquement supprimées  dans  la table  fille. Dans l'exemple,   une   suppression   d'un   enregistrement   de   la   table   « parent »   supprime   tous   les enregistrements de la table « child » dont le « parent_id » est égal au « id » de l'enregistrement de la table « parent » supprimé.
- Avec un ON  DELETE SET  NULL, les  enregistrements fils  ne sont  pas  supprimés, mais  les colonnes de la clé étrangère (ici parent_id) prennent la valeur NULL.
Un index doit exister pour la clé parente et la clé fille.

  • Index FULLTEXT

  • Création

Dans ses dernières versions (3.23.23 et supérieures)  MySQL permet l'indexation et la recherche sur un  ou   plusieurs  champs  de   type   TEXT.  On  peut   ainsi créer des moteurs de   recherches   très rapidement. Pour  ça il faut créer  un index «FULLTEXT» ou en Texte Entier, où chaque mot du champ texte est en fait indexé.
Les   index   FULLTEXT   ne   fonctionnent   qu'avec   des  champs   de   type   TEXT   (pas   BLOB)   ou VARCHAR   et   sur   des   tables   de   type   MyISAM  uniquement.  Voici   comment   créer   un  index FULLTEXT. Si la table existe déjà :

CREATE FULLTEXT INDEX ft1 on f_message (sujet,texte);

 

A la création de la table, on rajoute une ligne de création d'index :

FULLTEXT KEY ft1 (sujet,texte)

 

On peut préciser  une ou plusieurs colonnes dans ce genre d'index. Mais ATTENTION: lors de la recherche si on a créé un index sur deux colonnes, on ne peut pas rechercher sur une seule des deux colonnes en même temps... Dans ce cas il faudra créer plusieurs index FULLTEXT.

  • Recherche

On  effectue une recherche  avec  les  fonctions MATCH() et AGAINST( ). La fonction MATCH permet de préciser sur  quelles colonnes on effectue la recherche, et la fonction AGAINST les mots recherchés.

SELECT   id_message   FROM   f_message   WHERE   MATCH(sujet,texte)   AGAINST('linux nvidia');

Cette requête va effectuer  une recherche sur  les mots 'linux' et 'nvidia' dans les colonnes  'sujet' et 'texte'. Elle va  retourner les  id des  messages  correspondants avec les  plus pertinents  en premier (ceux qui correspondent  le mieux à la recherche). Cela est dû au fait que MATCH  est dans une clause WHERE. La pertinence est déterminée par  MySQL selon des critères (un peu opaques tout de même) comme le nombre de mots dans la ligne, le nombre de mots uniques dans la ligne, la longueur de la ligne. C'est la fonction MATCH  qui retourne la pertinence sous forme d'un flottant supérieur  ou égale à zéro. Le zéro signifie une pertinence nulle (pas de correspondance). Plus la valeur  est élevée plus le résultat est pertinent.

SELECT id_message, MATCH(sujet,texte) AGAINST('linux nvidia') FROM f_message;

Cette requête récupère en seconde colonne la valeur de la pertinence. Celle-ci n'est pas classée car il n'y a pas de WHERE ou de ORDER BY. Voici une dernière méthode permettant de récupérer  les champs et la pertinence triés par ordre de pertinence.

SELECT id_message,sujet MATCH (sujet,texte) AGAINST ('linux nvidia')
FROM f_messages WHERE MATCH (sujet,texte) AGAINST ('linux nvidia');

 

  • Recherche booléenne

Les versions 4.x de MySQL ont introduit la notion de recherche booléenne qui permet d'affiner ses recherches.

SELECT id_message FROM f_message WHERE MATCH(sujet,texte) AGAINST ('+linux +nvidia +ati' IN BOOLEAN MODE);

 

Voici la signification des caractères supplémentaires
+ : le mot doit obligatoirement être présent dans chaque enregistrement retourné
- : le mot ne doit pas être présent dans les enregistrements retournés
> et < : valorisation du mot. Un >toto <titi valorise plus toto que titi dans la recherche
( et ) : grouper une série de mots
~ : négation d'un mot. Contrairement au -, le mot est tout  de même pris en compte avec une pertinence négative.
* : tronquage d'un mot : bon* => bonjour, bonsoir ...

« " » les guillemets : une chaîne recherchée telle quelle.
 

MySQL et PHP

 

  • Connexion à une base de données

Deux étapes sont généralement nécessaires pour plus de simplicité. La seconde n'est pas obligatoire mais bien pratique dans le cas où on travaille sur une seule base de données dans toute la page.

  • Connexion au serveur

On utilise la fonction mysql_connect(). Cette  fonction prend (au minimum)  trois paramètres : le serveur (hostname), l'utilisateur et son mot de passe.

<?php
$host="localhost"
$user="root";
$pass="password";
  
$cnx=mysql_connect($host, $user, $pass);
if(!$cnx){
die("erreur de connexion à MySQL");
}
?>
  • Choix d'une base de données

On  choisit  une base  de  données  par   défaut  avec la  fonction mysql_select_db().  Elle prend au minimum   un paramètre,  le   nom  de  la  base.  Le  second  paramètre  optionnel   est  une  ressource retournée par  la fonction mysql_connect, en cas  de  connexion sur  plusieurs  serveurs MySQL. Par  défaut, la fonction prend la dernière connexion ouverte (celle du dernier mysql_connect exécuté).

<?php
$base="database";
$db = mysql_select_db($b_base);
if(!$db){
 die("Erreur de connexion à la base $base");
}
?>
  • Fermeture d'une connexion

On  ferme  une  connexion  à MySQL  avec  la  fonction mysql_close() Cependant  dans  le cas  de connexion non persistantes (voir  à  ce point)  cette  fonction n'est  pas  obligatoire car  PHP  ferme automatiquement les connexions à la fin d'un script.

<?php
mysql_close($cnx);
?>

 Le  paramètre  optionnel   est  une  ressource retournée par  mysql_connect, en cas  de  connexion sur  plusieurs  serveurs MySQL. Par  défaut, la fonction prend la dernière connexion ouverte (celle du dernier mysql_connect exécuté).

  • Séquence complète pour la connexion à une base de données MySQL

 

<?php
$host="localhost"
$user="root";
$pass="password";
$base="database";
$cnx=mysql_connect($host, $user, $pass);
if(!$cnx){
die("erreur de connexion à MySQL");
}
mysql_select_db($base) or die("erreur à la selection de $base");
mysql_close($cnx);
?>

 

  • Les requêtes

  • Exécuter une requête

On exécute une 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).

ATTENTION : Ce n'est  pas  parce que  l'appel à mysql_query()  n'a pas  retourné d'erreur  que  la fonction retourne des  lignes de résultats dans le cas d'un SELECT par  exemple. Enfin, la requête SQL ne doit pas finir par un point-virgule. La requête peut être de n'importe quel type (selection, 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.
 

<?php
$result=mysql_query("select id_message, sujet from f_message");
?>

 

  • Nombre de lignes affectées

Dans le cas d'un DELETE, INSERT, REPLACE  ou UPDATE, on peut connaître  le  nombre de lignes affectées (modifiées) par la requête à l'aide de la fonction
mysql_affected_rows()
 

<?php

$result=mysql_query("delete from f_message where login='toto'");
if($result){
 echo mysql_affected_rows()." Enregistrements supprimés";
}
?>

 

  • Nombre de lignes retournées

Dans le cas d'un SELECT, le nombre d'enregistrements (lignes) retourné est obtenu avec la fonction mysql_num_rows()
 

<?php

$result=mysql_query("select * from f_message where id_message > 10");
if($result){
 echo mysql_num_rows().' enregistrements retournés';
}
?>

 

  • Récupérer les résultats

La fonction la plus sympathique pour récupérer les enregistrements après l'exécution d'une sélection est mysql_fetch_array() . Elle prend au minimum un paramètre : une 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 de la table. Dans un tableau indexé, les colonnes sont numérotées à partir de zéro. Notez que 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.

<?php
$result=mysql_query("select sujet,texte from f_message where login='foo'");
$tab=mysql_fetch_array($result); // Première ligne du résultat
echo $tab['sujet'].', '.$tab['texte']; // affiche les champs sujet et texte
echo $tab[0].', '.$tab[1]; // idem
?>

 

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 :

SELECT t1.nom as col1, t2_nom as col2 FROM t1, t2 ...

 

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


Voici comment récupérer tous les résultats :

<?php
$result=mysql_query("select sujet,texte from f_message where login='toto'");
while ($result && $tab=mysql_fetch_array($result)) {
echo $tab['sujet'].', '.$tab['texte']; // affiche les champs sujet et texte
}
?>

 

Notez l'expression du while. Pour y rentrer, il faut que le résultat de la requête ($result) ne soit pas FALSE (donc  que la requête ait  fonctionné)  et  qu'il  reste  des  lignes  à lire. Autrement  dit  si  la requête ne retourne rien, on ne rentre pas dans la boucle. Notez enfin qu'il existe deux autres fonctions possibles :
mysql_fetch_row() : équivaut à mysql_fetch_array($var,MYSQL_NUM)
mysql_fetch_assoc() : équivaut à mysql_fetch_array($var, MYSQL_ASSOC)
 

  • Insertion avec auto_incrément

L'identifiant unique d'une table est souvent 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). On utilise pour ça la fonction mysql_insert_id().

<?php
$result=mysql_query("insert into f_message(sujet,   texte) values('test','test')");
$id=mysql_insert_id();
$result=mysql_query("select sujet, texte from f_message where id_message=$id");
$tab=mysql_fetch_array($result);
echo $tab['sujet'].', '.$tab['texte']; // test, test
?>
  • Récupération des erreurs

En cas d'erreur lors d'une manipulation sur MySQL, on peut récupérer le numéro de l'erreur MySQL par  la  fonction mysql_errno(). De même  on peut récupérer   le message  d'erreur  par  la fonction mysql_error(). On peut trouver la liste des codes d'erreurs ici :




Vous êtes ici :
Accueil Cours Développement web Création d'un site web en PHP et MySQL MySQL