Vous êtes sur la page 1sur 46

SQL

Initiation aux requêtes SQL


Requête de manipulation de table
 SQL/CREATE TABLE
SQL/ CONSTRAINT
SQL/ Clé primaire
SQL/Clé étrangère
SQL/ CREATE VIEW
SQL/ CREATE INDEX
SQL/ ALTER TABLE
SQL/ DROP TABLE
SQL/ TRUNCATE TABLE
SQL/ INSERT INTO
SQL/ UPDATE
SQL/ DELETE FROM
SQL/ INSERT INTO
 Sous SQL, il existe deux manières de base pour INSÉRER des données
dans une table :

◦ l’une consiste à insérer des données une ligne à la fois, et l’autre plusieurs à la fois. Pour
INSÉRER des données une ligne à la fois :

◦ La syntaxe pour l’insertion de données dans une table une ligne à la fois est comme suit :

◦ INSERT INTO "nom de table" ("colonne 1", "colonne 2", ...)


VALUES ("valeur 1", "valeur 2", ...)
SQL/ INSERT INTO
 Le deuxième type de la commande INSERT INTO permet d’ajouter
plusieurs lignes à une table.
 Contrairement à l’exemple précédent, où nous avons inséré une seule
ligne en spécifiant ses valeurs pour toutes les colonnes, nous devons
maintenant utiliser une instruction SELECT pour spécifier les données à
ajouter à la table.
 Nous sommes donc en train d’insérer des données provenant d’une autre
table. La syntaxe est comme suit :

 INSERT INTO "table1" ("column1", "column2", ...)


SELECT "column3", "column4", ...
FROM "table2"
SQL/ UPDATE
 Nous pouvons, parfois, être amenés à modifier les données contenues dans
une table.
 Pour ce faire, il convient d’utiliser la commande UPDATE.
 La syntaxe de cette commande est :

◦ UPDATE "nom de table"


SET "colonne 1" = [nouvelle valeur]
WHERE {condition}

◦ UPDATE "nom de table"


SET colonne 1 = [valeur 1], colonne 2 = [valeur 2]
WHERE {condition}
SQL/ DELETE FROM
 Nous pouvons, parfois, être amenés à supprimer des enregistrements
d’une table.

 Pour ce faire, il est possible d’utiliser la commande DELETE FROM.

 La syntaxe de cette commande est :

◦ DELETE FROM "nom de table"


WHERE {condition}
SQL > Commandes SQL >
 SQL SELECT
SQL DISTINCT
SQL WHERE
SQL AND OR
SQL IN
SQL BETWEEN
SQL LIKE
SQL ORDER BY
SQL Fonctions
SQL COUNT
SQL GROUP BY
SQL HAVING
SQL ALIAS
SQL Jointure
SQL Concaténer
SQL SUBSTRING
SQL TRIM
SQL > Commandes SQL > Select

SELECT att1, att2, . . .


FROM nom table ;
 Récupérer les valeurs contenus dans la table nom table, en ne gardant que
les attributs att1, att2, ...
 En algèbre relationnelle :
!att1,att2,...(nom table)
 En calcul relationnel “tuple” :
{t.att1, t.att2, · · · | nom table(t)}

On peut remplacer att1, att2, . . . par « * »pour utiliser tous les


attributs.
Exemple
Schéma :

Employe(Nom, Num, Fonction, Num sup, Embauche, Salaire, Num Dept)

Donner le nom et la fonction de chaque employé :

 SELECT Nom, Fonction FROM Employe ;

 Pi Nom,Fonction(Employe)
 {t.Nom, t.Fonction | Employe(t)}
Exemple2
Schéma :
Employe(Nom, Num, Fonction, Num sup, Embauche, Salaire, Num Dept)

Donner les informations sur chaque employé :

 SELECT * FROM Employe ;


 Employe
 {t.Nom, t.Num, t.Fonction, t.Num sup, t.Embauche, t.Salaire, t.Num Dept | Employe(t)}
SQL > Commandes SQL > Distinct

Le mot clé DISTINCT permet d’éliminer les doublons dans le


résultat.

Exemple :

Donner les différentes fonctions occupées dans l’entreprise :

SELECT DISTINCT Fonction FROM Employe ;


