ENSSA Tlemcen @ Dpartement Informatique

I- Dfinition
http://sql.sh/cours

http://www.w3schools.com/sql/default.asp

SQL est un langage qui permet au programmeur de formuler

des expressions dinterrogation, de mise jour et de
restructuration dune base de donnes. Ces oprations
ncessitent une structure de donnes sur laquelle elles vont tre
appliques. La seule structure de donnes utilise est la table.
Une table consiste en un certains nombre dattributs (colonnes).
Pour chaque attribut on dfinit son type. Le tableau suivant
rsume les types de base :
Chaine de caractre de longueur
char(n)
constante gale n octets,
Max=255 et valeur par dfaut=1.
chaine de caractre de longueur
varchar(n)
variable. Max n= 2000.
Un text (255 caractres max).
text
decimal(length,fraction) Length : le nombre total des
chiffres. Fraction : la longueur de la
partie fractionnelle.
Length 4, fraction 2: 99.99
Length 10, fraction 0: 9999999999
Length 8, fraction 3: 99999.999
Length 8, fraction -3: 99999000
Nombre entier (pas de partie
integer(length)
fractionnelle).
Nombre virgule flottante avec une
float
longueur = 38.
Intervalle (01-Jan-4712 BC, 31date
Dec-4712 AD). Format par dfaut
dd-mmm-yy.
On distingue trois types de tables :
- Tables de base : Ce sont les tables du modle logique de
donnes.
- Tables drives : Ce sont des tables obtenues partir des
tables de base (aprs lapplication dune requte). Elles peuvent
tre stockes dans la base.
- Tables virtuelles (vue): Une vue se compose de lignes et de
colonnes, tout comme une table. La diffrence entre une vue et
une table est que les vues sont obtenues partir d'autres tables
(ou vues) on appliquant des requtes SQL, et ne contiennent pas
les donnes eux-mmes. Si les donnes changent dans la table
partir de laquelle on obtenue la vue, le mme changement se
reflte dans la vue. Une vue peut tre obtenue partir d'une
seule table ou plusieurs tables. Elle peut galement tre obtenue
d'une autre vue.
Le langage SQL se compose de quatre types de requtes :
requtes de dfinition de donnes DDL et requtes de
manipulation de donnes DML, requtes de contrle de
donnes DCL et requtes de contrle de transaction TCL.
II- Requtes de dfinition de donnes
Ce type de requtes permet la cration, la suppression et le
changement des structures de la base (base de donnes, tables,
vues).
1- Dfinir une base de donnes :
- La cration dune base de donnes se traduit par la requte
SQL suivante :
CREATE DATABASE NOM_DE_LA_BASE;
- La suppression dune base de donnes :
DROP DATABASE NOM_DE_LA_BASE ;
- La slection dune base de donnes
USE NOM_DE_LA_BASE;
- Visionner les bases de donnes disponibles
SHOW DATABASES;

Module : Base de donnes

2016-2017 Semestre II
Exemple :
CREATE
CREATE
CREATE
DROP
CREATE

DATABASE
DATABASE
DATABASE
DATABASE
DATABASE

hmida;
ali;
informatique;
hmida ;
ESSATlemcen ;

SHOW DATABASES;
+--------------------+
| Database
|
+--------------------+
| ali
|
| informatique
|
| ESSATlemcen
|
+--------------------+

2- Dfinir une table:

- La cration dune table se traduit par la requte SQL suivante :
CREATE TABLE Nom_Table(
colonne1 datatype,
colonne2 datatype,
colonne3 datatype,
.....
colonneN datatype,
PRIMARY KEY( un ou plusieurs colonnes )
);

Exemple :
CREATE TABLE CUSTOMERS(
ID
INT
NOT NULL,
NAME VARCHAR (20)
NOT NULL,
AGE INT
NOT NULL,
ADDRESS CHAR (25) ,
SALARY
DECIMAL (18, 2),
PRIMARY KEY (ID)
);
+-------+-----------+----+-----+--------+-----+
| Field | Type
|Null| Key | Default|Extra|
+-------+-----------+----+-----+--------+-----+
| ID
|int(11)
| NO | PRI |
|
|
| NAME |varchar(20)| NO |
|
|
|
| AGE
|int(11)
| NO |
|
|
|
| ADDR |char(25)
| YES|
| NULL
|
|
| SALARY |decimal(18,2)|YES |

NULL

+-------+-----------+----+-----+--------+-----+

- la suppression dune table :

