Select

Une requête d'interrogation SQL est composée de :

select: commande indiquant l'interrogation, suivie de la liste des colonnes (et éventuels calculs) souhaitées
from: suivi de la liste des noms de tables
where: filtre sur les données contenues dans les tables
group by: regroupement de données
having: filtre sur les résultats
order by: critère de tri

Base d'exemple

Les exemples reposent sur les données contenues dans le script Livres.sql.

Cette base représente une réprésentation simpliste d'une descriptions de livres. Elle contient les deux tables Livres et Lieux. La colonne LieuNaissance de la table Livres contient des données permettant de lier les données à celles de la table Lieux.

Livres

Auteur	LieuNaissance	Titre	Type	Annee
Mark Twain	Florida	Les aventures de Tom Sawyer	Fiction	1876
Charles Darwin	Shrewsbury	L'origine des espèces	Science	1856
William Shakespeare	Stratford-upon-Avon	Roméo et Juliette	Théâtre	1594
J.K. Rowling	Yate	Harry Potter à l''école des sorciers	Fiction	1995
Caryl Férey	Caen	Zulu	Fiction	2008
Emmanuel Jouanne	Caen	Damiers imaginaires	Fiction	1982
Dan Simmons	Peoria	Hyperion	Fiction	1989

Lieux

Ville	Pays
Florida	Royaume-Uni
Shrewsbury	Royaume-Uni
Stratford-upon-Avon	Royaume-Uni
Yate	Royaume-Uni
Strasbourg	France
Peoria	Etats-Unis

Exemples de requête

Liste des colonnes

Sélectionner toutes les données de la table Livres. Ici l'opérateur * indique que toutes les colonnes sont attendues, sinon il faut préciser la liste des colonnes souhaitées.

mysql> Select * from Livres;
+---------------------+---------------------+----------------------------------------+-----------+-------+
| Auteur              | LieuNaissance       | Titre                                  | Type      | Annee |
+---------------------+---------------------+----------------------------------------+-----------+-------+
| Mark Twain          | Florida             | Les aventures de Tom Sawyer            | Fiction   |  1876 |
| Charles Darwin      | Shrewsbury          | L'origine des espèces                  | Science   |  1856 |
| William Shakespeare | Stratford-upon-Avon | Roméo et Juliette                      | Théâtre   |  1594 |
| J.K. Rowling        | Yate                | Harry Potter à  l'école des sorciers   | Fiction   |  1995 |
| Caryl Férey         | Caen                | Zulu                                   | Fiction   |  2008 |
| Emmanuel Jouanne    | Caen                | Damiers imaginaires                    | Fiction   |  1982 |
| Dan Simmons         | Peoria              | Hyperion                               | Fiction   |  1989 |
+---------------------+---------------------+----------------------------------------+-----------+-------+
7 rows in set (0.00 sec)

Sélectionner le contenu de la colonne Auteur de la table Livres.

mysql> Select Auteur from Livres;
+---------------------+
| Auteur              |
+---------------------+
| Mark Twain          |
| Charles Darwin      |
| William Shakespeare |
| J.K. Rowling        |
| Caryl Férey         |
| Emmanuel Jouanne    |
| Dan Simmons         |
+---------------------+
7 rows in set (0.00 sec)

L'opérateur distinct appliqué à une colonne permet d'indiquer que seules les valeurs distinctes de cette colonne sont attendues. Ici, on recherchera les types de livres.

mysql> Select distinct type from Livres;
+-----------+
| type      |
+-----------+
| Fiction   |
| Science   |
| Théâtre   |
+-----------+
3 rows in set (0.00 sec)

Filtre sur les données

Les filtres illustrés ici utiliseront la clause where.

Sélectionner toutes les colonnes de Livres pour les livres parus après l'année 1700. La ligne avec Roméo et Juliette disparaîtra.

mysql> Select * from Livres where annee > 1700;
+------------------+---------------+----------------------------------------+---------+-------+
| Auteur           | LieuNaissance | Titre                                  | Type    | Annee |
+------------------+---------------+----------------------------------------+---------+-------+
| Mark Twain       | Florida       | Les aventures de Tom Sawyer            | Fiction |  1876 |
| Charles Darwin   | Shrewsbury    | L'origine des espèces                  | Science |  1856 |
| J.K. Rowling     | Yate          | Harry Potter à  l'école des sorciers   | Fiction |  1995 |
| Caryl Férey      | Caen          | Zulu                                   | Fiction |  2008 |
| Emmanuel Jouanne | Caen          | Damiers imaginaires                    | Fiction |  1982 |
| Dan Simmons      | Peoria        | Hyperion                               | Fiction |  1989 |
+------------------+---------------+----------------------------------------+---------+-------+
6 rows in set (0.00 sec)

L'opérateur like permet une comparaison sur tout ou partie d'une chaîne de caractères. On utilisera le joker % qui permet de remplacer n'importe quelle chaîne de caractères (y compris vide). On cherchera ici les lignes dont le nom de l'auteur contient la sous-chaîne ar.

mysql> Select * from Livres where Auteur like '%ar%';
+---------------------+---------------------+-----------------------------+-----------+-------+
| Auteur              | LieuNaissance       | Titre                       | Type      | Annee |
+---------------------+---------------------+-----------------------------+-----------+-------+
| Mark Twain          | Florida             | Les aventures de Tom Sawyer | Fiction   |  1876 |
| Charles Darwin      | Shrewsbury          | L'origine des espèces       | Science   |  1856 |
| William Shakespeare | Stratford-upon-Avon | Roméo et Juliette           | Théâtre   |  1594 |
| Caryl Férey         | Caen                | Zulu                        | Fiction   |  2008 |
+---------------------+---------------------+-----------------------------+-----------+-------+
4 rows in set (0.00 sec)

