ENSSA – Tlemcen @ Département Classe préparatoire 2018-2019 Semestre II

I- Définition Exemple :
http://sql.sh/cours http://www.w3schools.com/sql/default.asp CREATE DATABASE hmida;
SQL est un langage qui permet au programmeur de formuler CREATE DATABASE ali;
des expressions d’interrogation, de mise à jour et de CREATE DATABASE informatique;
restructuration d’une base de données. Ces opérations DROP DATABASE hmida ;
CREATE DATABASE ESSATlemcen ;
nécessitent une structure de données sur laquelle elles vont être
appliquées. La seule structure de données utilisée est la table. SHOW DATABASES;
Une table consiste en un certains nombre d’attributs (colonnes). +--------------------+
Pour chaque attribut on définit son type. Le tableau suivant | Database |
résume les types de base : +--------------------+
char(n) Chaine de caractère de longueur | ali |
constante égale à n octets, | informatique |
Max=255 et valeur par défaut=1. | ESSATlemcen |
+--------------------+
varchar(n) chaine de caractère de longueur
variable. Max n= 2000. 2- Définir une table:
- La création d’une table se traduit par la requête SQL suivante :
text Un text (255 caractères max). CREATE TABLE Nom_Table(
decimal(length,fraction) Length : le nombre total des colonne1 datatype,
chiffres. Fraction : la longueur de la colonne2 datatype,
partie fractionnelle. colonne3 datatype,
Length 4, fraction 2: 99.99 .....
Length 10, fraction 0: 9999999999 colonneN datatype,
Length 8, fraction 3: 99999.999 PRIMARY KEY( un ou plusieurs colonnes )
Length 8, fraction -3: 99999000 );
integer(length) Nombre entier (pas de partie Exemple :
CREATE TABLE CUSTOMERS(
fractionnelle). ID INT NOT NULL,
float Nombre à virgule flottante avec une NAME VARCHAR (20) NOT NULL,
longueur = 38. AGE INT NOT NULL,
date Intervalle (01-Jan-4712 BC, 31- ADDRESS CHAR (25) ,
Dec-4712 AD). Format par défaut SALARY DECIMAL (18, 2),
‘dd-mmm-yy’. PRIMARY KEY (ID)
On distingue trois types de tables : );
+-------+-----------+----+-----+--------+-----+
- Tables de base : Ce sont les tables du modèle logique de | Field | Type |Null| Key | Default|Extra|
données. +-------+-----------+----+-----+--------+-----+
- Tables dérivées : Ce sont des tables obtenues à partir des | ID |int(11) | NO | PRI | | |
tables de base (après l’application d’une requête). Elles peuvent | NAME |varchar(20)| NO | | | |
être stockées dans la base. | AGE |int(11) | NO | | | |
- Tables virtuelles (vue): Une vue se compose de lignes et de | ADDR |char(25) | YES| | NULL | |
colonnes, tout comme une table. La différence entre une vue et | SALARY |decimal(18,2)|YES | | NULL | |
+-------+-----------+----+-----+--------+-----+
une table est que les vues sont obtenues à partir d'autres tables
(ou vues) on appliquant des requêtes SQL, et ne contiennent pas - la suppression d’une table :
DROP TABLE Nom_Table;
les données eux-mêmes. Si les données changent dans la table à
- la Modification de la structure d’une table : en ajoutant ou en
partir de laquelle on à obtenue la vue, le même changement se
supprimant ou en changeant des colonnes.
reflète dans la vue. Une vue peut être obtenue à partir d'une ALTER TABLE Nom_Table ADD Nom_col Type_donnee;
seule table ou plusieurs tables. Elle peut également être obtenue ALTER TABLE Nom_Table DROP COLUMN Nom_col;
d'une autre vue. ALTER TABLE Nom_Table MODIFY COLUMN Nom_col;
Le langage SQL se compose de quatre types de requêtes : Exemple :
requêtes de définition de données DDL et requêtes de ALTER TABLE CUSTOMERS MODIFY NAME varchar(30);
manipulation de données DML, requêtes de contrôle de ALTER TABLE CUSTOMERS DROP COLUMN ADDR;
données DCL et requêtes de contrôle de transaction TCL. ALTER TABLE CUSTOMERS ADD ADDR char(20);
II- Requêtes de définition de données +-------+-----------+----+-----+--------+-----+
Ce type de requêtes permet la création, la suppression et le | Field | Type |Null| Key | Default|Extra|
+-------+-----------+----+-----+--------+-----+
changement des structures de la base (base de données, tables,
| ID |int(11) | NO | PRI | | |
vues). | NAME |varchar(30)| NO | | | |
1- Définir une base de données : | AGE |int(11) | NO | | | |
- La création d’une base de données se traduit par la requête | ADDR |char(20) | YES| | NULL | |
SQL suivante : | SALARY |decimal(18,2)|YES | | NULL | |
CREATE DATABASE NOM_DE_LA_BASE; +-------+-----------+----+-----+--------+-----+
- La suppression d’une base de données : 3- Définir une vue:
DROP DATABASE NOM_DE_LA_BASE ; - La création d’une vue se traduit par la requête SQL suivante :
- La sélection d’une base de données CREATE VIEW Nom_de_vue AS
SELECT nom_de_colonne (s)
USE NOM_DE_LA_BASE; FROM Nom_table Requête
- Visionner les bases de données disponibles WHERE condition ;
SHOW DATABASES; Exemple:
Module : Base de données Chap4 : Structured query language SQL (Langage de requête structurée) ©A.BEKADDOUR page 1
ENSSA – Tlemcen @ Département Classe préparatoire 2018-2019 Semestre II
Supposant que la table CUSTOMERS contient les données La table devient :
suivantes : +----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+ | ID | NAME | AGE | ADDRESS | SALARY |
| ID | NAME | AGE | ADDR | SALARY | +----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+ | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 | | 2 | Khilan | 25 | Delhi | 1500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 | | 3 | kaushik | 23 | Kota | 2000.00 |
| 3 | kaushik | 23 | Kota | 2000.00 | | 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+-----------+----------+ | 5 | Hardik | 27 | Bhopal | 8500.00 |
CREATE VIEW CUSTOMERS_VIEW AS | 6 | Komal | 22 | MP | 4500.00 |
SELECT name, age | 7 | Muffy | 24 | Indore | 10000.00 |
FROM CUSTOMERS; +----+----------+-----+-----------+----------+
La vue sera: - La requête DELETE :
+----------+-----+ On utilise cette requête pour supprimer des lignes d’une table.
| name | age | DELETE FROM Nom_table
+----------+-----+ WHERE [condition];
| Ramesh | 32 | Prenant le cas de la table CUSTOMERS
| Khilan | 25 | +----+----------+-----+-----------+----------+
| kaushik | 23 | | ID | NAME | AGE | ADDRESS | SALARY |
+----------+-----+ +----+----------+-----+-----------+----------+
- la suppression d’une vue : | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
DROP VIEW view_name; | 2 | Khilan | 25 | Delhi | 1500.00 |
III- Requêtes de manipulation de données | 3 | kaushik | 23 | Kota | 2000.00 |
Ce type de requêtes permet l’interrogation et la modification | 4 | Chaitali | 25 | Mumbai | 6500.00 |
des données. | 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
1- Manipulation des données
| 7 | Muffy | 24 | Indore | 10000.00 |
Ce type de requêtes permet d’insérer, de supprimer ou de +----+----------+-----+-----------+----------+
modifier des données contenus dans les tables (vues) définit par DELETE FROM CUSTOMERS
le DDL. WHERE ID = 6;
- La requête INSERT : +----+----------+-----+-----------+----------+
On utilise cette requête pour ajouter des nouvelles lignes à une | ID | NAME | AGE | ADDRESS | SALARY |
table. +----+----------+-----+-----------+----------+
INSERT INTO Nom_table (colonne1, colonne2, | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
colonne3 ,... colonneN)] | 2 | Khilan | 25 | Delhi | 1500.00 |
VALUES (valeur1, valeur2, valeur3,...valeurN); | 3 | kaushik | 23 | Kota | 2000.00 |
Si on veut ajouter les valeurs pour tous les champs de la table | 4 | Chaitali | 25 | Mumbai | 6500.00 |
on peut utiliser : | 5 | Hardik | 27 | Bhopal | 8500.00 |
INSERT INTO Nom_table | 7 | Muffy | 24 | Indore | 10000.00 |
VALUES(value1,value2,value3,...valueN); +----+----------+-----+-----------+----------+
Supposant qu’on a créer la table CUSTOMERS avec : Si on veut vide rune table alors:
DELETE FROM CUSTOMERS;
CREATE TABLE CUSTOMERS(
ID INT NOT NULL, - La requête UPDATE :
NAME VARCHAR (20) NOT NULL, On utilise cette requête pour modifier les valeurs d’une ligne.
AGE INT NOT NULL, UPDATE Nom_table
ADDRESS CHAR (25) , SET colonne1= valeur1, colonne2= valeur2....,
SALARY DECIMAL (18, 2), colonneN= valeurN
PRIMARY KEY (ID) WHERE [condition];
); Considérant la table CUSTOMERS suivante :
On peut maintenant ajouter de nouvelles lignes : +----+----------+-----+-----------+----------+
INSERT INTO CUSTOMERS | ID | NAME | AGE | ADDRESS | SALARY |
(ID,NAME,AGE,ADDRESS,SALARY) +----+----------+-----+-----------+----------+
VALUES (1, 'Ramesh', 32, 'Ahmedabad',2000.00 ); | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
INSERT INTO CUSTOMERS | 2 | Khilan | 25 | Delhi | 1500.00 |
(ID,NAME,AGE,ADDRESS,SALARY) | 3 | kaushik | 23 | Kota | 2000.00 |
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 ); | 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
INSERT INTO CUSTOMERS | 6 | Komal | 22 | MP | 4500.00 |
(ID,NAME,AGE,ADDRESS,SALARY) | 7 | Muffy | 24 | Indore | 10000.00 |
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 ); +----+----------+-----+-----------+----------+
INSERT INTO CUSTOMERS UPDATE CUSTOMERS
(ID,NAME,AGE,ADDRESS,SALARY) SET ADDRESS = 'Pune'
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 ); WHERE ID = 6;
INSERT INTO CUSTOMERS +----+----------+-----+-----------+----------+
(ID,NAME,AGE,ADDRESS,SALARY) | ID | NAME | AGE | ADDRESS | SALARY |
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 ); +----+----------+-----+-----------+----------+
INSERT INTO CUSTOMERS | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
(ID,NAME,AGE,ADDRESS,SALARY) | 2 | Khilan | 25 | Delhi | 1500.00 |
VALUES (6, 'Komal', 22, 'MP', 4500.00 ); | 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
Module : Base de données Chap4 : Structured query language SQL (Langage de requête structurée) ©A.BEKADDOUR page 2
ENSSA – Tlemcen @ Département Classe préparatoire 2018-2019 Semestre II
| 5 | Hardik | 27 | Bhopal | 8500.00 | - La clause DISTINCT : On utilise cette clause pour éliminer
| 6 | Komal | 22 | Pune | 4500.00 | les redondances dans le résultat.
| 7 | Muffy | 24 | Indore | 10000.00 | SELECT DISTINCT NAME FROM CUSTOMERS;
+----+----------+-----+-----------+----------+ +----------+
UPDATE CUSTOMERS | NAME |
SET ADDRESS = 'Pune', SALARY = 1000.00; +----------+
+----+----------+-----+---------+---------+ | Ramesh | Dans quelque systèmes tel que
| ID | NAME | AGE | ADDRESS | SALARY | | Khilan | ORACLE la clause DISTINCT est
+----+----------+-----+---------+---------+ | kaushik |
| 1 | Ramesh | 32 | Pune | 1000.00 | remplacée par UNIQUE.
| Chaitali |
| 2 | Khilan | 25 | Pune | 1000.00 | | Hardik |
| 3 | kaushik | 23 | Pune | 1000.00 | | Muffy |
| 4 | Chaitali | 25 | Pune | 1000.00 | +----------+
| 5 | Hardik | 27 | Pune | 1000.00 | - La clause WHERE:
| 6 | Komal | 22 | Pune | 1000.00 |
La clause WHERE est utilisée pour spécifier une condition.
| 7 | Muffy | 24 | Pune | 1000.00 |
SELECT colonne1, colonne2, colonneN
+----+----------+-----+---------+---------+
FROM nom_table
2- Interrogation des données WHERE [condition];
Ce type de requêtes permet de retrouver des données contenue On prenant toujours l’exemple de la table CUSTOMERS
dans les tables (vues) définit et manipulées par le DDL et les SELECT ID, NAME, SALARY
requêtes de manipulation du DML. FROM CUSTOMERS
On distingue trois types de requêtes d’interrogations : WHERE SALARY > 2000;
a- La requête SELECT : +----+----------+----------+
La requête SELECT permet d’extraire les données d’une table | ID | NAME | SALARY |
et renvoie le résultat sous forme d’une table. +----+----------+----------+
SELECT colonne1, colonne2, colonneN | 4 | Chaitali | 6500.00 |
FROM nom_table | 5 | Hardik | 8500.00 |
| 6 | Ramesh | 4500.00 |
Supposant que la table CUSTOMERS contient les données
| 7 | Muffy | 10000.00 |
suivantes : +----+----------+----------+
+----+----------+-----+-----------+----------+ SELECT ID, NAME, SALARY
| ID | NAME | AGE | ADDR | SALARY | FROM CUSTOMERS
+----+----------+-----+-----------+----------+ WHERE NAME = 'Hardik';
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 | +----+----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 | | ID | NAME | SALARY |
| 3 | kaushik | 23 | Kota | 2000.00 | +----+----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 | | 5 | Hardik | 8500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 | +----+----------+----------+
| 6 | Ramesh | 22 | NULL | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
La condition de la clause WHERE peut aussi contenir les
+----+----------+-----+-----------+----------+ opérateurs AND OR NOT.
SELECT ID, NAME, SALARY FROM CUSTOMERS; SELECT ID, NAME, SALARY
FROM CUSTOMERS
On obtient:
WHERE SALARY > 2000 AND age < 25;
+----+----------+----------+
+----+-------+----------+
| ID | NAME | SALARY |
| ID | NAME | SALARY |
+----+----------+----------+
+----+-------+----------+
| 1 | Ramesh | 2000.00 |
| 6 | Ramesh| 4500.00 |
| 2 | Khilan | 1500.00 |
| 7 | Muffy | 10000.00 |
| 3 | kaushik | 2000.00 |
+----+-------+----------+
| 4 | Chaitali | 6500.00 |
SELECT ID, NAME, SALARY
| 5 | Hardik | 8500.00 |
FROM CUSTOMERS
| 6 | Ramesh | 4500.00 |
WHERE SALARY > 2000 OR age < 25;
| 7 | Muffy | 10000.00 |
+----+----------+----------+
+----+----------+----------+
| ID | NAME | SALARY |
SELECT * FROM CUSTOMERS;
+----+----------+----------+
On obtient: | 3 | kaushik | 2000.00 |
+----+----------+-----+-----------+----------+ | 4 | Chaitali | 6500.00 |
| ID | NAME | AGE | ADDR | SALARY | | 5 | Hardik | 8500.00 |
+----+----------+-----+-----------+----------+ | 6 | Ramesh | 4500.00 |
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 | | 7 | Muffy | 10000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 | +----+----------+----------+
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
Il existe plusieurs cas d’utilisation de l’opérateur NOT:
SELECT ID, NAME, SALARY
| 5 | Hardik | 27 | Bhopal | 8500.00 |
FROM CUSTOMERS
| 6 | Ramesh | 22 | NULL | 4500.00 |
WHERE NAME NOT IN ('Chaitali', 'Muffy');
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+----------+
+----+----------+-----+-----------+----------+
| ID | NAME | SALARY |
La requête SELECT peut être utilisée sous forme basique +----+----------+----------+
(comme déjà vue) ou bien en utilisant des clauses. | 1 | Ramesh | 2000.00 |
| 2 | Khilan | 1500.00 |
Module : Base de données Chap4 : Structured query language SQL (Langage de requête structurée) ©A.BEKADDOUR page 3
ENSSA – Tlemcen @ Département Classe préparatoire 2018-2019 Semestre II
| 3 | kaushik | 2000.00 | +----+---------+-----+-----------+---------+
| 5 | Hardik | 8500.00 | | ID | NAME | AGE | ADDR | SALARY |
| 6 | Ramesh | 4500.00 | +----+---------+-----+-----------+---------+
+----+----------+----------+ | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
SELECT ID, NAME, SALARY | 2 | Khilan | 25 | Delhi | 1500.00 |
FROM CUSTOMERS +----+---------+-----+-----------+---------+
WHERE ADDR IS NOT NULL; - La clause ORDER BY: Pour ordonner le résultat.
+----+----------+----------+ SELECT * FROM CUSTOMERS
| ID | NAME | SALARY | ORDER BY NAME, SALARY;
+----+----------+----------+ +----+----------+-----+-----------+----------+
| 1 | Ramesh | 2000.00 | | ID | NAME | AGE | ADDR | SALARY |
| 2 | Khilan | 1500.00 | +----+----------+-----+-----------+----------+
| 3 | kaushik | 2000.00 | | 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 4 | Chaitali | 6500.00 | | 5 | Hardik | 27 | Bhopal | 8500.00 |
| 5 | Hardik | 8500.00 | | 3 | kaushik | 23 | Kota | 2000.00 |
| 7 | Muffy | 10000.00 | | 2 | Khilan | 25 | Delhi | 1500.00 |
+----+----------+----------+ | 7 | Muffy | 24 | Indore | 10000.00 |
SELECT ID, NAME, SALARY | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
FROM CUSTOMERS | 6 | Ramesh | 22 | NULL | 4500.00 |
WHERE NAME NOT LIKE ‘%m%’; +----+----------+-----+-----------+----------+
+----+----------+----------+ On peut aussi ordonner par ordre décroissant DESC ou
| ID | NAME | SALARY | croissant ASC.
+----+----------+----------+ SELECT * FROM CUSTOMERS ORDER BY NAME DESC;
| 2 | Khilan | 1500.00 | +----+----------+-----+-----------+----------+
| 3 | kaushik | 2000.00 | | ID | NAME | AGE | ADDR | SALARY |
| 4 | Chaitali | 6500.00 | +----+----------+-----+-----------+----------+
| 5 | Hardik | 8500.00 | | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
+----+----------+----------+ | 6 | Ramesh | 22 | NULL | 4500.00 |
Remarque : On peut aussi utiliser le caractère _ au lieu du | 7 | Muffy | 24 | Indore | 10000.00 |
caractère % | 2 | Khilan | 25 | Delhi | 1500.00 |
SELECT ID, NAME, SALARY | 3 | kaushik | 23 | Kota | 2000.00 |
FROM CUSTOMERS | 5 | Hardik | 27 | Bhopal | 8500.00 |
WHERE AGE NOT BETWEEN 25 AND 27; | 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+----------+ +----+----------+-----+-----------+----------+
| ID | NAME | SALARY | On peut utiliser la clause DISTINCT avec la clause ORDER
+----+----------+----------+ BY
| 1 | Ramesh | 2000.00 | Supposant que la table CUSTOMERS contient les données
| 3 | kaushik | 2000.00 | suivantes :
| 6 | Ramesh | 4500.00 | +----+----------+-----+-----------+----------+
| 7 | Muffy | 10000.00 | | ID | NAME | AGE | ADDR | SALARY |
+----+----------+----------+ +----+----------+-----+-----------+----------+
En plus de la table CUSTOMERS, Supposant maintenant que nous | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
avons la table ORDER suivante : | 2 | Khilan | 25 | Delhi | 1500.00 |
+----------+------------+-------------+ | 3 | kaushik | 23 | Kota | 2000.00 |
| ORDER_ID | CUSTUMER_ID| DATE | | 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----------+------------+-------------+ | 5 | Hardik | 27 | Bhopal | 8500.00 |
| 1 | 1 | 18/04/2016 | | 6 | Komal | 22 | MP | 4500.00 |
| 2 | 5 | 12/12/2016 | | 7 | Muffy | 24 | Indore | 10000.00 |
| 3 | 4 | 18/04/2014 | +----+----------+-----+-----------+----------+
| 4 | 7 | 01/10/2015 | SELECT DISTINCT SALARY FROM CUSTOMERS
+----------+------------+-------------+ ORDER BY SALARY;
SELECT ID, NAME, SALARY +----------+
FROM CUSTOMERS | SALARY |
WHERE NOT EXISTS ( +----------+
SELECT * Sous requête | 1500.00 |
FROM ORDER | 2000.00 |
WHERE CUSTOMERS.ID=ORDER.CUSTUMER_ID | 4500.00 |
); | 6500.00 |
+----+----------+----------+ | 8500.00 |
| ID | NAME | SALARY | | 10000.00 |
+----+----------+----------+ +----------+
| 2 | Khilan | 1500.00 | - La clause GROUP BY: Pour grouper les données du résultat.
| 3 | kaushik | 2000.00 | Supposant que la table CUSTOMERS contient les données
| 6 | Ramesh | 4500.00 | suivantes :
+----+----------+----------+ +----+----------+-----+-----------+----------+
- La clause LIMIT: pour le nombre de lignes résultats. | ID | NAME | AGE | ADDR | SALARY |
SELECT * FROM CUSTOMERS LIMIT 2; +----+----------+-----+-----------+----------+
Ou encore: SELECT TOP 2 * FROM CUSTOMERS; | 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
Ou: SELECT * FROM CUSTOMERS WHERE ROWNUM <= 2; | 2 | Ramesh | 25 | Delhi | 1500.00 |

