À quoi cela servirait-il d'enregistrer des données dans une base, si l'on ne disposait pas d'outil pour les extraire ? La commande select est probablement la plus utilisée du langage, et peut-être aussi la plus complexe. On se propose de commencer son étude par quelques exemples simples, avant de voir les cas les plus compliqués.

Nous avons déjà vu l'utilisation de cette commande sur des cas très simples dans notre partie d'introduction. La forme la plus simple de la commande select est la suivante.


Cette clause consiste à évaluer une expression booléenne pour toutes les lignes de la table (ou des tables) en paramètre de la clause from de cette requête. L'argument d'une clause where doit donc toujours se réduire à une expression dont le résultat ne peut prendre que deux valeurs : true ou false.

Comme nous l'avons vu dans le chapitre d'introduction, il est possible de grouper plusieurs lignes entre elles sur des critères précis, et de calculer des expressions sur certaines colonnes particulières de ces lignes.

La syntaxe du select se complexifie alors un peu, et devient la suivante.


Voyons immédiatement l'exemple le plus simple, qui permet de compter le nombre de lignes de toute table.


Voyons un premier exemple simple, qui retourne la moyenne d'âge calculée sur toute la table Marins.


Ce deuxième exemple calcule la moyenne d'âge des marins par commune.


La clause group by indique au serveur SQL qu'il doit regrouper les marins par commune avant de calculer la moyenne d'âge de ces marins, groupe par groupe. Le résultat comportera donc autant de lignes qu'il y a de communes différentes dans la table Marins.

L'utilisation de la clause having permet de filtrer ce type de résultat. Dans l'exemple qui suit, on ne s'intéresse qu'aux communes pour lesquelles la moyenne d'âge est supérieure à 20 ans.


Il est important de bien comprendre la différence qu'il y a entre la clause where et la clause having. Dans ce type de requête, la clause where agit comme filtre sur les données avant l'application du regroupement des données. La clause having agit une fois les groupages effectués et les fonctions d'agrégation évaluées.

Introduction à SQL
Retour au blog Java le soir
Cours & Tutoriaux

Table des matières

Introduction
1. Un peu d'histoire
2. Organisation de la présentation
Un premier exemple
1. Un premier exemple
1.1. Construction d'une première table
1.2. Enregistrer quelques données
1.3. Extraire des données
2. Trier, classer, calculer
2.1. Classer des données
2.2. Trier des données
2.3. Effectuer des calculs
2.4. Mise à jour d'une valeur
3. Sélection sur plusieurs tables
3.1. Ajout du lieu de naissance
3.2. Clés primaires et clés étrangères
Organisation des données
1. Introduction
2. Bases de données, schémas et tables
2.1. Création d'une table
2.2. Création d'une colonne
2.3. Contraintes sur une table
2.4. Nommage des contraintes
2.5. Exemples de création de tables
2.6. Modification d'une table
2.7. Effacement d'une table
2.8. Remarques sur restrict et cascade
3. Types de données
3.1. Les types numériques
3.2. Les types caractère
3.3. Les types temporels
3.4. Les types binaires
3.5. Type auto-incrémental de MySQL
3.6. Type auto-généré de Derby
3.7. Séquences d'Oracle
Manipulation des données
1. Introduction
2. Extraire des données : select
2.1. Extraire des données d'une table unique
2.2. Clause where
2.3. Requêtes imbriquées
2.4. Fonctions d'agrégation, groupage
3. Supprimer des données : delete
3.1. Forme générale du delete
3.2. Effacement en cascade
3.3. Fonctionnement du delete
4. Ajouter des données : insert
4.1. Forme générale de l' insert
4.2. Copie d'une table dans une autre
5. Mettre à jour des données : update
5.1. Forme générale de l' update
5.2. Mise à jour avec une requête imbriquée
Interrogations sur plusieurs tables
1. Introduction
2. Formes normales
2.1. Première forme normale
2.2. Deuxième forme normale
2.3. Troisième forme normale
2.4. Formes normales d'ordres supérieurs
3. Relations entre éléments
3.1. Cardinalité d'une relation
3.2. Relation 1:1
3.3. Relation 1:p
3.4. Relation p:1
3.5. Relation n:p
4. Jointures
4.1. Jointure interne
4.2. Jointure externe
4.3. Auto-jointure
5. Unions
6. Vues
6.1. Création d'une vue
6.2. Exemples de vues
Transactions
1. Introduction
2. Isolation des transactions
2.1. ACIDité d'une transaction
2.2. Définition de l'isolation
3. Gestion d'une transaction
3.1. Mode auto-commit
3.2. Fixer le niveau d'isolation
3.3. Démarrer une transaction
3.4. Terminer une transaction
3.5. Remarques importantes
Index
1. Introduction
2. Manipulation d'index
2.1. Création automatique d'index
2.2. Création manuelle d'index