Le langage SQL

Exemple 2-4. Requête simple avec qualification

Pour retrouver tous les tuples de la table PART dont l'attribut PRICE est supérieur à 10 nous formulons la requête suivante :

SELECT * FROM PART WHERE PRICE > 10;

et nous obtenons la table :

PNO | PNAME | PRICE -----+---------+-------- 3 | Bolt | 15 4 | Cam | 25

L'utilisation de * dans le mot-clé SELECT fournira tous les attributs de la table. Si nous voulons retrouver seulement les attributs PNAME et PRICE de la table PART nous utiliserons la clause :

SELECT PNAME, PRICE FROM PART WHERE PRICE > 10;

dans ce cas le résultat est :

PNAME | PRICE --------+-------- Bolt | 15 Cam | 25

Notez que le SELECT de SQL correspond au "projection" en algèbre relationnelle mais pas au "sélection" (lire la section Algèbre relationnelle).

Les qualifications dans la clause WHERE peuvent aussi être logiquement connectées en utilisant les mots-clé OR, AND, et NOT.

SELECT PNAME, PRICE FROM PART WHERE PNAME = 'Bolt' AND (PRICE = 0 OR PRICE < 15);

qui conduit au résultat :

PNAME | PRICE --------+-------- Bolt | 15

Les opérations arithmétiques peuvent être utilisées dans la liste cible et dans la clause WHERE. Par exemple si nous voulons connaître combien coûteront deux exemplaires d'une pièce acquise sans que le montant total de la facture atteigne 50 F nous utilisons la requête suivante :

SELECT PNAME, PRICE * 2 AS DOUBLE FROM PART WHERE PRICE * 2 < 50;

et obtenons :

PNAME | DOUBLE --------+--------- Screw | 20 Nut | 16 Bolt | 30

Notez que le mot DOUBLE après le mot-clé AS est le nouveau titre de la seconde colonne. Cette technique peut être utilisée pour chaque élément de la liste cible afin de donner un nouveau titre à la colonne qui en résultera. Ce nouveau titre est souvent utilisé comme alias. Ce dernier ne peut pas être utilisé dans le reste de la requête.

Exemple 2-5. Aggrégats

Si nous voulons connaître le coût moyen (AVeraGe) de toutes les pièces de la table PART nous utilisons la requête suivante :

SELECT AVG(PRICE) AS AVG_PRICE FROM PART;

le résultat est :

AVG_PRICE ----------- 14.5

Si nous voulons savoir combien de pièces sont stockées dans la table PART nous utilisons la clause :

SELECT COUNT(PNO) FROM PART;

et obtenons :

COUNT ------- 4

Exemple 2-6. Aggrégats

Pour connaître combien de pièces sont vendues par chaque fournisseur nous formulons la requête suivante :

SELECT S.SNO, S.SNAME, COUNT(SE.PNO) FROM SUPPLIER S, SELLS SE WHERE S.SNO = SE.SNO GROUP BY S.SNO, S.SNAME;

et obtenons :

SNO | SNAME | COUNT -----+-------+------- 1 | Smith | 2 2 | Jones | 1 3 | Adams | 2 4 | Blake | 3

Voici comment ce résultat est calculé. La jointure des tables SUPPLIER et SELLS est tout d'abord engendrée :

S.SNO | S.SNAME | SE.PNO -------+---------+-------- 1 | Smith | 1 1 | Smith | 2 2 | Jones | 4 3 | Adams | 1 3 | Adams | 3 4 | Blake | 2 4 | Blake | 3 4 | Blake | 4

Puis les tuples sont répartis dans les groupes. Tous ceux qui contiennent les mêmes valeurs pour les attributs S.SNO et S.SNAME appartiendront au même groupe.

S.SNO | S.SNAME | SE.PNO -------+---------+-------- 1 | Smith | 1 | 2 -------------------------- 2 | Jones | 4 -------------------------- 3 | Adams | 1 | 3 -------------------------- 4 | Blake | 2 | 3 | 4

Dans notre exemple nous avons obtenu quatre groupes et pouvons à présent appliquer l'opérateur COUNT pour chaque groupe afin d'obtenir le résultat de la requête.

Exemple 2-7. Having

La requête suivante produit la liste des fournisseurs vendant plus d'une pièce :