Pour combiner plusieurs critères de filtres, on peut utiliser les opérateurs logiques. Ici par exemple on utilisera and pour l'intersection des critères paru après 1700 et type fiction.

mysql> Select * from Livres where annee > 1700 and type like 'Fiction';
+------------------+---------------+----------------------------------------+---------+-------+
| Auteur           | LieuNaissance | Titre                                  | Type    | Annee |
+------------------+---------------+----------------------------------------+---------+-------+
| Mark Twain       | Florida       | Les aventures de Tom Sawyer            | Fiction |  1876 |
| J.K. Rowling     | Yate          | Harry Potter à  l'école des sorciers   | Fiction |  1995 |
| Caryl Férey      | Caen          | Zulu                                   | Fiction |  2008 |
| Emmanuel Jouanne | Caen          | Damiers imaginaires                    | Fiction |  1982 |
| Dan Simmons      | Peoria        | Hyperion                               | Fiction |  1989 |
+------------------+---------------+----------------------------------------+---------+-------+
5 rows in set (0.00 sec)

Pour la comparaison à une liste de valeurs, on utilisera l'opérateur in.

mysql> Select * from Livres where type in ('Fiction','Science');
+------------------+---------------+----------------------------------------+---------+-------+
| Auteur           | LieuNaissance | Titre                                  | Type    | Annee |
+------------------+---------------+----------------------------------------+---------+-------+
| Mark Twain       | Florida       | Les aventures de Tom Sawyer            | Fiction |  1876 |
| Charles Darwin   | Shrewsbury    | L'origine des espèces                  | Science |  1856 |
| J.K. Rowling     | Yate          | Harry Potter à  l'école des sorciers   | Fiction |  1995 |
| Caryl Férey      | Caen          | Zulu                                   | Fiction |  2008 |
| Emmanuel Jouanne | Caen          | Damiers imaginaires                    | Fiction |  1982 |
| Dan Simmons      | Peoria        | Hyperion                               | Fiction |  1989 |
+------------------+---------------+----------------------------------------+---------+-------+
6 rows in set (0.00 sec)

La clause where accepte les opérateurs suivants :

comparaison: = égal; <> différent de; > supérieur et >= supérieur ou égal; < inférieur et <= inférieur ou égal
logique: OR ou; AND et; NOT négation
comparaison: IS [NOT] {TRUE|FALSE|UNKOWN} comparaison logique ([] signifiant optionnel et {} signifiant un choix); IS [NOT] NULL; LIKE motif comparaison avec une chaîne; [NOT] IN (liste) comparaison avec une liste
mathématiques: + - / *
intervalle: BETWEEN valeurbasse AND valeurhaute

Tri

L'ordre de tri est déterminé par l'ordre de saisie dans la base. Pour effectuer un tri à partir de critères, on utilisera la clause order by.

mysql> Select * from Livres order by annee;
+---------------------+---------------------+----------------------------------------+-----------+-------+
| Auteur              | LieuNaissance       | Titre                                  | Type      | Annee |
+---------------------+---------------------+----------------------------------------+-----------+-------+
| William Shakespeare | Stratford-upon-Avon | Roméo et Juliette                      | Théâtre   |  1594 |
| Charles Darwin      | Shrewsbury          | L'origine des espèces                  | Science   |  1856 |
| Mark Twain          | Florida             | Les aventures de Tom Sawyer            | Fiction   |  1876 |
| Emmanuel Jouanne    | Caen                | Damiers imaginaires                    | Fiction   |  1982 |
| Dan Simmons         | Peoria              | Hyperion                               | Fiction   |  1989 |
| J.K. Rowling        | Yate                | Harry Potter à  l'école des sorciers   | Fiction   |  1995 |
| Caryl Férey         | Caen                | Zulu                                   | Fiction   |  2008 |
+---------------------+---------------------+----------------------------------------+-----------+-------+
7 rows in set (0.00 sec)

Fonctions

Le langage SQL définit différentes fonctions pour permettre un traitement sur les données. En voici quelques exemples.

Compter le nombre de lignes : fonction count.

mysql> Select count(*) from Livres;
+----------+
| count(*) |
+----------+
|        7 |
+----------+
1 row in set (0.00 sec)

Pour déterminer la valeur maximale contenue dans une colonne, on utilisera max.

mysql> Select max(annee) from Livres;
+------------+
| max(annee) |
+------------+
|       2008 |
+------------+
1 row in set (0.03 sec)

On pourra trouver par exemple les fonctions suivantes :

traitement de chaîne de caractères: UPPER majuscules; LOWER minuscules; SUBSTRING (colonne FROM debut TO fin) sous chaîne
statistiques: MAX maximum; MIN minimum; SUM somme; AVG moyenne; COUNT nombre

Agrégation

Pour regrouper les résultats, on utilisera group by. Ici par exemple, on va chercher à dénombrer le nombre de livres par type.

mysql> Select Type, count(*) from Livres group by Type;
+-----------+----------+
| Type      | count(*) |
+-----------+----------+
| Fiction   |        5 |
| Science   |        1 |
| Théâtre   |        1 |
+-----------+----------+
3 rows in set (0.00 sec)

Attention, MySQL ne lèvera pas d'alerte si le regroupement n'est pas cohérent (par exemple grouper sur une colonne et afficher des colonnes non groupées).

Base d'exemple

Alias

On peut définir un alias pour une colonne (ou une vue, un résultat de fonction, ...) grâce au mot clé as.

mysql> Select Type, count(*) as Nombre from Livres group by Type;
+-----------+--------+
| Type      | Nombre |
+-----------+--------+
| Fiction   |      5 |
| Science   |      1 |
| Théâtre   |      1 |
+-----------+--------+
3 rows in set (0.01 sec)