DROP TABLE Nom_Table;

- la Modification de la structure dune table : en ajoutant ou en

supprimant ou en changeant des colonnes.
ALTER TABLE Nom_Table ADD Nom_col Type_donnee;
ALTER TABLE Nom_Table DROP COLUMN Nom_col;
ALTER TABLE Nom_Table MODIFY COLUMN Nom_col;

Exemple :
ALTER TABLE CUSTOMERS MODIFY NAME varchar(30);
ALTER TABLE CUSTOMERS DROP COLUMN ADDR;
ALTER TABLE CUSTOMERS ADD ADDR char(20);
+-------+-----------+----+-----+--------+-----+
| Field | Type
|Null| Key | Default|Extra|
+-------+-----------+----+-----+--------+-----+
| ID
|int(11)
| NO | PRI |
|
|
| NAME |varchar(30)| NO |
|
|
|
| AGE
|int(11)
| NO |
|
|
|
| ADDR |char(20)
| YES|
| NULL
|
|
| SALARY |decimal(18,2)|YES |

NULL

+-------+-----------+----+-----+--------+-----+

3- Dfinir une vue:

- La cration dune vue se traduit par la requte SQL suivante :
CREATE
VIEW
Nom_de_vue
SELECT nom_de_colonne (s)
FROM Nom_table
WHERE condition ;

AS

Requte

Exemple:
Chap4 : Structured query language SQL (Langage de requte structure) A.BEKADDOUR page 1

ENSSA Tlemcen @ Dpartement Informatique

Supposant que la table CUSTOMERS contient les donnes
suivantes :
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDR
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
+----+----------+-----+-----------+----------+
CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM CUSTOMERS;

+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDRESS
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 6 | Komal
| 22 | MP
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+

- La requte DELETE :
On utilise cette requte pour supprimer des lignes dune table.

La vue sera:
+----------+-----+
| name
| age |
+----------+-----+
| Ramesh
| 32 |
| Khilan
| 25 |
| kaushik | 23 |
+----------+-----+

- la suppression dune vue :

DROP VIEW view_name;

III- Requtes de manipulation de donnes

Ce type de requtes permet linterrogation et la modification
des donnes.
1- Manipulation des donnes
Ce type de requtes permet dinsrer, de supprimer ou de
modifier des donnes contenus dans les tables (vues) dfinit par
le DDL.
- La requte INSERT :
On utilise cette requte pour ajouter des nouvelles lignes une
table.
INSERT INTO Nom_table (colonne1, colonne2,
colonne3 ,... colonneN)]
VALUES (valeur1, valeur2, valeur3,...valeurN);

Si on veut ajouter les valeurs pour tous les champs de la table

on peut utiliser :
INSERT INTO Nom_table
VALUES(value1,value2,value3,...valueN);
Supposant quon a crer la table CUSTOMERS avec :
CREATE TABLE CUSTOMERS(
ID
INT
NOT NULL,
NAME VARCHAR (20)
NOT NULL,
AGE INT
NOT NULL,
ADDRESS CHAR (25) ,
SALARY
DECIMAL (18, 2),
PRIMARY KEY (ID)
);

On peut maintenant ajouter de nouvelles lignes :