SELECT S.SNO, S.SNAME, COUNT(SE.PNO) FROM SUPPLIER S, SELLS SE WHERE S.SNO = SE.SNO GROUP BY S.SNO, S.SNAME HAVING COUNT(SE.PNO) > 1;

et obtenons :

SNO | SNAME | COUNT -----+-------+------- 1 | Smith | 2 3 | Adams | 2 4 | Blake | 3

Exemple 2-8. Sous-requête

Nous voulons connaître toutes les pièces dont la valeur est plus grande que la pièce nommée 'Screw', nous nous servons de la requête :

SELECT * FROM PART WHERE PRICE > (SELECT PRICE FROM PART WHERE PNAME='Screw');

le résultat est :

PNO | PNAME | PRICE -----+---------+-------- 3 | Bolt | 15 4 | Cam | 25

La requête ci-dessus contient deux SELECT. Le premier, placé au tout début de la requête (ici appelé «SELECT externe») et l'autre («SELECT interne») dans la clause WHERE qui commence une requête emboîtée. Pour chaque tuple du SELECT externe, le SELECT interne a été évalué. Après chaque évaluation nous connaissons le prix du tuple nommé 'Screw' et pouvons savoir si le prix du tuple actuel est plus grand.

Nous voulons connaître tous les fournisseurs qui ne vendent aucune pièce (afin, par exemple, de les supprimer de la base), utilisons :

SELECT * FROM SUPPLIER S WHERE NOT EXISTS (SELECT * FROM SELLS SE WHERE SE.SNO = S.SNO);

Dans notre exemple le résultat sera vide parce que chaque fournisseur vend au moins une pièce. Notez que nous utilisons le S.SNO acquis grâce au SELECT externe dans la clause WHERE du SELECT interne. Comme décrit ci-dessus la sous-requête est évaluée pour chaque tuple obtenu par la requête externe, i.e. la valeur pour S.SNO est toujours prise depuis le tuple du SELECT externe considéré sur le moment.

Exemple 2-9. Union, Intersection, Exception

cet exemple de requête UNION :

SELECT S.SNO, S.SNAME, S.CITY FROM SUPPLIER S WHERE S.SNAME = 'Jones' UNION SELECT S.SNO, S.SNAME, S.CITY FROM SUPPLIER S WHERE S.SNAME = 'Adams';

donne le résultat :

SNO | SNAME | CITY -----+-------+-------- 2 | Jones | Paris 3 | Adams | Vienna

ici, un exemple pour INTERSECT :

SELECT S.SNO, S.SNAME, S.CITY FROM SUPPLIER S WHERE S.SNO > 1 INTERSECT SELECT S.SNO, S.SNAME, S.CITY FROM SUPPLIER S WHERE S.SNO > 2;

donne le résultat :

SNO | SNAME | CITY -----+-------+-------- 2 | Jones | Paris Le seul tuple retourné par les deux parties de la requête est celui ayant SNO=2.

Enfin un exemple pour EXCEPT :

SELECT S.SNO, S.SNAME, S.CITY FROM SUPPLIER S WHERE S.SNO > 1 EXCEPT SELECT S.SNO, S.SNAME, S.CITY FROM SUPPLIER S WHERE S.SNO > 3;

donne le résultat :

SNO | SNAME | CITY -----+-------+-------- 2 | Jones | Paris 3 | Adams | Vienna

Exemple 2-10. Création de table

Pour créer les tables de notre exemple les clauses SQL suivantes sont utilisées :

CREATE TABLE SUPPLIER (SNO INTEGER, SNAME VARCHAR(20), CITY VARCHAR(20));

CREATE TABLE PART (PNO INTEGER, PNAME VARCHAR(20), PRICE DECIMAL(4 , 2));

CREATE TABLE SELLS (SNO INTEGER, PNO INTEGER);

Exemple 2-11. Create index

Pour créer un index nommé I sur l'attribut SNAME de la relation SUPPLIER, nous utilisons la clause suivante :

CREATE INDEX I ON SUPPLIER (SNAME);

L'index créé est maintenu automatiquement, donc lors de chaque insertion d'un nouveau tuple dans la relation SUPPLIER l'index I est adapté. Notez que les seuls changements que peut percevoir un utilisateur quand un index est créé est un accroissement des performances de certaines opérations de sélection.