Si vous utilisez MySQL en version 4.1.3 ou plus récente ainsi que PHP 5, il est fortement recommandé d'utiliser l'extension MySQLi, décrite un peu plus loin.

Il faut procéder par étape :

• étape 1 : se connecter au serveur de base de données avec mysql_connect() en précisant le nom du serveur, un nom d'utilisateur et un mot de passe valide
• étape 2 : sélectionner la base de données sur laquelle on souhaite travailler, avec mysql_select_db()
• étape 3 : fermer avec mysql_close() la connexion une fois le travail sur la base de données terminé

if($db = mysql_connect($host, $user, $pass)) {
    if($dbb = mysql_select_db($base)) {
        ...
        mysql_close();
    } else {
        die("connexion à la base $base impossible");
    }
} else {
    die("connexion au serveur $host impossible");
}

Les actions possibles de l'utilisateur sur la base à laquelle il se connecte dépendent des droits qui lui auront été fournis par l'administrateur de la base de données.

mysql_connect($server,$user,$password) : permet de se connecter au serveur $server en tant qu'utilisateur $user avec le mot de passe $password, retourne l'identifiant de connexion si succès, FALSE sinon. Si ces arguments manquent, les valeurs par défaut du fichier de configuration php.ini seront utilisées.

mysql_select_db($base[,$id]) : permet de choisir la base $base, peut prendre un identifiant $id de connexion ; retourne TRUE en cas de succès, sinon FALSE. Les identifiants de connexion ne sont pas nécessaires si on ne se connecte qu'à un seul serveur à la fois, ils permettent seulement de lever toute ambiguïté en cas de connexions multiples (vers plusieurs serveurs dans le même script).

mysql_close([$id]) : permet de fermer la connexion à un serveur de bases de données, l'argument optionnel $id est l'identifiant de connexion retourné à l'ouverture de la connexion. A noter que toutes les connexions aux serveurs de bases de données sont automatiquement fermées à la fin de l'exécution du script qui les aura ouvertes.

Il est tout à fait possible de se connecter à deux bases de données différentes en utilisant le même login.
La connection doit être effectuée de la manière suivante :

$db1 = mysql_connect("localhost" , "root" , "password");
$db2 = mysql_connect("localhost" , "root" , "password" , true);

$db2 contient true pour forcer l'ouverture d'une nouvelle connexion en laissant la premiere ouverte.

Il est tout à fait possible d'ouvrir plusieurs connexions vers des bases de données distinctes au cours du même script. Pour cela, il faut ouvrir deux connexions distinctes vers le serveur, dont on garde précieusement les deux identifiants retournés par mysql_connect() :

$link1 = mysql_connect(...);
$link2 = mysql_connect(...);

Ensuite, il faut sélectionner les deux bases avec mysql_select_db() :

mysql_select_db($base1, $link1);
mysql_select_db($base2, $link2);

Et enfin exécuter les requêtes sur l'une ou l'autre des bases de données avec mysql_query(), en lui passant en paramètre l'identifiant de connexion adéquate :

mysql_query("SELECT ... FROM ... WHERE ...", $link1);

ou :

mysql_query("SELECT ... FROM ... WHERE ...", $link2);

• Utilisateurs (login et mot de passe) distincts avec des droits différents ;
• Connexion à deux serveurs différents ;
• Très nombreuses requêtes vers l'une et l'autres des bases.

Dans le cas où le même utilisateur travaille sur deux bases différentes du même serveur avec les mêmes permissions (et le même login et mot de passe), la seule fonction mysql_select_db() permet d'éviter les connexions multiples au serveur.

Exemple :

mysql_select_db($base1);
mysql_query("SELECT ... FROM ... WHERE ...");
mysql_select_db($base2);
mysql_query("SELECT ... FROM ... WHERE ...");
...
mysql_select_db($base1);
mysql_query("SELECT ... FROM ... WHERE ...");

Si vous lancez de très nombreuses requêtes vers vos deux bases au cours de l'exécution de votre script, il peut s'avérer judicieux de préférer les connexions multiples et de travailler avec les identifiants de connexion plutôt que d'avoir à changer la base de données courante à tout bout de champ (avec les oublis et erreurs que cela peut impliquer).