Module : Base de données Chap4 : Structured query language SQL (Langage de requête structurée) ©A.BEKADDOUR page 4
ENSSA – Tlemcen @ Département Classe préparatoire 2018-2019 Semestre II
| 3 | kaushik | 23 | Kota | 2000.00 | | 7 | Muffy | 24 | Indore | 10000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 | +----+----------+-----+-----------+----------+
| 5 | Hardik | 27 | Bhopal | 8500.00 | SELECT NAME, SUM(SALARY) FROM CUSTOMERS
| 6 | Komal | 22 | MP | 4500.00 | GROUP BY NAME
| 7 | Muffy | 24 | Indore | 10000.00 | HAVING SUM(SALARY) > 9000;
+----+----------+-----+-----------+----------+ La fonction SUM permet de calculer la somme des valeurs de la
SELECT NAME, SUM(SALARY) FROM CUSTOMERS colonne spécifiée.
GROUP BY NAME; +---------+-------------+
+---------+-------------+ | NAME | SUM(SALARY) |
| NAME | SUM(SALARY) | +---------+-------------+
+---------+-------------+ | Muffy | 10000.00 |
| Hardik | 8500.00 | +---------+-------------+
| kaushik | 8500.00 | SELECT NAME, COUNT(SALARY) FROM CUSTOMERS
| Komal | 4500.00 | GROUP BY NAME
| Muffy | 10000.00 | HAVING COUNT(SALARY) >= 2 ;
| Ramesh | 3500.00 | La fonction COUNT permet de compter le nombre de ligne de
+---------+-------------+
la colonne spécifiée.
La clause GROUP BY permet de filtrer par groupe alors que la +---------+-------------+
clause WHERE permet de filtrer par ligne. | NAME |COUNT(SALARY)|
- La clause CASE WHEN: Similaire à si/ sinon +---------+-------------+
Supposant que la table CUSTOMERS | Ramesh | 2 |
+----+----------+-----+-----------+----------+ | kaushik | 2 |
| ID | NAME | AGE | ADDRESS | SALARY | +---------+-------------+
+----+----------+-----+-----------+----------+ SELECT NAME, AVG (SALARY) FROM CUSTOMERS
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 | GROUP BY NAME
| 7 | Muffy | 24 | Indore | 10000.00 | HAVING AVG(SALARY) BETWEEN 3000 AND 4500;
| 6 | Komal | 22 | MP | 4500.00 | La fonction AVG permet calculer de la moyenne des valeurs de
| 2 | Khilan | 25 | Delhi | 1500.00 | la colonne spécifiée.
| 3 | kaushik | 23 | Kota | 2000.00 | +---------+-------------+
| 5 | Hardik | 27 | Bhopal | 8500.00 | | NAME | AVG(SALARY)|
| 4 | Chaitali | 25 | Mumbai | 6500.00 | +---------+-------------+
+----+----------+-----+-----------+----------+ | kaushik | 4250.00 |
SELECT ID, +---------+-------------+
NAME, SELECT NAME, AVG (SALARY) FROM CUSTOMERS
Age, GROUP BY NAME
CASE WHEN Age=27 THEN 'Age bon' HAVING AVG(SALARY) = MIN (SALARY);
WHEN Age>24 THEN 'Age bien' La fonction MIN permet de calculer le minimum des valeurs de
ELSE 'Age loin' END la colonne spécifiée (De même pour MAX).
, +---------+-------------+
ADDRESS, | NAME | AVG(SALARY) |
SALARY +---------+-------------+
FROM CUSTOMERS; | Ramesh | 1500.00 |
+----+---------+----+----------+----------+--------+
| ID | NAME |AGE |CASE | ADDRESS | SALARY
+---------+-------------+
| b- Les requête à plusieurs tables :
+----+---------+----+----------+----------+--------+ Ce type de requête est utilisé pour les opérations nécessitant
| 1 | Ramesh | 32 |Age bien |Ahmedabad | 2000.00 | plusieurs tables (union, intersection, différence, jointure).
| 7 | Muffy | 24 |Age loin |Indore |10000.00 |
| 6 | Komal | 22 |Age loin |MP | 4500.00 |
- La clause UNION : union de deux tables.
| 2 | Khilan | 25 |Age bien |Delhi | 1500.00 | Supposant les deux tables magasin 1 et magasin 2 :
| 3 | kaushik | 23 |Age loin |Kota | 2000.00 | Magasin1
| 5 | Hardik | 27 |Age bon |Bhopal | 8500.00 |
| 4 | Chaitali| 25 |Age bien |Mumbai | 6500.00 | prenom nom ville date_naiss total_achat
+----+---------+----+----------+---------+---------+ Léon Dupuis Paris 1983-03-06 135
- La clause HAVING: La clause HAVING en SQL est presque
similaire à WHERE à la seule différence que HAVING permet Marie Bernard Paris 1993-07-03 75
de sélectionner en utilisant des fonctions d’agrégation telles que Sophie Dupond Marseille 1986-02-22 27
SUM(), COUNT(), AVG(), MIN() ou MAX().
Marcel Martin Paris 1976-11-24 39
La clause HAVING est souvent utilisée avec GROUP BY
malgré que ce n’est pas obligatoire. Magasin2
Supposant que la table CUSTOMERS : prenom nom ville date_naiss total_achat
+----+----------+-----+-----------+----------+
Marion Leroy Lyon 1982-10-27 285
| ID | NAME | AGE | ADDR | SALARY | Paul Moreau Lyon 1976-04-19 133
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 | Marie Bernard Paris 1993-07-03 75
| 2 | Ramesh | 25 | Delhi | 1500.00 | Marcel Martin Paris 1976-11-24 39
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
Module : Base de données Chap4 : Structured query language SQL (Langage de requête structurée) ©A.BEKADDOUR page 5
ENSSA – Tlemcen @ Département Classe préparatoire 2018-2019 Semestre II
SELECT * FROM Magasin1 commande
UNION
SELECT * FROM Magasin2; utilisateur_id date_achat num_factur prix_total
prenom nom ville date_naiss total_achat 1 2013-01-23 A00103 203.14
Léon Dupuis Paris 1983-03-06 135 1 2013-02-14 A00104 124.00
Marie Bernard Paris 1993-07-03 75 5 2013-02-17 A00105 149.45
Sophie Dupond Marseille 1986-02-22 27 - INNER JOIN:
SELECT id, prenom, nom, date_achat, num_factur,
Marcel Martin Paris 1976-11-24 39 prix_total
FROM utilisateur
Marie Leroy Lyon 1982-10-27 285 INNER JOIN commande ON utilisateur.id =
Paul Moreay Lyon 1976-04-19 133 commande.utilisateur_id;
- La clause INTERSECT : Intersection de deux tables. id prenom nom date_achat num_factur prix_total
SELECT * FROM Magasin1 1 Aimée Marechal 2013-01-23 A00103 203.14
INTERSECT
SELECT * FROM Magasin2; 1 Aimée Marechal 2013-02-14 A00104 124.00
nom prenom ville date_naiss total_achat - CROSS JOIN: Le produit cartésien.
SELECT utilisateur.id,prenom, nom,
Marie Bernard Paris 1993-07-03 75 commande.utilisateur_id,date_achat
Marcel Martin Paris 1976-11-24 39 FROM utilisateur
CROSS JOIN commande ;
- La clause EXCEPT: Différence de deux tables. Ou bien encore:
SELECT prenom, nom FROM Magasin1 SELECT utilisateur.id,prenom, nom,
EXCEPT commande.id,date_achat
SELECT prenom, nom FROM Magasin2; FROM utilisateur,commande ;
prenom nom ville date_naiss total_achat id prenom nom utilisateur_id date_achat
Léon Dupuis Paris 1983-03-06 135 1 Aimée Marechal 1 2013-01-23
Sophie Dupond Marseille 1986-02-22 27 1 Aimée Marechal 1 2013-02-14
1 Aimée Marechal 5 2013-02-17
2 Esmée Lefort 1 2013-01-23
2 Esmée Lefort 1 2013-02-14
UNINON INTERSECT EXCEPT
- La clause JOIN: il existe plusieurs manières pour réaliser une 2 Esmée Lefort 5 2013-02-17
jointure : 3 Marine Prevost 1 2013-01-23
3 Marine Prevost 1 2013-02-14
3 Marine Prevost 5 2013-02-17
4 Luc Rolland 1 2013-01-23
INNER JOIN LEFT JOIN RIGHT JOIN
4 Luc Rolland 1 2013-02-14
4 Luc Rolland 5 2013-02-17
- LEFT JOIN (LEFT OUTER JOIN): permet de lister tous
les résultats de la première table de gauche (left = gauche)
LEFT JOIN SANS INTERSECT RIGHT JOIN SANS INTERSECT même s’il n’y a pas de correspondance dans la deuxième tables.
S’il n’y a pas de correspondance les colonnes de la deuxième
table auront toutes NULL.
SELECT id, prenom,NOM,date_achat,utilisateur_id
FROM utilisateur
LEFT JOIN commande ON utilisateur.id =
commande.utilisateur_id ;
FULL JOIN FULL JOIN SANS INTERSECT
Et CROSS JOIN (voir l’exemple). id prenom Nom date_achat utilisateur_id
1 Aimée Marechal 2013-01-23 1
Soit les deux tables:
1 Aimée Marechal 2013-02-14 1
utilisateur
id prenom nom email ville 2 Esmée Lefort NULL NULL
1 Aimée Marechal marechal@example.com Paris 3 Marine Prevost NULL NULL
2 Esmée Lefort lefort@example.com Lyon 4 Luc Rolland NULL NULL
- LEFT JOIN (sans intersection): c’est une jointure gauche
3 Marine Prevost prevost@example.com Lille en éliminant les cas d’intersection.
4 Luc Rolland lucrolland@example.com Marseille SELECT id, prenom,NOM,date_achat,utilisateur_id
Module : Base de données Chap4 : Structured query language SQL (Langage de requête structurée) ©A.BEKADDOUR page 6
ENSSA – Tlemcen @ Département Classe préparatoire 2018-2019 Semestre II
FROM utilisateur
LEFT JOIN commande ON utilisateur.id =
id prenom nom utilisateur_id date_achat
commande.utilisateur_id 2 Esmée Lefort NULL NULL
WHERE utilisateur_id IS NULL ;
3 Marine Prevost NULL NULL
id prenom Nom date_achat utilisateur_id
4 Luc Rolland NULL NULL
2 Esmée Lefort NULL NULL
NULL NULL NULL 5 2013-02-17
3 Marine Prevost NULL NULL
- SELF JOIN : correspond à une jointure d’une table avec
4 Luc Rolland NULL NULL elle-même.
- RIGHT JOIN (RIGHT OUTER JOIN): permet de lister SELECT a.id, a.prenom, a.nom, a.ville,
tous les résultats de la deuxième table de droite (right = droite) b.prenom, b.nom, b.ville
FROM utilisateur a, utilisateur b
même s’il n’y a pas de correspondance dans la première table. WHERE a.ville = b.ville AND a.id <> b.id;
S’il n’y a pas de correspondance les colonnes de la première
table auront toutes NULL. id prenom nom ville prenom nom ville
SELECT id, prenom,NOM,date_achat,utilisateur_id 2 Esmée Lefort Lyon Marine Prevost Lille
FROM utilisateur
RIGHT JOIN commande ON utilisateur.id = 3 Marine Prevost Lille Esmée Lefort Lyon
commande.utilisateur_id ; - NATURAL JOIN : Permet de faire une jointure naturelle
id
prenom Nom date_achat utilisateur_id entre 2 tables. L’avantage d’un NATURAL JOIN c’est qu’il n’y
a pas besoin d’utiliser la clause ON.
1 Aimée Marechal 2013-01-23 1
Soit les deux tables :
1 Aimée Marechal 2013-02-14 1 utilisateur:
NULL NULL NULL 2013-02-17 5 user_id user_prenom user_ville pays_id
- RIGHT JOIN (sans intersection): c’est une jointure gauche 1 Jérémie Paris 1
en éliminant les cas d’intersection.
SELECT id, prenom,NOM,date_achat,utilisateur_id 2 Damien Montréal 2
FROM utilisateur 3 Sophie Marseille NULL
RIGHT JOIN commande ON utilisateur.id =
commande.utilisateur_id 4 Yann Lille 9999
WHERE id IS NULL ; 5 Léa Paris 1
id prenom Nom date_achat utilisateur_id pays:
NULL NULL NULL 2013-02-17 5 pays_id pays_nom
- FULL JOIN (FULL OUTER JOIN): permet de combiner 1 France
les résultats de 2 tables, les associer entre eux grâce à une
condition et remplir avec des valeurs NULL si la condition n’est 2 Canada
pas respectée. 3 Belgique
SELECT id, prenom, nom, utilisateur_id,
date_achat 4 Suisse
FROM utilisateur Remarquer que utilisateur.pays_id et pays.id ont le même nom
FULL JOIN commande ON utilisateur.id = et le même type (sinon on ne poura pas faire une jointure
commande.utilisateur_id ; naturelle).
id
prenom nom utilisateur_id date_achat
1 Aimée Marechal 1 2013-01-23 pays_id user_id user_prenom user_ville pays_nom
1 Aimée Marechal 1 2013-02-14 1 1 Jérémie Paris France
2 Esmée Lefort NULL NULL 2 2 Damien Montréal Canada
3 Marine Prevost NULL NULL NULL 3 Sophie Marseille NULL
4 Luc Rolland NULL NULL 9999 4 Yann Lille NULL
NULL NULL NULL 5 2013-02-17 1 5 Léa Paris France
- FULL JOIN (sans intersection): c’est une jointure b- Les fonctions :
complète en éliminant les cas d’intersection. Le langage SQL contient des fonctions permettant de faire des
SELECT id, prenom, nom, utilisateur_id, calculs (traitement) sur les données. On distingue trois types de
date_achat fonctions.
FROM utilisateur - Les fonctions d’agrégation : Ces fonctions retournent une
FULL JOIN commande ON utilisateur.id = seule valeur calculée à partir de plusieurs valeurs dans une
commande.utilisateur_id
colonne. Parmi ces fonctions AVG() - retourne la moyenne.
WHERE utilisateur_id IS NULL AND id IS NULL;
 COUNT() – retourne le nombre de lignes.
 FIRST() – retourne la première valeur.
 LAST() – retourne la dernière valeur.
 MAX() – retourne la plus grande valeur.
 MIN() – retourne la plus petite valeur.
