Requete De Selection Select
Création d'une base de données
Nous pouvons créer une base de données à l'aide de la console Mysql ou du gestionnaire PhpMyAdmin.
Création de la Base de données :
entreprise
Avec la console Mysql :

Cliquez sur l'icone de wamp, puis cliquer sur Mysql > Mysql Console.
Dans la console, vous pouvez cliquer sur l'icone en haut à gauche > propriété > configuration > Taille de la fenetre pour augmenter en largeur
Si vous souhaitez faire un copier/coller, sachez que le ctrl+v ne fonctionne pas sur certaines versions. Dans la console, il sera préférable d'effectuer un clic droit + coller.
A l'inverse, si vous voulez copier quelque chose de la console et le coller dans un fichier, il faudra également faire un clic droit + selectionner, prendre la partie qui vous intéresse (avec le clic gauche de la souris) et ensuite aller dans votre fichier et coller normalement le contenu.

Saisir le code SQL suivant :
CREATE DATABASE entreprise ;
Si vous êtes en mode console, nous rajouterons une ligne de code pour dire au SGBD que nous souhaitons travailler sur notre base de données entreprise :
USE entreprise;
Avec le gestionnaire PhpMyAdmin :
Création des tables
Une fois la base de données "entreprise" créée, nous aurons besoin d'une table pour contenir des enregistrements :
Création de la table :
employes
Base de données entreprise - Table employes
CREATE TABLE IF NOT EXISTS employes (
id_employes int(3) NOT NULL AUTO_INCREMENT,
prenom varchar(20) DEFAULT NULL,
nom varchar(20) DEFAULT NULL,
sexe enum('m','f') NOT NULL,
service varchar(30) DEFAULT NULL,
date_embauche date DEFAULT NULL,
salaire float DEFAULT NULL,
PRIMARY KEY (id_employes)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ;
Insertion et enregistrement des informations :
Dans tous les cas, voici les enregistrements à insérer dans la base de données entreprise afin d'avoir du contenu sur lequel travailler :
INSERT INTO employes (id_employes, prenom, nom, sexe, service, date_embauche, salaire) VALUES
(350, 'Jean-pierre', 'Laborde', 'm', 'direction', '1999-12-09', 5000),
(388, 'Clement', 'Gallet', 'm', 'commercial', '2000-01-15', 2300),
(415, 'Thomas', 'Winter', 'm', 'commercial', '2000-05-03', 3550),
(417, 'Chloe', 'Dubar', 'f', 'production', '2001-09-05', 1900),
(491, 'Elodie', 'Fellier', 'f', 'secretariat', '2002-02-22', 1600),
(509, 'Fabrice', 'Grand', 'm', 'comptabilite', '2003-02-20', 1900),
(547, 'Melanie', 'Collier', 'f', 'commercial', '2004-09-08', 3100),
(592, 'Laura', 'Blanchet', 'f', 'direction', '2005-06-09', 4500),
(627, 'Guillaume', 'Miller', 'm', 'commercial', '2006-07-02', 1900),
(655, 'Celine', 'Perrin', 'f', 'commercial', '2006-09-10', 2700),
(699, 'Julien', 'Cottet', 'm', 'secretariat', '2007-01-18', 1390),
(701, 'Mathieu', 'Vignal', 'm', 'informatique', '2008-12-03', 2000),
(739, 'Thierry', 'Desprez', 'm', 'secretariat', '2009-11-17', 1500),
(780, 'Amandine', 'Thoyer', 'f', 'communication', '2010-01-23', 1500),
(802, 'Damien', 'Durand', 'm', 'informatique', '2010-07-05', 2250),
(854, 'Daniel', 'Chevel', 'm', 'informatique', '2011-09-28', 1700),
(876, 'Nathalie', 'Martin', 'f', 'juridique', '2012-01-12', 3200),
(900, 'Benoit', 'Lagarde', 'm', 'production', '2013-01-03', 2550),
(933, 'Emilie', 'Sennard', 'f', 'commercial', '2014-09-11', 1800),
(990, 'Stephanie', 'Lafaye', 'f', 'assistant', '2015-06-02', 1775);
Si on récaptiule et qu'on développe :
Créer une base de données
CREATE DATABASE [nomdelabase] ;
Utiliser une base de données
USE [nomdelabase] ;
Lister les base de données
SHOW DATABASES;
Supprimer une base de données
DROP DATABASE [nomdelabase] ;
Supprimer une table d'une base de données
DROP TABLE [nomdelatable] ;
Vider le contenu d'une table d'une base de données
TRUNCATE [nomdelatable] ;
Observer la structure d'une table
DESC [nomdelatable] ;
Par exemple nous pourrions écrire :
DESC employes;
Cela nous permet de voir de quelle colonne est composée notre table.
Les requêtes de SELECTion
Afficher les noms et prénoms des employés travaillant dans l’entreprise
Requête SQL SELECT
SELECT nom, prenom FROM employes ;
Résultat
prenom |
nom |
Jean-pierre |
Laborde |
Clement |
Gallet |
Thomas |
Winter |
Chloe |
Dubar |
Elodie |
Fellier |
Fabrice |
Grand |
Melanie |
Collier |
Laura |
Blanchet |
Guillaume |
Miller |
Celine |
Perrin |
Julien |
Cottet |
Mathieu |
Vignal |
Thierry |
Desprez |
Amandine |
Thoyer |
Damien |
Durand |
Daniel |
Chevel |
Nathalie |
Martin |
Benoit |
Lagarde |
Emilie |
Sennard |
Stephanie |
Lafaye |
Afficher les services occupés dans l’entreprise
Requête SQL SELECT
SELECT service FROM employes ;
Résultat
service |
direction |
commercial |
commercial |
production |
secretariat |
comptabilite |
commercial |
direction |
commercial |
commercial |
secretariat |
informatique |
secretariat |
communication |
informatique |
informatique |
juridique |
production |
commercial |
assistant |
Explications
Nous obtenons la liste des différents services dans l'entreprise. Ceci comporte des doublons car Mysql a renvoyé la colonne nommée service sans se préoccuper des doublons.
Le mot clé DISTINCT
Afficher les services occupés dans l’entreprise (en évitant les doublons cette fois-ci)
Requête SQL SELECT
SELECT DISTINCT(service) FROM employes ;
Résultat
service |
direction |
commercial |
production |
secretariat |
comptabilite |
informatique |
communication |
juridique |
assistant |
Explications
Le mot clé
DISTINCT permet d'éviter les doublons.
Bon à savoirLa fleche du haut (au clavier) est un racourrci pour l'historique des requêtes.
Les requêtes ne sont pas senssibles à la casse, mais une convention indique qu'il faut mettre les mots-clés des requetes en majuscule.
Afficher la table employes (toutes les colonnes / champs)
Requête SQL SELECT
SELECT id_employes, prenom, nom, sexe, service, date_embauche, salaire FROM employes;
Résultat
id_employes | prenom | nom | sexe | service | date_embauche | salaire |
---|
350 | Jean-pierre | Laborde | m | direction | 1999-12-09 | 5000 |
388 | Clement | Gallet | m | commercial | 2000-01-15 | 2300 |
415 | Thomas | Winter | m | commercial | 2000-05-03 | 3550 |
417 | Chloe | Dubar | f | production | 2001-09-05 | 1900 |
491 | Elodie | Fellier | f | secretariat | 2002-02-22 | 1600 |
509 | Fabrice | Grand | m | comptabilite | 2003-02-20 | 1900 |
547 | Melanie | Collier | f | commercial | 2004-09-08 | 3100 |
592 | Laura | Blanchet | f | direction | 2005-06-09 | 4500 |
627 | Guillaume | Miller | m | commercial | 2006-07-02 | 1900 |
655 | Celine | Perrin | f | commercial | 2006-09-10 | 2700 |
699 | Julien | Cottet | m | secretariat | 2007-01-18 | 1390 |
701 | Mathieu | Vignal | m | informatique | 2008-12-03 | 2000 |
739 | Thierry | Desprez | m | secretariat | 2009-11-17 | 1500 |
780 | Amandine | Thoyer | f | communication | 2010-01-23 | 1500 |
802 | Damien | Durand | m | informatique | 2010-07-05 | 2250 |
854 | Daniel | Chevel | m | informatique | 2011-09-28 | 1700 |
876 | Nathalie | Martin | f | juridique | 2012-01-12 | 3200 |
900 | Benoit | Lagarde | m | production | 2013-01-03 | 2550 |
933 | Emilie | Sennard | f | commercial | 2014-09-11 | 1800 |
990 | Stephanie | Lafaye | f | assistant | 2015-06-02 | 1775 |
Explications
Nous selectionnons toutes les colonnes que nous souhaitons voir apparaitre dans le résultat.
Le raccourci *
Afficher la table employes (toutes les colonnes / champs) avec le raccourci étoile " * "
Requête SQL SELECT
SELECT * FROM employes;
Résultat
id_employes | prenom | nom | sexe | service | date_embauche | salaire |
---|
350 | Jean-pierre | Laborde | m | direction | 1999-12-09 | 5000 |
388 | Clement | Gallet | m | commercial | 2000-01-15 | 2300 |
415 | Thomas | Winter | m | commercial | 2000-05-03 | 3550 |
417 | Chloe | Dubar | f | production | 2001-09-05 | 1900 |
491 | Elodie | Fellier | f | secretariat | 2002-02-22 | 1600 |
509 | Fabrice | Grand | m | comptabilite | 2003-02-20 | 1900 |
547 | Melanie | Collier | f | commercial | 2004-09-08 | 3100 |
592 | Laura | Blanchet | f | direction | 2005-06-09 | 4500 |
627 | Guillaume | Miller | m | commercial | 2006-07-02 | 1900 |
655 | Celine | Perrin | f | commercial | 2006-09-10 | 2700 |
699 | Julien | Cottet | m | secretariat | 2007-01-18 | 1390 |
701 | Mathieu | Vignal | m | informatique | 2008-12-03 | 2000 |
739 | Thierry | Desprez | m | secretariat | 2009-11-17 | 1500 |
780 | Amandine | Thoyer | f | communication | 2010-01-23 | 1500 |
802 | Damien | Durand | m | informatique | 2010-07-05 | 2250 |
854 | Daniel | Chevel | m | informatique | 2011-09-28 | 1700 |
876 | Nathalie | Martin | f | juridique | 2012-01-12 | 3200 |
900 | Benoit | Lagarde | m | production | 2013-01-03 | 2550 |
933 | Emilie | Sennard | f | commercial | 2014-09-11 | 1800 |
990 | Stephanie | Lafaye | f | assistant | 2015-06-02 | 1775 |
Explications
Le raccourci étoile permet de cibler toutes les colonnes afin de les afficher.
C'est une requête à connaitre par coeur SELECT * FROM [nomdelatable].
Les conditions : Le mot clé WHERE
Il arrive parfois que nous ne souhaitions pas ressortir la totalité de nos données mais seulement une partie.
Pour cela nous allons utiliser une condition via la requête sql.
Afficher les employes (nom et prénom) du service informatique (uniquement)
Requête SQL SELECT
SELECT nom, prenom FROM employes WHERE service='informatique';
Résultat
nom | prenom |
---|
Vignal | Mathieu |
Durand | Damien |
Chevel | Daniel |
InformationsLes apostrophes et quotes sont équivalentes (where service = 'informatique' pareil que where service = "informatique"). Nous ne mettrons pas de quotes ou d'apostrophes lorsque nous devons énnoncer un chiffre (cela fonctionnerait quand même mais serait moins optimisé et contre nature car mysql devra convertir une chaine de caractères en integer).
Explications
Dans notre contexte, le mot clé
WHERE peut être traduit par " à condition que ".
"A condition que le service soit Informatique"
Dans notre condition, nous respecterons toujours le format suivant : champ = valeur
Le champ sur lequel on annonce la condition doit être énoncé suivi de la valeur à transmettre.
Voici quelques explications supplémentaires :
Le mot clé BETWEEN
Afficher les employes ayant été recrutés entre 2006 et 2010
Requête SQL SELECT
SELECT nom, prenom, date_embauche FROM employes WHERE date_embauche BETWEEN '2006-01-01' AND '2010-12-31';
Résultat
nom | prenom | date_embauche |
---|
Miller | Guillaume | 2006-07-02 |
Perrin | Celine | 2006-09-10 |
Cottet | Julien | 2007-01-18 |
Vignal | Mathieu | 2008-12-03 |
Desprez | Thierry | 2009-11-17 |
Thoyer | Amandine | 2010-01-23 |
Durand | Damien | 2010-07-05 |
Explications
Dans cette requête nous mettrons une condition sur le champ date_embauche afin de selectionner uniquement les employés répondant aux critères énoncé dans la condition : avoir été recruté entre le 1er janvier 2006 et le 31 décembre 2010.
La date s'inscrit au format Américain : ANNEE - MOIS - JOUR
Imaginons que l'on veuille afficher les employés recrutés entre 2006 et aujourd'hui, aujourd'hui est une valeur qui change toutes les 24h et vous imaginez bien qu'on ne pourra pas mettre à jour constamment la date contenue dans la requête.
Pour cette raison nous allons utiliser une fonction prédéfinie
CURDATE().
SELECT CURDATE();
Résultat
2023-04-01
Les fonctions prédéfinies permettent de réaliser un traitement (en l'occurence, afficher la date du jour), elles sont toujours suivies de parenthèses.
Afficher les employes ayant été recrutés entre 2006 et aujourd'hui
Requête SQL SELECT
SELECT nom, prenom, date_embauche FROM employes WHERE date_embauche BETWEEN '2006-01-01' AND CURDATE();
Résultat
nom | prenom | date_embauche |
---|
Miller | Guillaume | 2006-07-02 |
Perrin | Celine | 2006-09-10 |
Cottet | Julien | 2007-01-18 |
Vignal | Mathieu | 2008-12-03 |
Desprez | Thierry | 2009-11-17 |
Thoyer | Amandine | 2010-01-23 |
Durand | Damien | 2010-07-05 |
Chevel | Daniel | 2011-09-28 |
Martin | Nathalie | 2012-01-12 |
Lagarde | Benoit | 2013-01-03 |
Sennard | Emilie | 2014-09-11 |
Lafaye | Stephanie | 2015-06-02 |
Explications
CURDATE() permet de sortir la date du jour (évolutive dans le temps).
Le mot clé LIKE
Like, très utilisé dans les moteurs de recherche, nous permet de trouver des enregistrements sans avoir d'informations précises mais seulement un mot ou une lettre pouvant coincider avec les enregistrements en question.
Afficher les employés ayant un prénom commençant par la lettre "S"
Requête SQL SELECT
SELECT prenom FROM employes WHERE prenom LIKE 's%'
Explications
LIKE nous permet d'annoncer une valeur approchante sans avoir pour autant la valeur exacte.
Le signe % nous permet d'annoncer une suite de caractères quelconques.
Dans notre cas, 's%' veut dire qui commence par la lettre S.
Nous aurions également pu inscrire '%s' pour dire qui termine par la lettre S.
Exemple :
Requête SQL SELECT
SELECT prenom FROM employes WHERE prenom LIKE '%s'
Explications
Le % étant placé après la lettre S, nous demandons au système de sortir tous les prénoms ayant une lettre S à la fin.
Autre exemple :
Requête SQL SELECT
SELECT prenom FROM employes WHERE prenom LIKE '%-%'
Explications
Avec la présence des signes pourcentages avant et après la lettre ou le mot recherché, nous demandons au système de trouver des enregistrements contenant l'expression recherchée.
Dans notre cas, nous isolerons les prénoms composés (ayant un trait d'union).
A quoi cela peut-il servir ?
Imaginons une table d'appartements (destinés à la location) avec les données suivantes :
id |
ville |
cp |
adresse |
prix |
superficie |
1 | Paris | 75015 | rue A | 730 | 25 |
2 | Paris | 75011 | rue B | 800 | 28 |
3 | Paris | 69003 | rue C | 820 | 30 |
4 | Paris | 75016 | rue D | 710 | 18 |
5 | Paris | 75008 | rue E | 920 | 33 |
6 | Paris | 75007 | rue F | 890 | 37 |
Voici une condition avec le signe égal (classique) :
Requête SQL SELECT
SELECT * FROM appartement WHERE cp = 75;
Aucun enregistrements ne s'affichera suite à cette requête car aucun appartement n'est dans le département 75 mais dans le 75015, 75011, etc.
En revanche, avec la présence du mot clé like nous allons pouvoir cibler tous les appartements dont le code postal commence par 75 :
Requête SQL SELECT
SELECT * FROM appartement WHERE cp LIKE '75%';
N'ayant pas rééllement cette table de données sous la main, nous ne saisirons pas cette requête mais nous pouvons imaginer les résultats.
Operateurs de comparaisons
- = "est égal"
- > "strictement supérieur"
- < "strictement inférieur"
- >= "supérieur ou égal"
- <= "inférieur ou égal"
- <> ou != "est différent"
L'opérateur !=
Afficher tous les employés sauf ceux du service informatique
Requête SQL SELECT
SELECT nom, prenom, service FROM employes WHERE service != 'informatique';
Résultat
nom | prenom | service |
---|
Laborde | Jean-pierre | direction |
Gallet | Clement | commercial |
Winter | Thomas | commercial |
Dubar | Chloe | production |
Fellier | Elodie | secretariat |
Grand | Fabrice | comptabilite |
Collier | Melanie | commercial |
Blanchet | Laura | direction |
Miller | Guillaume | commercial |
Perrin | Celine | commercial |
Cottet | Julien | secretariat |
Desprez | Thierry | secretariat |
Thoyer | Amandine | communication |
Martin | Nathalie | juridique |
Lagarde | Benoit | production |
Sennard | Emilie | commercial |
Lafaye | Stephanie | assistant |
Explications
Nous pouvons apercevoir dans la liste de résultats tous les employés sauf ceux du service informatique.
L'opérateur >
Afficher tous les employés gagnant un salaire supérieur à 3 000 €
Requête SQL SELECT
SELECT nom, prenom, service, salaire FROM employes WHERE salaire > 3000;
Résultat
nom | prenom | service | salaire |
---|
Laborde | Jean-pierre | direction | 5000 |
Winter | Thomas | commercial | 3550 |
Collier | Melanie | commercial | 3100 |
Blanchet | Laura | direction | 4500 |
Martin | Nathalie | juridique | 3200 |
Explications
Nous isolons une portion de résultats : seulement les employés gagnant + de 3 000 €.
Les classements avec ORDER BY
Afficher tous les employés par ordre alphabétique (colonne prenom)
Requête SQL SELECT
SELECT prenom, nom FROM employes ORDER BY prenom ;
SELECT prenom, nom FROM employes ORDER BY prenom ASC ;
Avec ou sans le ASC la requête est la même. ASC est le mode de classement appliqué par défaut.
ASC veut dire ASCendant croissant (du plus petit au plus grand).
Résultat
prenom | nom |
---|
Amandine | Thoyer |
Benoit | Lagarde |
Celine | Perrin |
Chloe | Dubar |
Clement | Gallet |
Damien | Durand |
Daniel | Chevel |
Elodie | Fellier |
Emilie | Sennard |
Fabrice | Grand |
Guillaume | Miller |
Jean-pierre | Laborde |
Julien | Cottet |
Laura | Blanchet |
Mathieu | Vignal |
Melanie | Collier |
Nathalie | Martin |
Stephanie | Lafaye |
Thierry | Desprez |
Thomas | Winter |
Explications
Comme vous pouvez le constater la liste des prénoms est bien classée dans l'ordre "Amandine" avant "Benoit" avant "Celine", etc.
Nous pouvons également demander le classement inverse avec le mot clé DESC :
Requête SQL SELECT
SELECT prenom, nom FROM employes ORDER BY prenom DESC ;
Résultat
prenom | nom |
---|
Thomas | Winter |
Thierry | Desprez |
Stephanie | Lafaye |
Nathalie | Martin |
Melanie | Collier |
Mathieu | Vignal |
Laura | Blanchet |
Julien | Cottet |
Jean-pierre | Laborde |
Guillaume | Miller |
Fabrice | Grand |
Emilie | Sennard |
Elodie | Fellier |
Daniel | Chevel |
Damien | Durand |
Clement | Gallet |
Chloe | Dubar |
Celine | Perrin |
Benoit | Lagarde |
Amandine | Thoyer |
Explications
DESC permet d'annoncer DESCandant décroissant (du plus grand au plus petit).
Nous pouvons également réaliser plusieurs classements sur des champs/colonnes différents :
Requête SQL SELECT
SELECT nom, prenom, service, salaire FROM employes ORDER BY salaire ASC, prenom ASC;
Résultat
nom | prenom | service | salaire |
---|
Cottet | Julien | secretariat | 1390 |
Thoyer | Amandine | communication | 1500 |
Desprez | Thierry | secretariat | 1500 |
Fellier | Elodie | secretariat | 1600 |
Chevel | Daniel | informatique | 1700 |
Lafaye | Stephanie | assistant | 1775 |
Sennard | Emilie | commercial | 1800 |
Dubar | Chloe | production | 1900 |
Grand | Fabrice | comptabilite | 1900 |
Miller | Guillaume | commercial | 1900 |
Vignal | Mathieu | informatique | 2000 |
Durand | Damien | informatique | 2250 |
Gallet | Clement | commercial | 2300 |
Lagarde | Benoit | production | 2550 |
Perrin | Celine | commercial | 2700 |
Collier | Melanie | commercial | 3100 |
Martin | Nathalie | juridique | 3200 |
Winter | Thomas | commercial | 3550 |
Blanchet | Laura | direction | 4500 |
Laborde | Jean-pierre | direction | 5000 |
Explications
Le classement se fera sur le champ salaire, si jamais 2 employés gagnent le même salaire nous avons prévu un classement secondaire sur le champ prenom.
Pour 2 personnes qui gagneraient 1900 €, Fabrice apparaitra avant Guillaume (F se trouve avant G dans l'alphabet).
Lorsque nous demandons d'afficher les produits des moins chers aux plus chers sur un site web ecommerce, la requête SQL utilise une clause ORDER BY pour faire le classement et vous proposer un affichage concordant.
ORDER BY sera donc précieux pour réaliser des classements sur vos prochains sites web.
Limiter les résultats avec le mot clé LIMIT
Afficher les employés en les classant par salaire (du plus grand au plus petit) et en les affichant par 3.
Requête SQL SELECT
SELECT nom, prenom, service, salaire FROM employes ORDER BY salaire DESC LIMIT 0,3;
Résultat
nom | prenom | service | salaire |
---|
Laborde | Jean-pierre | direction | 5000 |
Blanchet | Laura | direction | 4500 |
Winter | Thomas | commercial | 3550 |
Explications
LIMIT permet de limiter les résultats.
Le premier chiffre précise l'enregistrement de départ (0 définit le 1er enregistrement en informatique), le second chiffre nous indique le nombre de résultats que l'on souhaite obtenir.
Les prochains résultats seront affichés de cette manière :
Requête SQL SELECT
SELECT nom, prenom, service, salaire FROM employes ORDER BY salaire DESC LIMIT 3,3;
Et ainsi de suite :
Requête SQL SELECT
SELECT nom, prenom, service, salaire FROM employes ORDER BY salaire DESC LIMIT 6,3;
Puis :
Requête SQL SELECT
SELECT nom, prenom, service, salaire FROM employes ORDER BY salaire DESC LIMIT 9,3;
Le premier chiffre reste la position de laquelle on part, le second chiffre annonce toujours le nombre d'enregistrements à afficher (dans notre cas, on souhaite les afficher 3 par 3, donc ce 2e chiffre n'évolue pas).
Lorsque nous consultons un catalogue avec des centaines de produits, le site web ne peut pas tous les afficher d'un coup sinon la page web mettrait trop de temps à charger et la scrollbar serait trop longue, la requête SQL crée une pagination (affichage par groupe de 10 produits par exemples) grâce à la clause LIMIT.
LIMIT sera donc précieux sur vos prochains sites web pour créer des affichage avec pagination.
Réaliser des calculs dans nos requêtes
Il est possible de réaliser des calculs dans nos requêtes SQL.
Afficher la liste des employés avec leur salaire annuel (nous ferons un x12 pour simplifier le calcul dans le cadre de ce cours).
Requête SQL SELECT
SELECT nom, prenom, salaire*12 FROM employes;
Résultat
nom | prenom | salaire*12 |
---|
Laborde | Jean-pierre | 60000 |
Gallet | Clement | 27600 |
Winter | Thomas | 42600 |
Dubar | Chloe | 22800 |
Fellier | Elodie | 19200 |
Grand | Fabrice | 22800 |
Collier | Melanie | 37200 |
Blanchet | Laura | 54000 |
Miller | Guillaume | 22800 |
Perrin | Celine | 32400 |
Cottet | Julien | 16680 |
Vignal | Mathieu | 24000 |
Desprez | Thierry | 18000 |
Thoyer | Amandine | 18000 |
Durand | Damien | 27000 |
Chevel | Daniel | 20400 |
Martin | Nathalie | 38400 |
Lagarde | Benoit | 30600 |
Sennard | Emilie | 21600 |
Lafaye | Stephanie | 21300 |
Explications
Le système va multiplier par 12 toutes les valeurs qu'il trouvera dans la colonne salaire.
Définir un ALIAS avec AS
Reprenons la requête précédente :
Requête SQL SELECT
SELECT nom, prenom, salaire*12 AS salaire_annuel FROM employes;
Résultat
nom | prenom | salaire_annuel |
---|
Laborde | Jean-pierre | 60000 |
Gallet | Clement | 27600 |
Winter | Thomas | 42600 |
Dubar | Chloe | 22800 |
Fellier | Elodie | 19200 |
Grand | Fabrice | 22800 |
Collier | Melanie | 37200 |
Blanchet | Laura | 54000 |
Miller | Guillaume | 22800 |
Perrin | Celine | 32400 |
Cottet | Julien | 16680 |
Vignal | Mathieu | 24000 |
Desprez | Thierry | 18000 |
Thoyer | Amandine | 18000 |
Durand | Damien | 27000 |
Chevel | Daniel | 20400 |
Martin | Nathalie | 38400 |
Lagarde | Benoit | 30600 |
Sennard | Emilie | 21600 |
Lafaye | Stephanie | 21300 |
Explications
Le mot clé AS permet de définir un ALIAS
Calculer la somme d'une colonne avec SUM
Nous pourrions calculer la somme que l'on paye pour nos salariés en faisant la somme de la colonne salaire :
Requête SQL SELECT
SELECT SUM(salaire*12) FROM employes;
Explications
Même si d'un point de vue comptable, le calcul de la masse salariale ne s'effectue pas comme ceci, nous voyons à travers cet exemple le calcul permettant de faire la somme d'une colonne.
Ceci sera pratique sur un site web pour calculer le CA (Chiffre d'Affaires) d'une boutique ecommerce.
Calculer une moyenne avec AVG
Nous pourrions calculer le salaire moyen gagné dans notre entreprise :
Requête SQL SELECT
SELECT AVG(salaire) FROM employes;
Explications
AVG est une fonction prédéfinie prenant comme argument (entre parenthèse) le nom de la colonne sur laquelle nous souhaitons calculer une moyenne.
Le salaire moyen est de 2405.75 €.
Ceci sera pratique sur un site web pour calculer le prix d'achat moyen d'une boutique ecommerce.
Arrondir avec ROUND
Nous pourrions arrondir le calcul précédent :
Requête SQL SELECT
SELECT ROUND(AVG(salaire)) FROM employes;
Explications
ROUND est une fonction prédéfinie prenant comme argument (entre parenthèse) le nombre à arrondir :
Nous aurions également pu inscrire : ROUND(AVG(salaire),2) pour obtenir 2 chiffres après la virgule (mais c'est déjà ce que nous avions de base).
Ceci sera pratique sur un site web pour arrondir des prix de vente avec le calcul de TVA sur une boutique ecommerce.
Compter avec COUNT
Nous pourrions compter le nombre de résultats :
Requête SQL SELECT
SELECT COUNT(*) FROM employes WHERE sexe='f';
Explications
Dans ce contexte, cela nous permet de compter le nombre de femmes dans l'entreprise
Isoler une valeur minimum/maximum avec MIN/MAX
Voyons comment trouver le salaire le plus faible dans notre liste d'employés :
Requête SQL SELECT
SELECT MIN(salaire) FROM employes;
Explications
Le mot clé MIN permet d'isoler le nombre minimum dans une colonne/champ.
De la même manière le mot clé MAX existe pour mettre en évidence le nombre maximum dans une colonne/champ.
AttentionPour autant, nous ne pourrons pas demander au système l'identité de cette personne via cette requête :
Requête SQL SELECT
SELECT prenom, MIN(salaire) FROM employes;
Résultatprenom | MIN(salaire) |
---|
Jean-pierre | 1390 |
Il n'y a pas d'erreur de requête mais le résultat est erroné, ce n'est pas Jean-Pierre qui gagne 1 390 €
Le système nous donne le premier résultat de la liste accompagné du salaire le plus faible.
En effet, si nous demandons au système de calculer le salaire le plus faible, nous ne pouvons pas lui demander dans le même temps de qui il s'agit. il ne pourra pas combiner les 2 instructions pour mener à 1 résultat cohérent.
Pour isoler le salaire le plus faible et en même temps connaitre l'identité de cette personne, nous devrons passer par une requête imbriquée (une requete dans une autre) :
Requête SQL SELECT
SELECT prenom, salaire FROM employes WHERE salaire = (SELECT MIN(salaire) FROM employes);
Le système va d'abord exécuter la requête entre parenthèse pour connaitre le résultat et l'utiliser comme source pour l'autre requête.
Si nous lisons la sous requête (requête entre parenthèse) nous tomberons sur 1390, nous pourrons donc simplifier notre lecture par la requête suivante :
Requête SQL SELECT
SELECT prenom, salaire FROM employes WHERE salaire = 1390;
Nous demandons quelle personne gagne un salaire de 1390 €, il s'agit de Julien Cottet.
Condition IN avec plusieurs valeurs
Nous pouvons appliquer une même condition comportant plusieurs valeurs grâce au mot clé IN :
Requête SQL SELECT
SELECT prenom,service FROM employes WHERE service IN('comptabilite', 'informatique');
Résultat
prenom | service |
---|
Fabrice | comptabilite |
Mathieu | informatique |
Damien | informatique |
Daniel | informatique |
Explications
Cette requête nous permet d'afficher les informaticiens et comptables dans l'entreprise.
Pour résumé :
- = (égal) permet d'annoncer 1 seule valeur
- IN permet d'annoncer plusieurs valeurs
Nous pouvons également exclure plusieurs valeurs avec NOT IN :
Requête SQL SELECT
SELECT prenom, service FROM employes WHERE service NOT IN('comptabilite', 'informatique');
Résultat
prenom | service |
---|
Jean-pierre | direction |
Clement | commercial |
Thomas | commercial |
Chloe | production |
Elodie | secretariat |
Melanie | commercial |
Laura | direction |
Guillaume | commercial |
Celine | commercial |
Julien | secretariat |
Thierry | secretariat |
Amandine | communication |
Nathalie | juridique |
Benoit | production |
Emilie | commercial |
Stephanie | assistant |
Explications
Cette requête nous permet d'afficher tous les employés sauf les informaticiens et comptables de l'entreprise.
Pour résumé :
- != (égal) permet d'exclure 1 seule valeur
- NOT IN permet d'exclure plusieurs valeurs
Conditions multiples (différents champs et valeurs)
Il est possible d'appliquer plusieurs conditions différentes au sein de la même requête :
Requête SQL SELECT
SELECT prenom, nom, salaire, service FROM employes WHERE service='commercial' AND salaire <= 2000 ;
Résultat
prenom | nom | salaire | service |
---|
Guillaume | Miller | 1900 | commercial |
Emilie | Sennard | 1800 | commercial |
Explications
Dans cette requête nous demanderons à ce que les employés fassent partie du service commercial et gagnent un salaire supérieur ou égal a 2000 €.
Ordre de priorité sur les conditions AND et OR
Lorsque nous avons plusieurs conditions mélangeant OR (ou) et AND (et) l'ordre naturel de lecture peut être modifié, exemple :
Requête SQL SELECT
SELECT prenom, nom, service, salaire FROM employes WHERE service='production' AND salaire= 1900 OR salaire=2300 ;
Résultat
prenom | nom | service | salaire |
---|
Clement | Gallet | commercial | 2300 |
Chloe | Dubar | production | 1900 |
Explications
Dans cette requête nous partons dans l'idée de demander l'affichage des employés du service production gagnant un salaire de 1900 € ou 2300 € précisément.
Notre résultat inclut Clément Gallet du service commercial gagnant également 2300 €. Nous ne souhaitons pas le voir apparaitre dans la liste car nous aimerions obtenir uniquement des employés du service production (qui peuvent gagner 1900 ou 2300 €).
Pourquoi un enregistrement indésiré est présent dans la liste ? Lorsqu'il y a AND et OR au sein de la même requête, le système lit la condition de la droite vers la gauche et il verra d'abord
salaire= 1900 OR salaire=2300
et ensuite
service='production'
Pour garantir l'ordre naturel de lecture (de la gauche vers la droite), nous utiliserons des parenthèses :
Requête SQL SELECT
SELECT prenom, nom, service, salaire FROM employes WHERE service='production' AND (salaire= 1900 OR salaire=2300) ;
De cette manière, nous sommes sûr d'obtenir le(s) bon(s) résultat(s) :
Résultatprenom | nom | service | salaire |
---|
Chloe | Dubar | production | 1900 |
Les regroupements avec GROUP BY
Si nous voulons connaitre le nombre d'employés par service, il peut être utile de faire des regroupements, voici un exemple :
Requête SQL SELECT
SELECT service, COUNT(*) AS nombre FROM employes GROUP BY service;
Résultatservice | nombre |
---|
assistant | 1 |
commercial | 6 |
communication | 1 |
comptabilite | 1 |
direction | 2 |
informatique | 3 |
juridique | 1 |
production | 2 |
secretariat | 3 |
Explications
Le mot clé COUNT permet de compter chaque ligne d'enregistrement (+1), tandis que GROUP BY permet de les grouper ensemble (tout les +1) en fonction du même service.
Nous obtenons bien le nombre d'employés par service.
Pour imposer une condition dans une requête comportant un GROUP BY, nous utiliserons le mot clé HAVING :
Requête SQL SELECT
SELECT service, COUNT(*) AS nombre FROM employes GROUP BY service HAVING COUNT(*) > 2;
Résultatservice | nombre |
---|
commercial | 6 |
informatique | 3 |
secretariat | 3 |