Dans le cas où le visiteur du site doit naviguer à travers différents script PHP qui se connectent tous au même serveur, il est préférable d'avoir recours aux connexions persistantes.

Une connexion persistante est ouverte avec la fonction mysql_pconnect() qui est en tout point comparable à mysql_connect() à la seule différence que la connexion n'est pas fermée à la fin du script qui a ouvert la connexion. Ainsi, les scripts suivants peuvent continuer à lancer des requêtes à la base de données sans avoir à rouvrir de connexion en direction du serveur.

Une connexion persistante ne peut pas être fermée avec la fonction mysql_close(). Au delà d'un certain temps d'inactivité, la ou les connexions persistantes ouvertes sont automatiquement fermées.

Vaste sujet, ça dépend de la structure de la base !

Vous seront donnés ici quelques éléments de syntaxe de MySQL pour faire des sélections, tris et regroupements avec MySQL.

Une requête sera du type :

SELECT colonne1, colonne2, ...
FROM table1, table2, ...
WHERE colonnei=valeuri
AND|OR [NOT] colonnek IN (val1, val2, ...)
AND (colonnel BETWEEN aa AND bb)
AND colonnef LIKE "%$chaîne%"
ORDER BY colonnei ASC|DESC
GROUP BY colonnej
LIMIT a, b