Module : Base de données Chap4 : Structured query language SQL (Langage de requête structurée) ©A.BEKADDOUR page 7
ENSSA – Tlemcen @ Département Classe préparatoire 2018-2019 Semestre II
 SUM() – retourne la somme. - SELECT * FROM table WHERE colonne LIKE modele;
- Les fonctions scalaires : Ces fonctions retournent une seule - SELECT * FROM table WHERE nom_colonne IS NULL;
valeur en se basant sur une seule valeur en entrée. Parmi ces - SELECT * FROM table WHERE nom_colonne IS NOT
NULL;
fonctions :
- SELECT colonne1, fonction(colonne2)FROM table
 UCASE() – convertit un champs en majuscule. GROUP BY colonne1
 LCASE() – convertit un champs en minuscule. - SELECT colonne1, fonction(colonne2)FROM
 MID() – Extraire des caractères à partir d’un champs. nom_table WHERE condition GROUP BY colonne1
 LEN() – retourne la longueur d’un champs. HAVING condition;
UCASE, LCASE,MID et LEN s’applique sur des champs de - SELECT colonne1, colonne2, colonne3, … FROM
type chaine de caractères. table ORDER BY colonne1 DESC|ASC, colonne2
 ROUND() - Arrondit un champ numérique au nombre de DESC| ASC, colone3 DESC|ASC, … ;