INSERT INTO CUSTOMERS
(ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad',2000.00 );
INSERT INTO CUSTOMERS
(ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );
INSERT INTO CUSTOMERS
(ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );
INSERT INTO CUSTOMERS
(ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );
INSERT INTO CUSTOMERS
(ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );
INSERT INTO CUSTOMERS
(ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Komal', 22, 'MP', 4500.00 );

Module : Base de donnes

2016-2017 Semestre II
La table devient :

DELETE FROM Nom_table

WHERE [condition];
Prenant le cas de la table CUSTOMERS
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDRESS
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 6 | Komal
| 22 | MP
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+
DELETE FROM CUSTOMERS
WHERE ID = 6;
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDRESS
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+

Si on veut vide rune table alors:

DELETE FROM CUSTOMERS;

- La requte UPDATE :
On utilise cette requte pour modifier les valeurs dune ligne.
UPDATE Nom_table
SET colonne1= valeur1, colonne2= valeur2....,
colonneN= valeurN
WHERE [condition];
Considrant la table CUSTOMERS suivante :
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDRESS
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 6 | Komal
| 22 | MP
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+
UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDRESS
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |

Chap4 : Structured query language SQL (Langage de requte structure) A.BEKADDOUR page 2

ENSSA Tlemcen @ Dpartement Informatique

| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 6 | Komal
| 22 | Pune
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+
UPDATE CUSTOMERS
SET ADDRESS = 'Pune', SALARY = 1000.00;
+----+----------+-----+---------+---------+
| ID | NAME
| AGE | ADDRESS | SALARY |
+----+----------+-----+---------+---------+
| 1 | Ramesh
| 32 | Pune
| 1000.00 |
| 2 | Khilan
| 25 | Pune
| 1000.00 |
| 3 | kaushik | 23 | Pune
| 1000.00 |
| 4 | Chaitali | 25 | Pune
| 1000.00 |
| 5 | Hardik
| 27 | Pune
| 1000.00 |
| 6 | Komal
| 22 | Pune
| 1000.00 |
| 7 | Muffy
| 24 | Pune
| 1000.00 |
+----+----------+-----+---------+---------+

2- Interrogation des donnes

Ce type de requtes permet de retrouver des donnes contenue
dans les tables (vues) dfinit et manipules par le DDL et les
requtes de manipulation du DML.
On distingue trois types de requtes dinterrogations :
a- La requte SELECT :
La requte SELECT permet dextraire les donnes dune table
et renvoie le rsultat sous forme dune table.
SELECT colonne1, colonne2, colonneN
FROM nom_table
Supposant que la table CUSTOMERS contient les donnes

suivantes :
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDR
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 6 | Ramesh
| 22 | NULL
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+
SELECT ID, NAME, SALARY FROM CUSTOMERS;

On obtient:
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 1 | Ramesh
| 2000.00 |
| 2 | Khilan
| 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik
| 8500.00 |
| 6 | Ramesh
| 4500.00 |
| 7 | Muffy
| 10000.00 |
+----+----------+----------+
SELECT * FROM CUSTOMERS;

On obtient:
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDR
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 6 | Ramesh
| 22 | NULL
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+

La requte SELECT peut tre utilise sous forme basique

(comme dj vue) ou bien en utilisant des clauses.
Module : Base de donnes

2016-2017 Semestre II
- La clause DISTINCT : On utilise cette clause pour liminer
les redondances dans le rsultat.
SELECT DISTINCT NAME FROM CUSTOMERS;
+----------+
| NAME
|
+----------+
Dans quelque systmes tel que
| Ramesh
|
| Khilan
|
ORACLE la clause DISTINCT est
| kaushik |
remplace par UNIQUE.
| Chaitali |
| Hardik
|
| Muffy
|
+----------+

- La clause WHERE:
La clause WHERE est utilise pour spcifier une condition.
SELECT colonne1, colonne2, colonneN
FROM nom_table
WHERE [condition];
On prenant toujours lexemple de la table CUSTOMERS
SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000;
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 4 | Chaitali | 6500.00 |
| 5 | Hardik
| 8500.00 |
| 6 | Ramesh
| 4500.00 |
| 7 | Muffy
| 10000.00 |
+----+----------+----------+
SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE NAME = 'Hardik';
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 5 | Hardik
| 8500.00 |
+----+----------+----------+

La condition de la clause WHERE peut aussi contenir les

oprateurs AND OR NOT.
SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;
+----+-------+----------+
| ID | NAME | SALARY
|
+----+-------+----------+
| 6 | Ramesh| 4500.00 |
| 7 | Muffy | 10000.00 |
+----+-------+----------+
SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik
| 8500.00 |
| 6 | Ramesh
| 4500.00 |
| 7 | Muffy
| 10000.00 |
+----+----------+----------+

Il existe plusieurs cas dutilisation de loprateur NOT:

SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE NAME NOT IN ('Chaitali', 'Muffy');
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 1 | Ramesh
| 2000.00 |
| 2 | Khilan
| 1500.00 |

Chap4 : Structured query language SQL (Langage de requte structure) A.BEKADDOUR page 3

ENSSA Tlemcen @ Dpartement Informatique

| 3 | kaushik | 2000.00 |
| 5 | Hardik
| 8500.00 |
| 6 | Ramesh
| 4500.00 |
+----+----------+----------+
SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE ADDR IS NOT NULL;
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 1 | Ramesh
| 2000.00 |
| 2 | Khilan
| 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik
| 8500.00 |
| 7 | Muffy
| 10000.00 |
+----+----------+----------+
SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE NAME NOT LIKE %m%;
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 2 | Khilan
| 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik
| 8500.00 |
+----+----------+----------+

Remarque : On peut aussi utiliser le caractre _ au lieu du

caractre %
SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE AGE NOT BETWEEN 25 AND 27;
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 1 | Ramesh
| 2000.00 |
| 3 | kaushik | 2000.00 |
| 6 | Ramesh
| 4500.00 |
| 7 | Muffy
| 10000.00 |
+----+----------+----------+
En plus de la table CUSTOMERS, Supposant maintenant que nous

avons la table ORDER suivante :

+----------+------------+-------------+
| ORDER_ID | CUSTUMER_ID|
DATE
|
+----------+------------+-------------+
| 1
| 1
| 18/04/2016 |
| 2
| 5
| 12/12/2016 |
| 3
| 4
| 18/04/2014 |
| 4
| 7
| 01/10/2015 |
+----------+------------+-------------+
SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE NOT EXISTS (
SELECT *
Sous requte
FROM ORDER
WHERE CUSTOMERS.ID=ORDER.CUSTUMER_ID
);
+----+----------+----------+
| ID | NAME
| SALARY
|
+----+----------+----------+
| 2 | Khilan
| 1500.00 |
| 3 | kaushik | 2000.00 |
| 6 | Ramesh
| 4500.00 |
+----+----------+----------+

- La clause LIMIT: pour le nombre de lignes rsultats.

SELECT * FROM CUSTOMERS LIMIT 2;
Ou encore: SELECT TOP 2 * FROM CUSTOMERS;
Ou: SELECT * FROM CUSTOMERS WHERE ROWNUM <= 2;

Module : Base de donnes

2016-2017 Semestre II
+----+---------+-----+-----------+---------+
| ID | NAME
| AGE | ADDR
| SALARY |
+----+---------+-----+-----------+---------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi
| 1500.00 |
+----+---------+-----+-----------+---------+

- La clause ORDER BY: Pour ordonner le rsultat.

SELECT * FROM CUSTOMERS
ORDER BY NAME, SALARY;
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDR
| SALARY
|
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 6 | Ramesh
| 22 | NULL
| 4500.00 |
+----+----------+-----+-----------+----------+

On peut aussi ordonner par ordre dcroissant DESC ou

croissant ASC.
SELECT * FROM CUSTOMERS ORDER BY NAME DESC;
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDR
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 6 | Ramesh
| 22 | NULL
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
+----+----------+-----+-----------+----------+

On peut utiliser la clause DISTINCT avec la clause ORDER

BY
Supposant que la table CUSTOMERS contient les donnes
suivantes :
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDR
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 6 | Komal
| 22 | MP
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+
SELECT DISTINCT SALARY FROM CUSTOMERS
ORDER BY SALARY;
+----------+
| SALARY
|
+----------+
| 1500.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+

- La clause GROUP BY: Pour grouper les donnes du rsultat.

Supposant que la table CUSTOMERS contient les donnes
suivantes :
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDR
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Ramesh
| 25 | Delhi
| 1500.00 |

Chap4 : Structured query language SQL (Langage de requte structure) A.BEKADDOUR page 4

ENSSA Tlemcen @ Dpartement Informatique

2016-2017 Semestre II

| 3 | kaushik | 23 | Kota
| 2000.00 |
| 4 | kaushik | 25 | Mumbai
| 6500.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 6 | Komal
| 22 | MP
| 4500.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+
SELECT NAME, SUM(SALARY) FROM CUSTOMERS
GROUP BY NAME;
+---------+-------------+
| NAME
| SUM(SALARY) |
+---------+-------------+
| Hardik |
8500.00 |
| kaushik |
8500.00 |
| Komal
|
4500.00 |
| Muffy
|
10000.00 |
| Ramesh |
3500.00 |
+---------+-------------+

| 7 | Muffy
| 24 | Indore
| 10000.00 |
+----+----------+-----+-----------+----------+
SELECT NAME, SUM(SALARY) FROM CUSTOMERS
GROUP BY NAME
HAVING SUM(SALARY) > 9000;

La clause GROUP BY permet de filtrer par groupe alors que la

clause WHERE permet de filtrer par ligne.
- La clause CASE WHEN: Similaire si/ sinon
Supposant que la table CUSTOMERS

+---------+-------------+
| NAME
|COUNT(SALARY)|
+---------+-------------+
| Ramesh |
2
|
| kaushik |
2
|
+---------+-------------+
SELECT NAME, AVG (SALARY) FROM CUSTOMERS
GROUP BY NAME
HAVING AVG(SALARY) BETWEEN 3000 AND 4500;

+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDRESS
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 7 | Muffy
| 24 | Indore
| 10000.00 |
| 6 | Komal
| 22 | MP
| 4500.00 |
| 2 | Khilan
| 25 | Delhi
| 1500.00 |
| 3 | kaushik | 23 | Kota
| 2000.00 |
| 5 | Hardik
| 27 | Bhopal
| 8500.00 |
| 4 | Chaitali | 25 | Mumbai
| 6500.00 |
+----+----------+-----+-----------+----------+
SELECT ID,
NAME,
Age,
CASE
WHEN Age=27 THEN 'Age bon'
WHEN Age>24 THEN 'Age bien'
ELSE 'Age loin' END
,
ADDRESS,
SALARY
FROM CUSTOMERS;
+----+---------+----+----------+----------+--------+
| ID | NAME
|AGE |CASE
| ADDRESS
| SALARY
|
+----+---------+----+----------+----------+--------+
| 1 | Ramesh | 32 |Age bien |Ahmedabad | 2000.00 |
| 7 | Muffy
| 24 |Age loin |Indore
|10000.00 |
| 6 | Komal
| 22 |Age loin |MP
| 4500.00 |
| 2 | Khilan | 25 |Age bien |Delhi
| 1500.00 |
| 3 | kaushik | 23 |Age loin |Kota
| 2000.00 |
| 5 | Hardik | 27 |Age bon |Bhopal
| 8500.00 |
| 4 | Chaitali| 25 |Age bien |Mumbai
| 6500.00 |
+----+---------+----+----------+---------+---------+

- La clause HAVING: La clause HAVING en SQL est presque

similaire WHERE la seule diffrence que HAVING permet
de slectionner en utilisant des fonctions dagrgation telles que
SUM(), COUNT(), AVG(), MIN() ou MAX().
La clause HAVING est souvent utilise avec GROUP BY
malgr que ce nest pas obligatoire.
Supposant que la table CUSTOMERS :
+----+----------+-----+-----------+----------+
| ID | NAME
| AGE | ADDR
| SALARY
|
+----+----------+-----+-----------+----------+
| 1 | Ramesh
| 32 | Ahmedabad | 2000.00 |
| 2 | Ramesh
| 25 | Delhi
| 1500.00 |
| 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 donnes

La fonction SUM permet de calculer la somme des valeurs de la

colonne spcifie.
+---------+-------------+
| NAME
| SUM(SALARY) |
+---------+-------------+
| Muffy
|
10000.00 |
+---------+-------------+
SELECT NAME, COUNT(SALARY) FROM CUSTOMERS
GROUP BY NAME
HAVING COUNT(SALARY) >= 2 ;

La fonction COUNT permet de compter le nombre de ligne de

la colonne spcifie.

La fonction AVG permet calculer de la moyenne des valeurs de

la colonne spcifie.
+---------+-------------+
| NAME
| AVG(SALARY)|
+---------+-------------+
| kaushik |
4250.00 |
+---------+-------------+
SELECT NAME, AVG (SALARY) FROM CUSTOMERS
GROUP BY NAME
HAVING AVG(SALARY) = MIN (SALARY);

La fonction MIN permet de calculer le minimum des valeurs de

la colonne spcifie (De mme pour MAX).
+---------+-------------+
| NAME
| AVG(SALARY) |
+---------+-------------+
| Ramesh |
1500.00 |
+---------+-------------+

b- Les requte plusieurs tables :

Ce type de requte est utilis pour les oprations ncessitant
plusieurs tables (union, intersection, diffrence, jointure).
- La clause UNION : union de deux tables.
Supposant les deux tables magasin 1 et magasin 2 :
Magasin1

prenom
Lon
Marie
Sophie
Marcel

nom
Dupuis
Bernard
Dupond
Martin

ville
Paris
Paris
Marseille
Paris

date_naiss
1983-03-06
1993-07-03
1986-02-22
1976-11-24

total_achat
135
75
27
39

Magasin2

prenom
Marion
Paul
Marie
Marcel

nom
Leroy
Moreau
Bernard
Martin

ville
Lyon
Lyon
Paris
Paris

date_naiss
1982-10-27
1976-04-19
1993-07-03
1976-11-24

total_achat
285
133
75
39

Chap4 : Structured query language SQL (Langage de requte structure) A.BEKADDOUR page 5

ENSSA Tlemcen @ Dpartement Informatique

2016-2017 Semestre II

SELECT * FROM Magasin1

UNION
SELECT * FROM Magasin2;

prenom
Lon
Marie
Sophie
Marcel
Marie
Paul

nom
Dupuis
Bernard
Dupond
Martin
Leroy
Moreay

ville
Paris
Paris
Marseille
Paris
Lyon
Lyon

commande

date_naiss
1983-03-06
1993-07-03
1986-02-22
1976-11-24
1982-10-27
1976-04-19

total_achat
135
75
27
39
285
133

- La clause INTERSECT : Intersection de deux tables.

SELECT * FROM Magasin1
INTERSECT
SELECT * FROM Magasin2;

utilisateur_id
1
1
5

date_achat
2013-01-23
2013-02-14
2013-02-17

num_factur
A00103
A00104
A00105

- INNER JOIN:
SELECT id, prenom, nom, date_achat, num_factur,
prix_total
FROM utilisateur
INNER JOIN commande ON utilisateur.id =
commande.utilisateur_id;

id prenom nom date_achat num_factur prix_total

1 Aime Marechal 2013-01-23 A00103
203.14
1 Aime Marechal 2013-02-14 A00104
124.00

nom prenom ville date_naiss total_achat

Marie Bernard Paris 1993-07-03 75
Marcel Martin Paris 1976-11-24 39

- CROSS JOIN: Le produit cartsien.

- La clause EXCEPT: Diffrence de deux tables.

Ou bien encore:

SELECT utilisateur.id,prenom, nom,

commande.utilisateur_id,date_achat
FROM utilisateur
CROSS JOIN commande ;

SELECT prenom, nom FROM Magasin1

EXCEPT
SELECT prenom, nom FROM Magasin2;

prenom nom
ville
date_naiss
Lon
Dupuis Paris
1983-03-06
Sophie Dupond Marseille 1986-02-22

SELECT utilisateur.id,prenom, nom,

commande.id,date_achat
FROM utilisateur,commande ;

total_achat
135
27

UNINON
INTERSECT
EXCEPT
- La clause JOIN: il existe plusieurs manires pour raliser une
jointure :

INNER JOIN

LEFT JOIN

RIGHT JOIN

LEFT JOIN SANS INTERSECT RIGHT JOIN SANS INTERSECT

FULL JOIN
FULL JOIN SANS INTERSECT
Et CROSS JOIN (voir lexemple).
Soit les deux tables:
utilisateur

id
1
2
3
4

prenom
Aime
Esme
Marine
Luc

nom
Marechal
Lefort
Prevost
Rolland

email
marechal@example.com
lefort@example.com
prevost@example.com
lucrolland@example.com

Module : Base de donnes

prix_total
203.14
124.00
149.45

ville
Paris
Lyon
Lille
Marseille

id
1
1
1
2
2
2
3
3
3
4
4
4

prenom
Aime
Aime
Aime
Esme
Esme
Esme
Marine
Marine
Marine
Luc
Luc
Luc

nom
Marechal
Marechal
Marechal
Lefort
Lefort
Lefort
Prevost
Prevost
Prevost
Rolland
Rolland
Rolland

utilisateur_id
1
1
5
1
1
5
1
1
5
1
1
5

date_achat
2013-01-23
2013-02-14
2013-02-17
2013-01-23
2013-02-14
2013-02-17
2013-01-23
2013-02-14
2013-02-17
2013-01-23
2013-02-14
2013-02-17

- LEFT JOIN (LEFT OUTER JOIN): permet de lister tous

les rsultats de la premire table de gauche (left = gauche)
mme sil ny a pas de correspondance dans la deuxime tables.
Sil ny a pas de correspondance les colonnes de la deuxime
table auront toutes NULL.
SELECT id, prenom,NOM,date_achat,utilisateur_id
FROM utilisateur
LEFT JOIN commande ON utilisateur.id =
commande.utilisateur_id ;

id
1
1
2
3
4

prenom
Aime
Aime
Esme
Marine
Luc

Nom
Marechal
Marechal
Lefort
Prevost
Rolland

date_achat
2013-01-23
2013-02-14
NULL
NULL
NULL

utilisateur_id
1
1
NULL
NULL
NULL

- LEFT JOIN (sans intersection): cest une jointure gauche

en liminant les cas dintersection.
SELECT id, prenom,NOM,date_achat,utilisateur_id

Chap4 : Structured query language SQL (Langage de requte structure) A.BEKADDOUR page 6

ENSSA Tlemcen @ Dpartement Informatique

FROM utilisateur
LEFT JOIN commande ON utilisateur.id =
commande.utilisateur_id
WHERE utilisateur_id IS NULL ;

id
2
3
4

prenom
Esme
Marine
Luc

Nom
Lefort
Prevost
Rolland

date_achat
NULL
NULL
NULL

utilisateur_id
NULL
NULL
NULL

- RIGHT JOIN (RIGHT OUTER JOIN): permet de lister

tous les rsultats de la deuxime table de droite (right = droite)
mme sil ny a pas de correspondance dans la premire table.
Sil ny a pas de correspondance les colonnes de la premire
table auront toutes NULL.
SELECT id, prenom,NOM,date_achat,utilisateur_id
FROM utilisateur
RIGHT JOIN commande ON utilisateur.id =
commande.utilisateur_id ;

id

prenom Nom date_achat utilisateur_id

1
Aime Marechal 2013-01-23 1
1
Aime Marechal 2013-02-14 1
NULL NULL NULL 2013-02-17 5
- RIGHT JOIN (sans intersection): cest une jointure gauche
en liminant les cas dintersection.
SELECT id, prenom,NOM,date_achat,utilisateur_id
FROM utilisateur
RIGHT JOIN commande ON utilisateur.id =
commande.utilisateur_id
WHERE id IS NULL ;

id prenom Nom date_achat utilisateur_id

NULL NULL NULL 2013-02-17 5
- FULL JOIN (FULL OUTER JOIN): permet de combiner
les rsultats de 2 tables, les associer entre eux grce une
condition et remplir avec des valeurs NULL si la condition nest
pas respecte.
SELECT id, prenom, nom, utilisateur_id,
date_achat
FROM utilisateur
FULL JOIN commande ON utilisateur.id =
commande.utilisateur_id ;

id

prenom
1
Aime
1
Aime
2
Esme
3
Marine
4
Luc
NULL NULL

nom
Marechal
Marechal
Lefort
Prevost
Rolland
NULL

utilisateur_id
1
1
NULL
NULL
NULL
5

date_achat
2013-01-23
2013-02-14
NULL
NULL
NULL
2013-02-17

- FULL JOIN (sans intersection): cest une jointure

complte en liminant les cas dintersection.

2016-2017 Semestre II

id

prenom
2
Esme
3
Marine
4
Luc
NULL NULL

nom
Lefort
Prevost
Rolland
NULL

utilisateur_id
NULL
NULL
NULL
5

date_achat
NULL
NULL
NULL
2013-02-17

- SELF JOIN : correspond une jointure dune table avec

elle-mme.
SELECT a.id, a.prenom, a.nom, a.ville,
b.prenom, b.nom, b.ville
FROM utilisateur a, utilisateur b
WHERE a.ville = b.ville AND a.id <> b.id;

id prenom nom ville prenom nom ville

2 Esme Lefort Lyon Marine Prevost Lille
3 Marine Prevost Lille Esme Lefort Lyon
- NATURAL JOIN : Permet de faire une jointure naturelle
entre 2 tables. Lavantage dun NATURAL JOIN cest quil ny
a pas besoin dutiliser la clause ON.
Soit les deux tables :
utilisateur:

user_id
1
2
3
4
5

user_prenom
Jrmie
Damien
Sophie
Yann
La

user_ville
Paris
Montral
Marseille
Lille
Paris

pays_id
1
2
NULL
9999
1

pays:

pays_id
1
2
3
4

pays_nom
France
Canada
Belgique
Suisse

Remarquer que utilisateur.pays_id et pays.id ont le mme nom

et le mme type (sinon on ne poura pas faire une jointure
naturelle).

pays_id
1
2
NULL
9999
1

user_id
1
2
3
4
5

user_prenom
Jrmie
Damien
Sophie
Yann
La

user_ville
Paris
Montral
Marseille
Lille
Paris

pays_nom
France
Canada
NULL
NULL
France

b- Les fonctions :
Le langage SQL contient des fonctions permettant de faire des
SELECT
id,
prenom,
nom,
utilisateur_id, calculs (traitement) sur les donnes. On distingue trois types de
date_achat
fonctions.
FROM utilisateur
- Les fonctions dagrgation : Ces fonctions retournent une
FULL JOIN commande ON utilisateur.id =
seule valeur calcule 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 premire valeur.
LAST() retourne la dernire valeur.
MAX() retourne la plus grande valeur.
MIN() retourne la plus petite valeur.
Module : Base de donnes Chap4 : Structured query language SQL (Langage de requte structure) A.BEKADDOUR page 7

ENSSA Tlemcen @ Dpartement Informatique

SUM() retourne la somme.
- Les fonctions scalaires : Ces fonctions retournent une seule
valeur en se basant sur une seule valeur en entre. Parmi ces
fonctions :
UCASE() convertit un champs en majuscule.
LCASE() convertit un champs en minuscule.
MID() Extraire des caractres partir dun champs.
LEN() retourne la longueur dun champs.
UCASE, LCASE,MID et LEN sapplique sur des champs de
type chaine de caractres.
ROUND() - Arrondit un champ numrique au nombre de
dcimales spcifi
NOW() - Renvoie la date et l'heure actuelles du systme.
FORMAT() - Formate la faon dont un champ doit tre
affich.
Soit la table produit.
ProductID ProductName SupplierID CategoryID Unit Price
1

Table

100

18

Chaise

24 - 80 19

4
Porte
2
2
48 - 60 21.35
SELECT UCASE(ProductName) AS Product,
MID(ProductName,1,3)AS Pro, LEN(Productname) AS
L, ROUND(Price,1) AS R, NOW(),
FORMAT(Now(),'YYYY-MM-DD') AS F FROM produit;
Product Pro L R
NOW( )
F
TABLE Tab 5 18

1/3/2017 1:36:03 PM 2017-03-01

CHAISE Cha 6 19

1/3/2017 1:36:03 PM 2017-03-01

PORTE Por 5 21.3 1/3/2017 1:36:03 PM 2017-03-01

IV-

Rsum de prototype de requtes

- CREATE
DATABASE
NOM_DE_LA_BASE;
- DROP
DATABASE
NOM_DE_LA_BASE ;
- CREATE TABLE Nom_Table( colonne1 datatype,
colonne2 datatype,
.....
colonneN datatype,
PRIMARY KEY( un ou plusieurs colonnes )
);
- DROP TABLE Nom_Table;
- ALTER TABLE Nom_Table ADD Nom_col Type_donnee;
- ALTER TABLE Nom_Table DROP COLUMN Nom_col;
- 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 donnes

2016-2017 Semestre II
- SELECT * FROM table WHERE colonne LIKE modele;
- SELECT * FROM table WHERE nom_colonne IS NULL;
- SELECT * FROM table WHERE nom_colonne IS NOT
NULL;
- SELECT colonne1, fonction(colonne2)FROM table
GROUP BY colonne1
- SELECT colonne1, fonction(colonne2)FROM
nom_table WHERE condition GROUP BY colonne1
HAVING condition;
- SELECT colonne1, colonne2, colonne3, FROM
table ORDER BY colonne1 DESC|ASC, colonne2
DESC| ASC, colone3 DESC|ASC, ;
- SELECT nom_colonnes FROM table LIMIT
nombre_max_de_ligne_resultat ;
- CASE
WHEN condition1 THEN resultat1
WHEN condition1 THEN resultat2
WHEN condition1 THEN resultat3
ELSE resultat4
END
- SELECT * FROM table1 UNION SELECT * FROM
table2;
- SELECT * FROM table1 INTERSECT SELECT * FROM
table2;
- SELECT * FROM table1 EXCEPT SELECT * FROM
table2;
- SELECT * FROM table1 INNER JOIN table2 ON
table1.id = table2.CS_id
Ou encore: SELECT * FROM table1 INNER JOIN
table2 WHERE table1.id = table2.CS_id;
- SELECT * FROM table1 CROSS JOIN table2
Ou encore: SELECT * FROM table1, table2 ;
- SELECT * FROM table1 LEFT JOIN table2 ON
table1.id = table2.CS_id
Ou encore: SELECT * FROM table1 LEFT OUTER
JOIN table2 ON table1.id = table2.CS_id;
- SELECT * FROM table1 RIGHT JOIN table2 ON
table1.id = table2.CS_id
Ou encore: SELECT * FROM table1 RIGHT OUTER
JOIN table2 ON table1.id = table2.CS_id;
- SELECT * FROM table1 FULL JOIN table2 ON
table1.id = table2.CS_id;
Ou encore: SELECT * FROM table1 FULL OUTER
JOIN table2 ON table1.id = table2.CS_id;
- SELECT * FROM table1 NATURAL JOIN table2;

Chap4 : Structured query language SQL (Langage de requte structure) A.BEKADDOUR page 8