La clause SELECT permet de choisir les colonnes (séparées par une virgule) du résultat (c'est une projection). La clause FROM dit de quelles tables (séparées par une virgule) proviennent les lignes du résultat. La clause WHERE permet de sélectionner les lignes selon les valeurs des colonnes, les opérateurs booléens AND, OR et NOT, ainsi que les parenthèses et autres fonctions de MySQL sont possibles. La clause ORDER BY permet de faire un tri ASCendant ou DESCendant sur une ou plusieurs colonnes (séparées par une virgule). La clause GROUP BY permet de regrouper les lignes qui ont une colonne en commun (par exemple "GROUP BY nom" permet de grouper les lignes selon le nom). La clause LIMIT permet de paginer les résultats en ne retournant que les lignes numéros a à b par mis celles du résultat.

La commande LIKE permet de faire une comparaison sur les chaînes de caractères. Cette comparaison est insensible à la casse, sauf sur les colonnes dont le type est de la famille des BLOB. Les caractères spéciaux % et _ sont des caractères génériques au même titre que * et ? sous Linux et MS-DOS. Ils signifient respectivement n'importe quelle chaîne (même vide), un seul caractère quelconque.

La commande BETWEEN .. AND ... permet de comparer la valeur d'une colonne à un intervalle de valeurs.

La commande IN(...,) permet de comparer la valeur d'une colonne à une liste de valeurs prédéfinies.

Non, même en séparant les requêtes par un point virgule, MySQL refusera d'exécuter plusieurs requêtes en un seul appel de mysql_query().

Exemple faux :

mysql_query("UPDATE `table` SET `col`='value' WHERE `id`=$id; DELETE FROM `table` WHERE `id`=$id2");

Exemple correct :

mysql_query("UPDATE `table` SET `col`='value' WHERE `id`=$id");
mysql_query("DELETE FROM `table` WHERE `id`=$id2");

La fonction mysql_num_rows($result) retourne ce nombre de lignes, $result est le pointeur de résultat retourné par mysql_query().

Exemple :

$result = mysql_query("SELECT * FROM user") or die("erreur de base de données");
echo "Il y a ".mysql_num_rows($result)."résultats.";

Si les résultats en eux-mêmes ne vous intéressent pas, utilisez directement la fonction de groupe COUNT(*) dans la requête MySQL.

Exemple :

$result = mysql_query("SELECT COUNT(*) FROM user") or die("erreur de base de données");
$ligne = mysql_fetch_row($result);
echo "Il y a ".$ligne[0]."résultats.";

La fonction mysql_num_rows est une boucle sur un curseur. Elle va donc consommer beaucoup plus qu'un simple COUNT en SQL. Faites l'essai sur une table contenant plusieurs millions de lignes pour le vérifier. En effet, PHP va "dumper" toutes les lignes pour obtenir ce nombre.

Il vaut donc mieux pour compter le nombre de lignes (dans 90% des cas) faire un "select count(*) from..." et non utiliser mysql_num_rows().

La fonction mysql_affected_rows(), qui prend en unique paramètre l'identifiant de requête, retourne le nombre de lignes modifiées par une requête de type : delete, insert ou update. Elle ne fonctionne en aucun cas sur des requêtes de type SELECT mais seulement sur des requêtes de modification. Pour connaître le nombre de lignes retournées par une requête SELECT, utilisez mysql_num_rows(). Si la requête a échoué, mysql_affected_rows() renvoie la valeur -1. Par contre, à la suite d'une requête DELETE sans clause WHERE, cette fonction renvoie 0.

Il existe deux méthodes :

$connect = mysql_connect('localhost', 'julp', 'motdepasse');
$db = mysql_query("SHOW DATABASES;");
while($db_array = mysql_fetch_row($db)) {
    echo $db_array[0]."<br >";
}
mysql_close($connect);

Utiliser la requête MySQL "Show Databases;" qui lui est spécifique, et qui renvoie le nom de toutes les bases de données présentes.

ou

$connect = mysql_connect('localhost', 'julp', 'motdepasse');
$db = mysql_list_dbs($connect);
while($db_array = mysql_fetch_row($db)) {
    echo $db_array[0]."<br />";
}
@mysql_close($connect);

Utiliser la fonction mysql_list_dbs() qui renvoie le nom de toutes les bases de données.

Il existe deux méthodes :

$connect = mysql_connect('localhost', 'julp', 'motdepasse');
mysql_select_db('ma_base_de_données', $connect); //On sélectionne la base de données
$tables = mysql_query("SHOW TABLES;");
while($tables_array = mysql_fetch_row($tables)) {
    echo $tables_array[0]."<br />";
}
mysql_close($connect);

Utiliser la requête "SHOW TABLES;", spécifique à MySQL, qui renvoie le nom de toutes les tables présentes dans la base de données sélectionnée auparavant grâce à la fonction mysql_select_db(string nom_de_la_BDD, id_de_connexion_MySQL).

Ou bien utiliser la fonction mysql_list_tables(string nom_de_la_BDD) qui renvoie la liste des tables dans la base de données nommée : nom_de_la_BDD, mais cette approche est désormais déconseillée au profit de la précédente.

L'instruction 'DESCRIBE nom_de_la_table' permet d'obtenir les informations sur les colonnes d'une table MySQL.

• Field : Le nom du champ ;
• Type : Le type de la colonne ;
• Null : Possibilité de stocker une valeur nulle ;
• Key : Si le champ est indexé ;
• Default : valeur par défaut ;
• Extra : Informations complémentaires comme l'auto_increment.

<?php

// Connection mysql
mysql_connect('localhost', 'root', '')
    or die("Impossible de se connecter : " . mysql_error());

// Selection de la base de donnée
mysql_select_db('developpez')
    or die("Échec à la sélection de la table : " . mysql_error());

// Exécution de la requête
$description = mysql_query('DESCRIBE album')
    or die("Erreur lors de la requête : ".mysql_error()."\n");

?><pre><?php

$i=0; // Compteur pour numéroter les champs
// Pour chaque enregistrement récupérer l'objet correspondant
while($field = mysql_fetch_assoc($description))
{
    ++$i;
    ?>
#################################
Champ N&deg;<?php echo $i; ?>

    Nom du champ : <?php echo $field["Field"]; ?>

    Type du champ : <?php echo $field["Type"]; ?>

    Null : <?php echo $field["Null"]; ?>

    Type de la clef : <?php echo $field["Key"]; ?>

    Valeur par d&eacute;faut : <?php echo $field["Default"]; ?>

    Extra : <?php echo $field["Extra"]; ?>


    <?php
}

?></pre>

Lors de l'insertion d'une ligne dans une table comportant une colonne de type numérique clé primaire auto_increment, une valeur est automatiquement affectée à cette colonne si elle n'est pas renseignée lors du INSERT.

Il est utile de pouvoir extraire cette valeur pour s'en servir dans une autre table, par exemple à l'occasion de la création d'une jointure...

La fonction mysql_insert_id([$id]) retourne l'identifiant de l'attribut clé primaire AUTO_INCREMENT de la dernière insertion. L'argument optionnel $id est l'identifiant de connexion au serveur. Il s'agit du dernier identifiant pour la connexion en cours, donc cette fonction peut-être utilisée sans problème en cas de connexions simultanées de plusieurs personnes.

Les valeurs numériques doivent être castées de la même manière que pour une faille XSS.

Les chaînes de caractères doivent passer par la fonction mysql_real_escape_string() :

$sql = 'SELECT * FROM user WHERE name = "'.mysql_real_escape_string($_POST['username']).'"';

NB : Il faut avoir établi une connexion à MySQL avant de pouvoir utiliser cette fonction.

NB : Attention à votre configuration magic_quotes dans le php.ini car cela peut ajoutes des \ dans votre BDD. Le mieux est d'utiliser une fonction comme :

function quote_smart($value)
{
    if(get_magic_quotes_gpc())
    {
    $value = stripslashes($value);
    }

    return mysql_real_escape_string($value);
}

Ce qui donne :

$sql = 'SELECT * FROM user WHERE name = "'.quote_smart($_POST['username']).'"';

Il faut d'abord comprendre qu'en matière d'encodage, toute votre chaîne doit être convertie à l'encodage choisi (nous parlerons ici d'UTF-8).
Cela concerne en premier votre logiciel de programmation (IDE PHP, Dreamweaver et autres éditeurs de pages Web). Tout bon éditeur qui se respecte doit vous proposer le choix de l'encodage de vos documents. Pour Dreamweaver par exemple, cela se trouve dans les préférences pour les nouveaux documents où vous spécifierez comme codage par défaut « Unicode (UTF-8) ».
Ensuite, votre serveur PHP doit renvoyer le bon encodage lorsque vous générez du HTML avec PHP. Dans tous les cas et ceci afin de garantir la compatibilité de vos scripts, prenez l'habitude d'envoyer un Header spécifiant l'encodage comme suit :

<?php
 
// Inclure dans vos scripts PHP avant tout envoi d'HTML
header ('Content-type: text/html; charset=utf-8');
 
// Pour tester que PHP renvoie les caractères correctement (vous pouvez mettre tous les caractères
// que vous souhaitez dans le echo ci-dessous, l'utf-8 est prévu pour être multilingue
echo 'é à ? û ü';
 
?>

Pour la base de données, il en est de même : D'abord vous devez entrer vos données en UTF-8. Si vous utilisez PhpMyAdmin par exemple, n'oubliez pas de préciser votre encodage pour la base de données, pour l'interface PHP MyAdmin, pour les tables (selon les versions). Tout doit correspondre !
Mais ce n'est pas tout. Il faut également spécifier dans vos scripts PHP que les données récuperées ou transmises doivent être en UTF-8. La fonction magique pour ceci est :

mysql_query("SET NAMES 'utf8'");

Elle est à insérer juste après la connexion à la base établie, donc juste après avoir fait un

mysql_connect($dbhost, $dblogin, $dbpass);

<?php
mysql_connect('localhost', 'julp', 'motdepasse');
mysql_select_db('ma_base_de_données');
$query = "SELECT * FROM team ORDER BY id";
$result = mysql_query($query);
while($row = mysql_fetch_assoc($result)) {
    //... et on arrive ainsi au dernier enregistrement renvoyé par la requête
}

// On se repositionne sur le premier enregistrement
mysql_data_seek($result, 0); 
// On se replace sur le premier enregistrement
$row = mysql_fetch_assoc($result); // Il faut le relire
//On peut manipuler l'enregistrement $row["mon_champ"]
?>

La fonction mysql_data_seek(identifiant_de_résultat, numéro_de_ligne) déplace le pointeur interne de résultat identifiant_de_résultat. Il le fait pointer à la ligne numéro_de_ligne et retourne FALSE en cas d'échec. Le prochain appel à la fonction mysql_fetch_row() ou mysql_fetch_array() ou mysql_fetch_assoc() retournera cette ligne.

Attention : Le numéro du premier enregistrement est 0.

<?php
mysql_connect('localhost', 'julp', 'motdepasse');
mysql_select_db('ma_base_de_données');
$query = "SELECT * FROM team ORDER BY id";
$result = mysql_query($query);
$nb_rows = mysql_num_rows($result);

mysql_data_seek($result, $nb_rows - 1); //On se place sur le dernier enregistrement
$row = mysql_fetch_assoc($result); //Il faut le relire
// On peut manipuler l'enregistrement : $row["mon_champ"];
?>

La fonction mysql_data_seek(identifiant_de_résultat, numéro_de_ligne) déplace le pointeur interne de résultat identifiant_de_résultat. Il le fait pointer à la ligne numéro_de_ligne et retourne FALSE en cas d'échec. Le prochain appel à la fonction mysql_fetch_row() ou mysql_fetch_array() ou mysql_fetch_assoc() retournera cette ligne.

Attention : Le numéro du premier enregistrement renvoyé étant 0, il faut donc soustraire 1 à mysql_num_rows() qui renvoie le nombre de lignes renvoyées par une requête Select.

Le mot clé BETWEEN ... AND ... de la clause WHERE permet de ne retenir que les engistrements dont un attribut appartient à un intervalle. Cet intervalle peut être déterminé par deux dates. Dont l'une peut se déduire de l'autre par ajout ou retrait d'une période.

Syntaxe :

date +/- INTERVAL valeur unité

Cela permet de d'ajouter (+) ou de retirer (-) à la date date une période de valeurs unités.

L'unité peut être l'une des suivantes :

• SECOND (la seconde)
• MINUTE (la minute)
• HOUR (l'heure)
• DAY (le jour)
• MONTH (le mois)
• YEAR (l'année)
• MINUTE_SECOND (la minute et la seconde), ex : '2003-06-25' + INTERVAL "26:30" MINUTE_SECOND (ajout de 26 minutes et de 30 secondes)
• HOUR_MINUTE (l'heure et la minute)
• DAY_HOUR (le jour et l'heure)
• YEAR_MONTH (l'année et le mois)
• HOUR_SECOND (heure, minute et seconde)
• DAY_MINUTE (jour, heure et minute)
• DAY_SECOND (jour, heure, minute et seconde), ex : '2003-06-25' - INTERVAL "5 8:30:00" DAY_SECOND (retrait de 5 jours, 8 heures, 30 minutes et 0 seconde)

Note : les séparateurs peuvent être quelconques.

Exemple :

SELECT
FROM
WHERE `date` BETWEEN ('2003-06-25' - INTERVAL 3 MONTH) AND '2003-06-25'

Cet exemple permet d'extraire tous les enregistrements dont la date est comprise entre '2003-06-25' et 3 mois avant.

Pour afficher un enregistrement aléatoirement, il est possible d'utiliser la fonction MySQL "RAND" qui génére des nombres aléatoires.
Pour sélectionner un enregistrement aléatoirement dans la table "nomTable" il suffit d'utiliser la requête MySQL suivante :

SELECT *
FROM nomTable
ORDER BY RAND()
LIMIT 1

La ligne "ORDER BY RAND()" permet de trier aléatoirement tous les enregistrements et ensuite "LIMIT 1" permet de sélectionner le premier enregistrement.

Pour afficher les valeurs d'un SELECT utilisant des fonctions DATE (décrites ici), il faut créer un alias.
Exemple :

$select_annee=mysql_query("SELECT DISTINCT YEAR(DATE) as Annee FROM table1 WHERE id = '$id'"); 
while($annee = mysql_fetch_array($select_annee))
{
  echo $annee['Annee'];
}

On lit un peu partout que pour pouvoir appeler des procédures stockées ou lancer des requêtes multiples il faut utiliser MySQLi, notamment avec sa fonction mysqli::multi_query().

Cependant, il est tout aussi possible de faire la même chose avec l'extension MySQL.

En effet, si on regarde la documentation de la fonction mysql_connect, on peut voir le dernier paramètre qui est client_flags. Il suffit donc de renseigner ce paramètre avec des valeurs bien précises pour pouvoir profiter pleinement de ces fonctionnalités.

Plus bas dans la page précédemment citée, il y a un commentaire :

#define CLIENT_LONG_PASSWORD 1 /* new more secure passwords */
#define CLIENT_FOUND_ROWS 2 /* Found instead of affected rows */
#define CLIENT_LONG_FLAG 4 /* Get all column flags */
#define CLIENT_CONNECT_WITH_DB 8 /* One can specify db on connect */
#define CLIENT_NO_SCHEMA 16 /* Don't allow database.table.column */
#define CLIENT_COMPRESS 32 /* Can use compression protocol */
#define CLIENT_ODBC 64 /* Odbc client */
#define CLIENT_LOCAL_FILES 128 /* Can use LOAD DATA LOCAL */
#define CLIENT_IGNORE_SPACE 256 /* Ignore spaces before '(' */
#define CLIENT_PROTOCOL_41 512 /* New 4.1 protocol */
#define CLIENT_INTERACTIVE 1024 /* This is an interactive client */
#define CLIENT_SSL 2048 /* Switch to SSL after handshake */
#define CLIENT_IGNORE_SIGPIPE 4096 /* IGNORE sigpipes */
#define CLIENT_TRANSACTIONS 8192 /* Client knows about transactions */
#define CLIENT_RESERVED 16384 /* Old flag for 4.1 protocol */
#define CLIENT_SECURE_CONNECTION 32768 /* New 4.1 authentication */
#define CLIENT_MULTI_STATEMENTS 65536 /* Enable/disable multi-stmt support */
#define CLIENT_MULTI_RESULTS 131072 /* Enable/disable multi-results */
#define CLIENT_REMEMBER_OPTIONS (((ulong) 1) << 31)

Cela nous permet de savoir quel entier donner au paramètre client_flags. Pour être en mesure d'exécuter plusieurs requêtes à la fois, utilisons la valeur CLIENT_MULTI_STATEMENTS, soit 65536 :

$lk = mysql_connect( HOST, USER, PASS, false, 65536 );

Pour pouvoir lancer les procédures stockées, c'est la valeur CLIENT_MULTI_RESULTS, soit 131072 :

$lk = mysql_connect( HOST, USER, PASS, false, 131072 );

Pour utiliser les deux en même temps, il suffit d'additionner ces deux entiers, ce qui nous donne 196608.

Cette astuce a été testée avec MySQL 5.0 mais il semble que les valeurs exactes changent suivant la version de MySQL. Vérifiez le code source de la version de MySQL que vous utilisez avant de mettre cette astuce en application.

Grâce à l'utilitaire phpMyAdmin, on va sauvegarder le schéma (c'est-à-dire la définition des tables) et les données (les lignes des tables) d'une base en particulier. (On ne peut pas sauvegarder plusieurs bases d'un seul coup.) Cette action de sauvegarde est appelée "faire un dump" en argot informatique.

Il faut choisir la base à sauvegarder en la choisissant dans le menu de gauche. Dans la page de droite, il s'affiche la liste des tables, et en bas toute une série d'actions possibles. On s'intéressera à "Afficher le schéma de la base".

On va choisir quelles tables en particulier sauvegarder (dans une balise SELECT). Ne rien sélectionner pour les sauvegarder toutes.

Ensuite on coche "structure seule" pour ne sauvegarder que le schéma de la base, ou "structure et données" pour sauvegarder le schéma ET les données, ou encore "Données seulement" pour sauvegarder les données sans le schéma.

Enfin on peut cocher quelques options :

• "Ajouter des énoncés drop table" afin de supprimer et recréer les tables lors de l'importation de la sauvegarde.
• "Protéger les noms des tables et des champs par des `" afin de protéger les noms avec accents des tables et des colonnes.
• "Transmettre" afin de forcer le téléchargement du fichier texte contenant la sauvegarde, avec possibilité d'utiliser un algorithme de compression.
• "Insertions étendues" permet de n'avoir qu'une seule requête INSERT pour les données d'une table, sous la forme INSERT INTO table VALUES((,,),(,,)(,,))
• "Insertions complètes" permet d'inclure la liste des colonnes aux requêtes INSERT, selon la syntaxe : INSERT INTO table(,,,) VALUES(,,,)

Il ne reste alors plus qu'à cliquer sur le bouton "Exécuter".