décimales spécifié - SELECT nom_colonnes FROM table LIMIT
nombre_max_de_ligne_resultat ;
 NOW() - Renvoie la date et l'heure actuelles du système.
- CASE
 FORMAT() - Formate la façon dont un champ doit être WHEN condition1 THEN resultat1
affiché. WHEN condition1 THEN resultat2
Soit la table produit. WHEN condition1 THEN resultat3
ProductID ProductName SupplierID CategoryID Unit Price ELSE resultat4
END
1 Table 1 1 100 18
- SELECT * FROM table1 UNION SELECT * FROM
2 Chaise 1 1 24 - 80 19 table2;
4 Porte 2 2 48 - 60 21.35 - SELECT * FROM table1 INTERSECT SELECT * FROM
SELECT UCASE(ProductName) AS Product, table2;
MID(ProductName,1,3)AS Pro, LEN(Productname) AS - SELECT * FROM table1 EXCEPT SELECT * FROM
L, ROUND(Price,1) AS R, NOW(), table2;
FORMAT(Now(),'YYYY-MM-DD') AS F FROM produit; - SELECT * FROM table1 INNER JOIN table2 ON
table1.id = table2.CS_id
Product Pro L R NOW( ) F Ou encore: SELECT * FROM table1 INNER JOIN
TABLE Tab 5 18 1/3/2017 1:36:03 PM 2017-03-01 table2 WHERE table1.id = table2.CS_id;
CHAISE Cha 6 19 1/3/2017 1:36:03 PM 2017-03-01 - SELECT * FROM table1 CROSS JOIN table2
Ou encore: SELECT * FROM table1, table2 ;
PORTE Por 5 21.3 1/3/2017 1:36:03 PM 2017-03-01 - SELECT * FROM table1 LEFT JOIN table2 ON
IV- Résumé de prototype de requêtes table1.id = table2.CS_id
- CREATE DATABASE NOM_DE_LA_BASE; Ou encore: SELECT * FROM table1 LEFT OUTER
- DROP DATABASE NOM_DE_LA_BASE ; JOIN table2 ON table1.id = table2.CS_id;
- CREATE TABLE Nom_Table( colonne1 datatype, - SELECT * FROM table1 RIGHT JOIN table2 ON
colonne2 datatype, table1.id = table2.CS_id
..... Ou encore: SELECT * FROM table1 RIGHT OUTER
colonneN datatype, JOIN table2 ON table1.id = table2.CS_id;
PRIMARY KEY( un ou plusieurs colonnes ) - SELECT * FROM table1 FULL JOIN table2 ON
); table1.id = table2.CS_id;
- DROP TABLE Nom_Table; Ou encore: SELECT * FROM table1 FULL OUTER
- ALTER TABLE Nom_Table ADD Nom_col Type_donnee; JOIN table2 ON table1.id = table2.CS_id;
- ALTER TABLE Nom_Table DROP COLUMN Nom_col; - SELECT * FROM table1 NATURAL JOIN table2;
- ALTER TABLE Nom_Table MODIFY COLUMN Nom_col;
- CREATE VIEW Nom_de_vue AS
SELECT nom_de_colonne (s)
FROM Nom_table
WHERE condition ;
- INSERT INTO Nom_table (colonne1, colonne2,
colonne3 ,... colonneN)]
VALUES (valeur1, valeur2, valeur3,...valeurN);
- DELETE FROM Nom_table WHERE [condition];
- UPDATE Nom_table SET colonne1= valeur1,
colonne2= valeur2...., colonneN= valeurN
WHERE [condition];
- SELECT colonne1, colonne2, colonneN
FROM nom_table ;
- SELECT DISTINCT ma_colonne FROM nom_table;
- SELECT nom_colonnes FROM nom_table WHERE
condition;
- SELECT nom_colonnes FROM nom_table WHERE
condition1 AND condition2;
- SELECT nom_colonnes FROM nom_table WHERE
condition1 OR condition2;
- SELECT nom_colonne FROM table WHERE
nom_colonne IN ( valeur1, valeur2, valeur3,
... ) ;
- SELECT * FROM table WHERE nom_colonne BETWEEN
valeur1 AND valeur2;
Module : Base de données Chap4 : Structured query language SQL (Langage de requête structurée) ©A.BEKADDOUR page 8