Sélections (de lignes)
SELECT att1, att2, . . .
FROM nom table
WHERE condition
La clause WHERE spécifie les lignes à sélectionner grâce à la condition.

 En algébre relationnelle :
!att1,att2,...("condition(nom table))

 En calcul relationnel “tuple” :


{t.att1, t.att2, — — — | nom table(t) ! condition}
SQL > Commandes SQL > Where

 Expressions simples :
◦ Comparaisons (=, !=, <, <=, >, >=)
◦ entre un attribut et une constante ou un autre attribut
◦ différents types de données utilisées pour les constantes :
 nombres : 1, 1980, 1.5
 chaines de caractères : ’Martin’, ’directeur’
 dates : ’1980-06-18’ (le formatage des dates peut varier)

 Combinaison d’expressions via :


◦ Le : AND
◦ Le : OR
Exemple
Schéma :
Employe(Nom, Num, Fonction, Num sup, Embauche, Salaire, Num Dept)
Quels sont les employés dont la date d’embauche est antérieure au
1er janvier 1999 :

SELECT Nom
FROM Employe
WHERE Embauche < ’1999-01-01’ ;
Exemple
Schéma :
Employe(Nom, Num, Fonction, Num sup, Embauche, Salaire, Num Dept)

Quels sont les employés dont la date d’embauche est antérieure au


1er janvier 1999 et touchant au moins 30000 FCFA de salaire :

SELECT Nom
FROM Employe
WHERE Embauche < ’1999-01-01’
AND Salaire >= 30000 ;
SQL > Commandes SQL > IN - Between
 L’opérateur IN permet de spécifier un ensemble de valeur possibles :
Quels sont les employés qui sont directeur ou ingénieur ?

SELECT Nom, Fonction


FROM Employe
WHERE Fonction IN (’ingenieur’,’directeur’) ;

 L’opérateur BETWEEN ... AND permet de spécifier un intervalle de valeurs :


◦ Quels employés gagnent entre 25000 et 30000 FCFA ?

SELECT Nom, Salaire


FROM Employe
WHERE Salaire BETWEEN 25000 AND 30000 ;
NB : Attention à ne pas confondre le AND du BETWEEN.
Exemple
Quels sont les employés directeur ou ingénieur, embauchés entre le
1er janvier 1990 et le 31 décembre 1999 gagnant moins de 32000 FCFA ?

SELECT Nom, Embauche, Fonction, Salaire


FROM Employe
WHERE Fonction IN (’ingenieur’,’directeur’)
AND Embauche BETWEEN ’1990-01-01’ AND ’1999-12-31’
AND Salaire < 32000 ;
SQL > Commandes SQL > Order By

En pratique, il peut être intéressant de trier le résultat d’une requête.


SELECT att1, att2, . . .
FROM nom table
WHERE condition
ORDER BY atti , attj , . . .
 Le résultat de la requête est tri´e par ordre croissant sur l’attribut atti

 En cas d’´egalit´e entre deux lignes au niveau de l’attribut atti ,


on utilise l’attribut attj , etc . . .

 Dans un ORDER BY, il est possible de faire suivre le nom d’un attribut par
ASC ou DESC pour indiquer un ordre croissant ou décroissant.
SQL > Commandes SQL > Like
 LIKE est un autre mot-clé utilisé dans la clause WHERE. LIKE permet
d’effectuer une recherche basée plutôt sur un modèle qu’une spécification
exacte de ce qui est souhaité (comme dans IN) ou une définition d’un
intervalle (comme dans BETWEEN). La syntaxe est comme suit :
◦ SELECT "nom de colonne"
FROM "nom de table"
WHERE "nom de colonne" LIKE {modèle}
 {modèle} représente souvent des caractères de remplacement.Voici quelques exemples :
 'A_Z' : toutes les chaînes commençant par 'A', ou un autre caractère, et terminant par 'Z'. Par
exemple, 'ABZ' et 'A2Z' satisferaient la condition, alors 'AKKZ' ne le ferait pas (car il y a deux
caractères entre A et Z au lieu d’un).
 'ABC%' : toutes les chaînes commençant par 'ABC'. Par exemple, 'ABCD' et 'ABCABC'
satisferaient la condition.
 '%XYZ' : toutes les chaînes terminant par 'XYZ'. Par exemple, 'WXYZ' et 'ZZXYZ' satisferaient
la condition.
 '%AN%' : toutes les chaînes contenant le modèle 'AN' quelle que soit sa position. Par exemple,
'LOS ANGELES' et 'SAN FRANCISCO' satisferaient la condition.
SQL > Commandes SQL > Fonctions
 SQL dispose des fonctions arithmétiques suivantes :
 - AVG
- COUNT
- MAX
- MIN
- SUM
 La syntaxe pour utiliser ces fonctions est :
 SELECT "nom de fonction"("nom de colonne")
FROM "nom de table"
SQL > Commandes SQL > Count

 COUNT permet de compter le nombre


de lignes incluses dans une table.

 La syntaxe est :
 SELECT COUNT("nom de colonne")
FROM "nom de table"
SQL > Commandes SQL > Group By

 fonction d’agrégation (Group by)


◦ SELECT "nom de colonne 1",
◦ SUM("nom de colonne 2")
FROM "nom de table"
GROUP BY "nom de colonne 1"
SQL > Commandes SQL > Having

 il faut utiliser la clause HAVING, réservée pour les fonctions d’agrégation,


à la place de la clause WHERE dans l’instruction SQL.
 Généralement, la clause HAVING est placée pratiquement en fin
d’instruction SQL, et cette dernière peut ou non inclure la clause
GROUP BY.
 La syntaxe pour HAVING est,
 SELECT "nom de colonne 1", SUM("nom de colonne 2")
FROM "nom de table"
GROUP BY "nom de colonne 1"
HAVING (condition fonction)
 Remarque : la clause GROUP BY est optionnelle.
SQL > Commandes SQL > Alias
 Il existe deux types d’alias qui sont fréquemment utilisés
: alias de colonne et alias de table
 les alias de colonne concourent à améliorer la lisibilité
d’une requête.
 Cette procédure est facile à comprendre, mais pensons
à des cas où l’en-tête de colonne peut être compliqué
(surtout s’il provoque plusieurs opérations
arithmétiques).
 L’utilisation d’un alias de colonne permet de rendre le
résultat beaucoup plus lisible.
SQL > Commandes SQL > Alias

 Le second type d’alias est l’alias de table.


 L’alias de table s’obtient en plaçant directement un alias après le
nom de table dans la clause FROM
 Les alias sont très utiles lorsque vous souhaitez obtenir des
informations de deux tables séparées (le terme technique est
'perform joins').
 L’avantage d’utiliser un alias de table au moment d’exécuter des
commandes de jointure est manifeste.
 Par essence, les alias de table sont destinés à faciliter la
compréhension des instructions SQL, surtout en présence de
plusieurs tables.

◦ SELECT "table alias"."nom de colonne 1" "colonne alias"


FROM "nom de table" "table alias"
SQL > Commandes SQL > Jointure

 Exemple
SQL > Commandes SQL > Jointure

En SQL, la jointure s’exprime comme une sélection sur le produit cartésien.


Jointure naturelle sur les relations R(A1,A2,B1,B2) et S(C1, C2,B1,B2)
peut s’exprimer par :

SELECT A1, A2, R.B1, S.B2, C1, C2


FROM R, S
WHERE R.B1=S.B1 AND R.B2=S.B2
Exemple
Schéma :
Batiment(Num_bat, Nom_bat, Ent_princ, Ent_Sec)
Departement(Num_dept, Nom_dept, Num_bat)

Donner les départements avec leurs bâtiments :

SELECT Num_dept, Nom_dept, Batiment.Num_bat, Nom_bat, Ent_princ, Ent_sec


FROM Departement, Batiment
WHERE Departement.Num_bat = Batiment.Num_bat ;

Une notation similaire peut être utilisée pour renommer les attributs dans le SELECT.
SQL > Commandes SQL > Concaténer Fonction

 Il est parfois nécessaire de combiner ensemble


(concaténer) les résultats de plusieurs champs
différents.
 Chaque base de données a sa propre méthode de
concaténation :
◦ MySQL: CONCAT()
◦ Oracle: CONCAT(), ||
◦ SQL Server: +
 La syntaxe pour CONCAT() est comme suit :
 CONCAT(str1, str2, str3, ...): Concaténez ensemble
str1, str2, str3, et toute autre chaîne.
SQL > Commandes SQL > Substring

 La fonction de sous-chaîne sous SQL est utilisée pour extraire une partie
des données stockées.
 Le nom de cette fonction diffère selon la base de données utilisée:
◦ MySQL: SUBSTR(), SUBSTRING()
◦ Oracle: SUBSTR()
◦ SQL Server: SUBSTRING()
 Les utilisations les plus fréquentes sont comme suit (SUBSTR() sera ici
utilisé):
◦ SUBSTR(str,pos): sélectionne tous les caractères de <str> en commençant par position
<pos>.
 Notez que cette syntaxe n’est pas prise en charge par SQL Server.
◦ SUBSTR(str,pos,len): en commençant par le caractère <pos> dans la chaîne <str>,
sélectionne les caractères <len> suivants.
SQL > Commandes SQL > Trim

 La fonction TRIM sous SQL permet de supprimer des préfixes ou suffixes


spécifiques d’une chaîne de caractères.
 Le modèle le plus fréquemment supprimé sont les espaces blancs.
 Le nom de cette fonction diffère selon la base de données utilisée :
◦ MySQL: TRIM(), RTRIM(), LTRIM()
◦ Oracle: RTRIM(), LTRIM()
◦ SQL Server: RTRIM(), LTRIM()

 La syntaxe de ces fonctions Trim est :


 TRIM([[LOCATION] [remstr] FROM ] str): [LOCATION] peut être
LEADING, TRAILING ou BOTH.
 Cette fonction efface le modèle [remstr] à partir du début ou de la fin de la chaîne
de caractères, ou des deux.
 Si [remstr] n’est pas spécifié, les espaces blancs seront effacés.
SQL > Commandes SQL > Trim

 LTRIM(str): Efface tous les espaces blancs situés en début de chaîne.


 RTRIM(str): Efface tous les espaces blancs situés en fin de chaîne.
 Exemple 1 :
 SELECT TRIM(' Sample ');
 Résultat :
 'Sample'
 Exemple 2 :
 SELECT LTRIM(' Sample ');
 Résultat :
 'Sample '
 Exemple 3 :
 SELECT RTRIM(' Sample ');
 Résultat :
 ' Sample'
Valeurs non définies
En pratique, il est possible d’avoir des valeurs non définies.

 Elles sont représentées par le mot clé NULL.


 On peut tester si une valeur n’est pas définie grâce à la
condition IS NULL (ou au contraire IS NOT NULL)
Schéma : Batiment(Num_bat, Nom_bat, Ent_princ, Ent_Sec)
 Les bâtiments qui n’ont pas d’entrée secondaire auront une
valeur NULL pour l’attribut Ent_Sec.
 La requête suivante indique les bâtiments n’ayant pas d’entrée
secondaire :

SELECT * FROM Batiment WHERE Ent_sec IS NULL ;


Exemple
Schéma :
Employe(Nom, Num, Fonction, Num sup, Embauche, Salaire, Num Dept)

Donner le nom des employés du département numéro 20, en triant


le résultat par salaire décroissant, puis par nom (croissant) :

SELECT Nom
FROM Employe
WHERE Num dept=20
ORDER BY Salaire DESC, Nom ;
Requêtes sur plusieurs tables
SELECT att1, att2, . . .
FROM nom table1, nom table2, . . .
WHERE condition
ORDER BY atti , attj , . . .

Il est possible d’utiliser plusieurs tables dans une requête.


Cela correspond à effectuer un produit cartésien entre les différentes
tables.
Si un attribut est présent dans plusieurs tables utilisées, on doit
l’écrire nom table.att
Renommages
Il est parfois utile de renommer des tables :

SELECT att1, att2, . . .


FROM nom table1 nouveau nom1, nom table2 nouveau nom2, . . .
WHERE condition
ORDER BY atti , attj , . . .

 Indication des renommages dans le FROM.


 Les anciens noms indiqués dans le FROM ne peuvent pas être
utilisés dans les autres parties de la requête.
 Utile lorsque l’on veut effectuer des jointures ou des produits
cartésiens d’une table avec elle-même.
Exemple
Schema :
Employe(Nom, Num, Fonction, Num_sup, Embauche, Salaire, Num_Dept)
Donner les noms et la fonction des employés avec le nom de leur
supérieur hiérarchique.

SELECT Employe.Nom, Employe.Fonction,


Chef.Nom Superieur
FROM Employe, Employe Chef
WHERE Chef.Num = Employe.Num_sup ;
Exemple2
Schéma :
Employe(Nom, Num, Fonction, Num_sup, Embauche, Salaire, Num_Dept)

Quels sont les employés, donnés avec leur salaire, qui gagnent moins que
Bellot ?

SELECT Employe.Nom, Employe.Salaire


FROM Employe, Employe bel
WHERE Employe.Salaire < bel.Salaire
AND bel.Nom = ’Bellot’ ;
Sous--requêtes
Sous
Il est possible d’utiliser le résultat d’une requête dans une autre
requête.
 Augmentation de la puissance d’expression du langage.
 Les sous-requêtes sont utilisables dans les parties
 WHERE
 FROM (à condition de renommer le résultat)
 SELECT (à condition que pour chaque ligne sélectionnée par
la requête principale, on ne sélectionne qu’une ligne dans la
sous-requête).

 En cas de conflit sur les nom, c’est la déclaration la plus


proche qui est utilisée.
Exemple
Si la sous-requête renvoie un résultat simple sur une ligne :
Schéma :
Employe(Nom, Num, Fonction, Num_sup, Embauche, Salaire, Num_Dept)
Quels sont les employés ayant la même fonction que ’Jones’ ?
SELECT Nom
FROM Employe
WHERE Fonction =(SELECT Fonction FROM Employe WHERE Nom=’Jones’)
;
Sous--requête liée à la requête principale
Sous
Schéma :

Employe(Nom, Num, Fonction, Num_sup, Embauche, Salaire, Num_Dept)


Quels sont les employés qui ne travaillent pas dans le même
département que leur supérieur ?
SELECT Nom
FROM Employe Emp
WHERE Num dept != (SELECT Num_dept
FROM Employe
WHERE Emp.Num_sup = Num) ;
Sous--requêtes renvoyant plusieurs lignes
Sous
Opérateurs permettant d’utiliser de telles sous-requêtes :
 a- IN (sous requête)
vrai si a apparait dans le résultat de sous requête.
 a- ANY (sous requête)
où " peut être {=, <,>,<=,>=}
vrai si il existe un b parmi les lignes renvoyées par sous requête tel que a"b soit
vrai.
 a- ALL (sous requête)
ou " peut être {=, <,>,<=,>=}
vrai si pour toutes les lignes b renvoyées par sous requête, a"b est vrai.
 EXISTS (sous requête)
vrai si le résultat de sous requête n’est pas vide.
Exemple
Schéma :

Employe(Nom, Num, Fonction, Num_sup, Embauche, Salaire, Num_Dept)

Quels sont les employés, donnés avec leur salaire, gagnant plus que
tous les employés du département 20 ?

SELECT Nom, Salaire


FROM Employe
WHERE Salaire > ALL (SELECT Salaire
FROM Employe
WHERE Num_dept = 20) ;
Exemple2
Schéma :

Employe(Nom, Num, Fonction, Num_sup, Embauche, Salaire, Num_Dept)

Quels sont les employés qui ont un subalterne ?

SELECT Nom
FROM Employe Chef
WHERE EXISTS (SELECT Nom
FROM Employe
WHERE Employe.Num_sup = Chef.Num) ;
Sous--requête avec un résultat à plusieurs colonnes
Sous

On peut utiliser la notation (a, b, . . .) pour former un n-uplet à comparer avec le


résultat de la sous-requête :

Schéma :

Employe(Nom, Num, Fonction, Num_sup, Embauche, Salaire, Num_Dept)

Quels sont les employés ont même fonction et même supérieur que ’Bellot’ ?

SELECT Nom
FROM Employe
WHERE (Fonction, Num_sup) = (SELECT Fonction, Num_sup
FROM Employe
WHERE Nom=’Bellot’) ;
Sous--requêtes imbriquées
Sous
Il est possible d’imbriquer les sous-requêtes :
Employe(Nom, Num, Fonction, Num_sup, Embauche, Salaire, Num _Dept)
Donner le nom et la fonction des employés du d´epartement 20 ayant
meme fonction qu’une personne du département de ’Dupont’.

SELECT Nom, Fonction FROM Employe WHERE Num_dept = 20


AND fonction IN (SELECT Fonction FROM Employe WHERE
Num dept = (SELECT Num_dept FROM Employe
WHERE Nom = ’Dupont’)
);