Cours intensif de MySQL - Partie 3
Bienvenue une nouvelle fois, dans le plan d’installation des bases du PHP. Dans mes deux dermiers articles, je me suis un peu éloigné du PHP proprement dit lorsque j’ai abordé les concepts fondamentaux pour travailler avec MySQL RDBMS (Système de Management de Base de Données Relationnelles) et MySQL syntaxe SQL. Ces éléments sont essentiels pour comprendre comment utiliser efficacement MySQL à partir du PHP. Dans tous les cas vous serez heureux d’apprendre que le sujet de l’article d’aujourd’hui va nous rapprocher de notre propos original, de telle manière que nous pourrons revenir sur le terrain plus familier du PHP.
Je concluerais ma série de cours intensifs sur MySQL en présentant quelques fonctions utiles qui sont disponibles lorsque l’on utilise SQL et PHP, en introduisant des conditions propres à l’instruction SELECT et en expliquant quelques principes permettant de relier les tables de données entres elles. Après tout, c’est un système de base de données relationnel.
Utilisation étendue de l’instruction SELECT
Comme vous l’avez déjà sûrement réalisé, l’instruction SELECT est incroyablement plus complexe et importante lorsque l’on travaille avec SQL. Pour accroître notre connaissance de cette instruction, voyons maintenant un peu plus les conditions spécifiques de celle-ci. Comme vous l’avez déjà noté dans les précédents articles, les données provenant du résultat d’une requête n’apparaissent pas dans un ordre particulier. Par contre il est souvent utile de travailler avec des données ordonnées, l’instruction “sélectionner” (SELECT) possède pour cela la condition “ordonné par” (ORDER BY) suivant :
mysql> SELECT name FROM authors ORDER BY name;
+-----------------+
| name |
+-----------------+
| Jennifer Author |
| Joe Coolguy |
| John Coggeshall |
+-----------------+
3 rows in set (0.00 sec)On demande à MySQL de produire le résultat d’une requête présentant les noms de chaque élément de la table auteurs dans l’ordre alphabétique.
Si au lieu de cela nous avions voulu obtenir la même réponse mais dans l’ordre alphabétique inverse nous aurions du écrire :
mysql> SELECT name FROM authors ORDER BY name DESC;
+-----------------+
| name |
+-----------------+
| John Coggeshall |
| Joe Coolguy |
| Jennifer Author |
+-----------------+
3 rows in set (0.00 sec)“descendant” (DESC) signifie ordre alphabétique inverse, l’ordre alphabétique normal étant codifié par “ascendant” (ASC).
Bien que l’ordre par défaut soit alphabétique “ascendant” (ASC), vous pouvez préciser cela en remplaçant le mot DESC par ASC.
Pour ordonner les résultats sur plus d’une colonne, indiquez simplement une liste de colonnes (dans l’ordre ou vous souhaitez qu’elles apparaissent) séparé par des virgules. Le résultat sur une si petite table ne vous dira pas grand chose mais voici comment procéder :
mysql> SELECT name, state FROM authors ORDER BY name, state;
+-----------------+-------+
| name | state |
+-----------------+-------+
| Jennifer Author | KS |
| Joe Coolguy | AZ |
| John Coggeshall | MI |
+-----------------+-------+
3 rows in set (0.00 sec)Note : Lorsque vous travaillez avec des colonnes multiples avec une condition “ordonné par” (ORDER BY), chaque colonne peut posséder son propre ordre alphabétique (ASC) ou inverse (DESC) pour préciser l’ordre de disposition.
LIMITation des résultats de l’instruction SELECT
Il est souvent utile de limiter le nombre de résultats pour une requête, cela est possible en utilisant la condition LIMIT:
mysql> SELECT * FROM authors LIMIT 1;
+-----------+-----------------+-------+
| author_id | name | state |
+-----------+-----------------+-------+
| 1 | John Coggeshall | MI |
+-----------+-----------------+-------+
1 row in set (0.00 sec)Lorsque la commande ci-dessus est exécutée, on obtient un résultat formé d’une seule ligne. Pour obtenir plusieurs lignes, l’instruction LIMIT peut accepter deux paramètres : le premier représente la ligne de départ (0, étant la première ligne, ce nombre n’étant relié à aucun IDentifiant (ID) unique ou autre clé primaire), le second précise le nombre de résultats à retourner, comme dans l’exemple ci-dessous :
mysql> SELECT * FROM authors LIMIT 1,2;
+-----------+-----------------+-------+
| author_id | name | state |
+-----------+-----------------+-------+
| 2 | Joe Coolguy | AZ |
| 3 | Jennifer Author | KS |
+-----------+-----------------+-------+
2 rows in set (0.00 sec)Exploration des relations entre différentes tables
Jusqu’à présent, nous avons abordé la plupart des opérations communes de SQL mais, MySQL n’est pas qu’un simple système de management de base de données c’est plus un système relationnel de base de données. Pour comprendre pourquoi les bases relationnelles sont importantes, voyons cela à partir de deux tables, celle des livres (books) et celle des auteurs (authors) :
mysql> DESC books;
+-----------+--------------+-------------------+------+-----+---------+----------------+
| Field | Type | Collation | Null | Key | Default | Extra |
+-----------+--------------+-------------------+------+-----+---------+----------------+
| book_id | int(11) | binary | YES | PRI | NULL | auto_increment |
| author_id | int(11) | binary | YES | | NULL | |
| title | varchar(255) | latin1_swedish_ci | YES | | NULL | |
| pub_date | date | latin1_swedish_ci | YES | | NULL | |
+-----------+--------------+-------------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)
mysql> DESC authors;
+-----------+--------------+-------------------+------+-----+---------+----------------+
| Field | Type | Collation | Null | Key | Default | Extra |
+-----------+--------------+-------------------+------+-----+---------+----------------+
| author_id | int(11) | binary | YES | PRI | NULL | auto_increment |
| name | varchar(255) | latin1_swedish_ci | YES | | NULL | |
| state | char(2) | latin1_swedish_ci | YES | | NULL | |
+-----------+--------------+-------------------+------+-----+---------+----------------+
3 rows in set (0.01 sec)En examinant les deux tables ci-dessus, comment pouvez-vous déterminer le nom de l’auteur de chaque livre pris individuellement ?
Comme vous pouvez le voir chaque table possède un “IDentifiant auteur” (author_id) en commun, alors que le titre de chaque ouvrage est contenu dans la table livre (books), le nom de l’auteur appartient à la table auteurs (authors). Avec ce que nous avons appris plus haut, il n’y a pas de moyen simple qui permet de créer un résultat contenant en même temps le titre d’un ouvrage et le nom de son auteur. Pour faire cela, nous devons trouver le moyen d’associer les deux tables ensemble.
Toutes les précisions pour l’instruction SELECT déja abordées ont été restreintes à une table, cela nous a permis d’obtenir ce que nous voulions à cette échelle. Le temps est venu maintenant d’introduire le concept de lien de table(s). Ce concept peut être très complexe mais son principe fondamental reste simple.
Considérons la requête suivante :
mysql> SELECT books.title, authors.name FROM books, authors
WHERE books.author_id=authors.author_id;
+------------------+-----------------+
| title | name |
+------------------+-----------------+
| PHP Unleashed | John Coggeshall |
| PHP4 Programming | John Coggeshall |
| Cool Stuff | Joe Coolguy |
| Another Book | Jennifer Author |
+------------------+-----------------+
4 rows in set (0.09 sec)Cette requête demande à la base de données de retrouver dans la colonne de la table des livres (books), le titre des livres (books.title) et dans la colonne de la table auteurs (authors) le nom d’auteurs (authors.name). Et parce que nous travaillons sur plus d’une table, c’est la partie de la requête associée à “de” (FROM) qui permet d’obtenir aussi le nom des tables concernés : livres et auteurs (books and authors).
La partie finale de la requête est la plus importante dans ce cas, parce qu’elle définit les données et la manière selon laquelle elles seront présentées dans le résultat final. Ici nous avons précisé dans la condition “ou” (WHERE) il existe une égalité entre IDentifiants d’auteur (books.author_id = authors.author_id). Cette condition relie les données de la table des livres (books) avec celles de la table des auteurs (authors) par leurs colonnes d’IDentifiants auteurs présents simultanément dans les deux tables. Par conséquent, lorsque MySQL construit la réponse à la requête, il compare les colonnes d’IDentifiants d’auteurs et assortis les données de façon appropriée.
Le concept de relier des tables ensemble est l’idée fondamentale sur laquelle s’appuie la structure des bases de données modernes. Cela vous permet de générer une multitude de rapports sur les éléments de votre base de données facilement et rapidement.
Rapports généraux par l’intermédiaire des liens
Les liens permettent d’autres possibilités en même temps qu’ils enrichissent la valeur d’autres fonctions. Par exemple, si l’on considère un rapport présentant combien de livres ont été publiés par chacun des auteurs. Puisque nous avons besoin de croiser les données de deux tables, cela va obligatoirement constituer un lien. Dans ce cas précis, ce lien seul ne suffira pas. Pour répondre à une telle requête vous avez besoin de la fonction MySQL “compter()” (COUNT()) et de la condition “grouper par” (GROUP BY).
Comme je l’ai déjà précisé, SQL est un langage axé sur l’extraction d’éléments d’une base de données. Pour faciliter cette action, SQL propose un grand choix de fonctions pour tout traiter depuis la manipulation des dates à la concaténation de chaines mais aussi des fonctions mathématiques. Pour compter le nombre total de livres par auteurs, nous avons besoin de la fonction “compter()” (COUNT()). Comme son nom l’indique, cette fonction permet de compter le nombre de lignes correspondantes à la requête. Un seul paramètre est nécessaire, c’est celui du nom de la colonne dans laquelle le comptage doit avoir lieu, la fonction renvoie un entier qui représente le nombre de lignes trouvées.
Par exemple vous pouvez demander combien de lignes il y a dans la table livres (books) en écrivant ceci :
mysql> SELECT COUNT(title) FROM books;
+--------------+
| COUNT(title) |
+--------------+
| 4 |
+--------------+
1 row in set (0.00 sec)Nous utiliserons une instruction équivallente pour compter le nombre de lignes qui satisfont au critère de notre requête (le nombre de livres par auteur). Notre requête effectuera une jointure des deux tables de manière similaire à la précédente requête :
mysql> SELECT authors.name, COUNT(books.title) AS books
FROM authors,books
WHERE books.author_id = authors.author_id GROUP BY name;
+-----------------+-------+
| name | books |
+-----------------+-------+
| Jennifer Author | 1 |
| Joe Coolguy | 1 |
| John Coggeshall | 2 |
+-----------------+-------+
3 rows in set (0.01 sec)Comme vous pouvez le voir, la requête retourne deux colonnes. La première contient le nom de l’auteur, elle provient de la colonne nom d’auteurs (authors.name) alors que la seconde contient une valeur calculée issue de la fonction “compter” (COUNT()). Notez que j’ai donné un autre nom pour cette dernière en utilisant le mot AS. C’est un détail important qui devient très utile lorsque l’on travaille avec MySQL depuis un script PHP, car ainsi l’accès aux données d’une requête sera possible en utilisant seulement le nom de la colonne.
La dernière chose qui différencie cette requête des autres réside dans l’utilisation de la condition “grouper par” (GROUP BY). Celle-ci condense une colonne particulière qui est dans ce cas la colonne noms d’auteurs (authors.name), le regroupement des données semblables se faisant sur une seule ligne. C’est utile ici, car cela ne serait pas satisfaisant de voir de nombreuses fois le même nom apparaître dans l’affichage du résultat. En fait, lorsque nous utilisons la fonction “compter” (COUNT()) avec un résultat en multi-colonne, vous devez avoir dans le même temps une condition “grouper par” (GROUP BY) afin que le resultat de la requête puisse être présenté dans les conditions les plus compréhensibles.
A suivre…
Avec ce dernier article, je termine mon cours intensif de MySQL ! Si SQL vous était inconnu, j’espère que vous en savez maintenant assez pour commencer à écrire de simples requêtes. Dans mes prochaines publications, j’aborderai l’extension MySQL à PHP. Sans attendre, si vous souhaitez continuer à vous documenter pour comprendre comment fonctionne SQL, vous pouvez trouver tout cela sur le site de MySQL.
Textes originaux en anglais sur O’Reilly : MySQL Crash Course part 3 par John Coggeshall
Chargement
Commentaires récents