Le langage SQL

Bruno Delb http://www.brunodelb.com Date : 20/04/2002

Le langage SQL

Sommaire

LE MODÈLE RELATIONNEL.......................................................................................2
STRUCTURE DES DONNÉES..............................................................................................2
Approche intuitive (exemple)................................................................................2
Définitions...........................................................................................................4
LES LANGAGES D’INTERROGATION DES DONNÉES (LID)..........................................................6
Deux requêtes (monotables) fondamentales...........................................................6
Trois requêtes « ensemblistes »............................................................................7
Les requêtes portant sur plusieurs tables................................................................8
LE LANGAGE D’INTERROGATION DES DONNÉES (LID).........................................11
L’ÉNONCÉ SELECT......................................................................................................11
Syntaxe............................................................................................................11
La clause From...................................................................................................13
La clause Where.................................................................................................14
La clause Group By et Having..............................................................................18
La clause Select.................................................................................................19
La clause Order By.............................................................................................26

1


Le langage SQL

Le modèle relationnel

Structure des données

La structure des données du modèle relationnel peut être présentée de
façon plus ou moins formelle.

Approche intuitive (exemple)
Prenons le cas de la sociét Parsifal et décrivons de façon détaillée les tables
relatives à la gestion des commandes passées par les clients.
Parsifal commercialise des articles ménagers et électro-ménagers décrits
dans les deux tables suivantes :
Table Produit :
NUPRO NOMPRO TYPROD_TY QES PV PR
P
30 Casserole 1 0 45 21
20 Poele 1 500 70 30
40 Sauteuse GM 1 750 95 82
50 Plat ovale 1 517 80 27
80 Plat rectang 2 54 72 30
60 Faitout PM 1 7 98 60
110 Faitout GM 2 15 153 98
90 Friteuse PM 220 V 3 453 646 480
70 Friteuse GM 220 3 24 1450 1380
V
100 Sauteuse PM 1 1540 65 59
10 Couteau élec 220 3 5645 150 70
V

Table Typrod :
TYP NOMTYPE
1 Domestique
2 Professionnel
3 Electroménager

Chaque produit est représenté par une ligne de description dans la table
Produit.
Certaines entêtes de colonnes doivent être explicitées :

2


Le langage SQL

• QES (Quantité En Stock) correspond au nombre d’articles
actuellement disponibles en stock. Chaque produit regroupe donc
un certain nombre d’articles « identiques ».
• PV (Prix de Vente) est le prix de vente d’un article (d’une unité).
• PR (Prix de Revient) est le prix de revient d’un article (d’une
unité).
• La colonne TYPROD_TYP doit être complétée à l’aide de la table
Typrod qui indique en clair la signification du code TYP. Ainsi, on
peut voir que les casseroles sont de type TYP = 1, c’est-à-dire
produits domestiques. Ce découpaeg en deux tables peut se
justifier ici tout d’abord par un allègement dans la présentation
de la table produit tout en conservant la possibilité de retrouver
(à une manipulation près) le type de chaque produit en clair,
ensuite par la facilité de connaître la liste complète des types
sans avoir à consulter la table produit et sans que le contenu de
cette liste dépende du contenu de la table produit (nous verrons
lors de l’étude de la conception quels sont les arguments en
faveur d’un tel découpage).
Les clients susceptibles de passer des commandes sont décrits dans les
deux tables suivantes :
Table Client :
NUCLI NOMCLI CATCLI_CATEG VILLE CODPOS
5621 DURAND GR PARIS 75001
5852 DUPONT D PARIS 75012
7436 DUPIN DG PARIS 75005
5439 MARTIN GR CAEN 14000
6459 SUPERD GS LYON 69004
5438 RAPID GS ROUEN 76100
5860 QUINCAILLERI D SOUILLAC 46200
E CENTRALE

Table Catcli :
CATEG NOMCATEG TR%
GR Grossiste 35
DG Détaillant- 30
grossiste
D Détaillant 25
GS Grande surface 35

Chaque client est représenté par une ligne de la table Client.
Voici la description des colonnes :
• VILLE et CODPOS doivent être complétés par l’adresse
proprement dite, qui a été omise afin de simplifier la
présentation.

3


Le langage SQL

• CARCLI_CATEG, TR%, CATEG et TR% sont réparties dans les
tables Client et Catcli et permettent d’attribuer une catégorie en
clair à chaque cilent et defixer le taux de remise qui lui est
accordé.
Certains clients passent des commandes qui concernent chacune un ou
plusieurs produits. Pour chaque produit de la commande, il est précisé le
nombre d’articles commandés. Les commandes et produits commandés
(ou ligne_commande) sont représentés par les deux tables suivantes :
Table Commande :
NUCOM DATECOM CLIENT_NUCL
I
750 15/09/91 5621
751 16/09/91 5852
752 19/09/91 5439
753 19/09/91 7436
754 21/09/91 5852

Table Ligne_commande :
COMMANDE_NUCO PRODUIT_NUPRO QTE
M
750 30 10
751 10 5
751 80 4
751 90 2
751 50 45
752 30 400
752 40 250
752 50 40
752 60 60
752 100 250
752 10 500
752 90 150
752 70 30
753 70 200
753 90 10
753 10 25

Chaque commande passée par un client (CLIENT_NUCLI) à une certaine
date (DATECOM) est repérée par un numéro (NUCOM).

Définitions
Chaque colonne entrant dans une table comprend une entête et un corps.
L’entête, généralement invariable, indique le nom d’une certaine propriété
ou attribut (exemple : NOMCLI) alors que le corps contient des valeurs ou
composants (exemple : DURAND, DUPONT, ...) apparteant au même
domaine (exemple : chaînes de caractères pour NOMCLI). L’ensemble des

4


Le langage SQL

attributs d’une table constitue son schéma primitif. Chaque composant
représente la valeur prise par un attribut dans une certaine ligne (exemple
: DURAND est la valeur prise par NOMCLI dans la première ligne). On
s’aperçoi que l’ensemble des composants d’une ligne donne la description
d’une partie de la réalité (exemple : « 5621, DURAND, GR, PARIS, 75001 »
décrit le client Durand).
On remarque qu’il est inutile et nuisible d’avoir deux lignes identiques dans
la même table : une seule information se suffit à elle-même mais avoir dix
fois la même information occupe dix fois plus de place, nécessite dix fois
plus de temps de mise à jour ... pour une seule information dans le
meilleur des cas.
Au lieu de parler de tables et de lignes, on utilise le vocabulaire suivant.
Une table peut être considérée comme un ensemble de lignes. Chaqe ligne,
qui comprend un ou plusieurs (n) composants, peut être considérée
comme un n-tuple ou tuple. Or un ensemble de tuples peut se définir
comme l’extension d’une relation de degré n entre n ensembles (les
domaines des attributs : la relation est un sous-ensemble du produit
cartésien de ces n ensembles).
Une relation étant définie comme un ensemble :
• Il est possible de définir sa cardinalité, qui est égale au nombre
de lignes ou de tuples qui la composent à un instant donné (la
cardinalité de la relation client est égale à 7).
• Les tuples ne sont pas forcément ordonnés (triés sur un certain
critère comme les enregistrements d’un fichier séquentiel par
exemple).
Tous les composants des six relations de l’exemple sont atomiques, c’est-
à-dire que chaque attribut ne peut prendre qu’une valeur (jamais un
ensemble variable de valeurs) ou pas de valeur (c’est-à-dire une valeur
non définie). Cette propriété permet de n’avoir qu’un seul modèle de ligne
ce qui simplifie la représentation (et facilite la résolution des problèmes de
stockage et de manipulation des données).
Dans la relation client, il semble impossible d’avoir plusieurs tuples avec la
même valeur pour NUCLI car si les autres valeurs sont identiques alors il y
a redondance de l’information (le même client est représenté deux fois) et
si les autres valeurs sont différents, il y a ambiguité (supposons deux
lignes avec NUCLI = 5621, la première avec NOMCLI = DURAND et la
seconde avec NOMCLI = DUVAL; si une commande est passée par le client
5621, est-ce DURAND ou DUVAL qui a passé la commande ?). Un tel
attribut est une clef candidate pour la relation client.
Le contenu de certaines relations dépend de celui d’autres relations. Ainsi,
on peut supposer qu’une commande doit être passée par un client connu,
c’est-à-dire déjà représentée dans la relation client : le contenu de la
colonne CLIENT_NUCLI doit donc être un sous-ensemble de la colonne
NUCLI dans la relation client.
Enfin, il est nécessaire d’introduire la notion de temps : nous avons vu que
l’on passait d’une description à une nouvelle description par des mises à
jour (au sens large) et certaines modifications pourront être interdites.

5


Le langage SQL

Supposons, par exemple, qu’il soit impossible pour un grossiste (GR) de
devenir grande surface (GS) : une telle contrainte est difficile à contrôler à
posteriori car, une fois la modification effectuée, il ne reste aucune trace de
la situation antérieure interdisant la modification.

Les Langages d’Interrogation des Données (LID)

Deux requêtes (monotables) fondamentales
Nous utilisons la base de données Parsifal.
Quels sont les clients (description complète) habitant Paris ?
Calcul à variables tuples :
Un tuple est une ligne dans une table. Une table étant considérée comme
un ensemble de tuples, la table clients peut donc être décrite comme suit :
{t / t ∈ Client}, c’est-à-dire l’ensemble des tuples t tels que « (t ∈ Client)
est Vrai » en utilisant la forme logique suivante : {t / P (t)} où P est le
prédicat client.
Mais cette requête ne répond pas à la question puisque nous avons tous
les tuples de la table. Il est donc nécessaire de définir des conditions plus
contraignantes : nous désirons les tuples de la table Client pour lesquels la
valeur prise par l’attribut VILLE est égale à ‘PARIS’.
{t / t ∈ Client ∧ t.VILLE = ‘PARIS’}
En SQL :
Select * From Client Where Ville = ‘PARIS’;
Ce qui peut aussi s’écrire Select t.* From Client t Where t.VILLE = ‘PARIS’;
Algèbre relationnelle :
Pour réaliser cette requête en algèbre relationnelle, on utilise un opérateur
fondamental appelé sélection défini de la façon suivante :
forme générale σ[θ] (spr) avec spr (R, D, dom)
Le prédicat θ peut comprendre :
• des constantes ci,
• des attributs A, B, ... tels que {A, B, ...} = R,
• des opérateurs O ∈ {=, <, >, <=, >=, <>},
• ∧, ∨ permettant de construire des prédicats composés.
avec les deux formes génériques suivantes :
• σ[A o C] (spr) = {t / t ∈ spr ∧ t.A o C}
• σ[A o B] (spr) = {t / t ∈ spr ∧ t.A o t.B}
t.A désignant le composant de t correspondant à l’attribut A.
La requête est donc « σ[VILLE = ‘PARIS’] (Client) ».
Quels sont les noms des clients ?

6


Le langage SQL

On peut utiliser deux notations pour traduire cette requête.
Ullman préconise : {t(1) / ∃ u ∈ Client ∧ t = u.NOMCLI}.
Mais on peut préférer la notation pointée : {t.NOMCLI / t ∈ Client} pour les
raisons suivantes :
• la simplicité d’utilisation,
• la facilité de traduction en SQL.
On utilise pourtant la dénomination « calcul à variables tuple » dans cette
présentation.
En SQL :
Select t.NOMCLI From Client t;
On utilise un opérateur fondamental appelé « projection » défini comme
suit : Π[L] (spr) = {t.L / t ∈ spr} avec L ⊆ R et spr (SPR), L étant une liste
d’attributs.
La projection permet de copier une relation r en omettant certains attributs
(les attributs A, B, ... ∉ L) et d’obtenir une relation résultat sans double.
La requête ci-dessus peut donc être traduite par l’expression « Π[NOMCLI]
(Client) ».
Ces opérateurs peuvent être enchaînés et permettre de répondre à des
questions compliquées comme « Quels sont les noms des clients habitant
Paris ? » :
• Π[NOMCLI] (σ[VILLE = ‘PARIS’] (Client))
• {t.NOMCLI / t ∈ Cilent ∧ t.VILLE = ‘PARIS’}
• Select Distinct x.NOMCLI From Client X Where X.VILLE = ‘PARIS’;

Trois requêtes « ensemblistes »
Quels sont les numéros des commandes qui comportent les produits
numéro 10 ou numéro 80 ?
{t.COMMAND_NUCOM / t ∈ Ligne_commande ∧ (t.PRODUIT_NUPRO = 10 ∨
t.PRODUIT_NUPRO = 80}
Select t.COMMANDE_NUCOM From LIGNE_COMMANDE T Where
T.PRODUIT_NUPRO = 10 Or T.PRODUIT_NUPRO = 80;
En algèbre relationnelle, on peut :
• utiliser une sélection à prédicat composé,
• utiliser un opérateur binaire simple : l’union de relations : « spr ∪
spr’ », où spr et spr’ représentent des relations compatibles
(c’est-à-dire de même arité et portant sur les mêmes domaines).
Π[Commande_NUCOM] ((σ[Produit_NUPRO = 10] (Ligne_Commande) ∪ (σ[Produit_NUPRO = 10]

(Ligne_Commande))

7


Le langage SQL

Quels sont les numéros des commandes qui comportent simultanément
les produits numéro 10 et numéro 80 ?
{t.Commande_NUCOM / t ∈ Ligne_commande ∧ T.Produit_NUPRO = 10, ∃
u (u ∈ Ligne_commande ∧ t.Commande_NUCOM = u.Commande_NUCOM
∧ u.Produit_NUPRO = 80))
Select T.COMMANDE_NUCOM
From LIGNE_COMMANDE T
Where T.PRODUIT_NUPRO = 10
And Exists (Select U.*
From LIGNE_COMMANDE U
Where T.COMMANDE_NUCOM = U.COMMANDE_NUCOM
And U.PRODUIT_NUPRO = 80;

Remarque : « Exists » est la traduction en SQL de « ∃ » en calcul à
variables tuples.
Π[Commande_NUCOM] (σ[Produit_NUPRO = 10] (Ligne_Commande))) ∩ Π[Commande_NUCOM]
(σ[Produit_NUPRO = 80] (Ligne_Commande)))
Quels sont les numéros des commandes qui comportent le produit
numéro 10 et pas de produit numéro 80 ?
{t.Commande_NUCOM / t ∈ Ligne_commande ∧ t.Produit_NUPRO = 10 ¬ ∃
u (u ∈ Ligne_commande ∧ t.Commande_NUCOM = u.Commande_NUCOM
∧ u.Produit_NUPRO = 80)}
SQL :
Select t.COMMANDE_NUCOM
Where T.PRODUIT_NUPRO = 10
And Not Exists (Select U.*
Where T.COMMANDE_NUCOM = U.COMMANDE_NUCOM
And U.PRODUIT_NUPRO = 80;

Π[Commande_NUCOM] (σ[Produit_NUPRO = 10] (Ligne_Commande))) - Π[Commande_NUCOM]
(σ[Produit_NUPRO = 80] (Ligne_Commande)))

Les requêtes portant sur plusieurs tables
Exemple : « Quels sont les noms des clients grossistes ? ». Cette requête
concerne les tables Client et Catcli.
Donner la description complète en clair des clients
{(t, u) / t ∈ Client, u ∈ Catcli ∧ t.Catcli_CATEG = u.CATEG}
SQL :
Select T.*, U.*
From CLIENT T, CATCLI U
Where T.CATCLI_CATEG = U.CATEG;

On introduit l’opérateur du produit cartésien entre deux relations ⊗ :
(r) ⊗ (s) = {(t, u) / t ∈ r, u ∈ s}

8


Le langage SQL

σ[A o B] ((r) ⊗ (s)) = {(t, u) / t ∈ r, u ∈ s ∧ t.A o u.B}
On suppose pour cela que les attributs A et B permettent d’assurer une
concaténation correcte des tuples qui doivent se compléter.
Pour notre exemple, on obtient σ[Catcli_CATEG = CATEG] ((Client) ⊗ (Catcli))
Cette opération, la θ-jointure, est représentée comme suit :
(spr) Ξ[θ] (spr’) = σ[θ] ((spr) ⊗ (spr’))
avec θ de la forme A o B et spr (SPR) et spr’(SPR’) A ⊆ R, B ⊆ R’ et O ∈
{=, >, <, >=, <=, =, <>}
On peut donc réécrire la requête : (Client) Ξ[Catcli_CATEG = CATEG] (Catcli)
Remarques :
• Le résultat d’une théta-jointure entre deux relations d’arités
respectives n et m est une relation d’arité (m+n). Lorsque les
attribts portent des noms identiques, il est nécessaire d’utiliser la
notation pointée pour les distinguer.
• Lorsque « spr ∩ spr’ = ∅ » et « O ∈ {=} », il est possible
d’utiliser la jointure naturelle définie par :
• (spr) Ξ (spr’) = Π[spr ∪ spr’] ((spr) Ξ[(spr.Ai = spr’.Ai) ∀Ai ∈ (spr ∩ spr’)] (spr’))
• La requête « Quelle est la catégorie du client Dupont ? » peut se
traduire en algèbre relationnelle comme suit : « Π[NomCateg] (σ[NomCli =
‘DUPONT’] ((Client) Ξ[Catcli_CATEG = CATEG] (Catcli))) »

Mais on préfère la traduction « Π[NomCateg] (((σ[NomCli = ‘DUPONT’] (Client))
Ξ[Catcli_CATEG = CATEG] (Catcli))) »
Quels sont les numéros des commandes qui comportent tous les produits
proposés par Parsifal ?
{t.Commande_NUCOM / t ∈ Ligne_commande ∀ u (u ∈ Produit ⇒ ∃ v (v ∈
Ligne_commande ∧ u.NUPRO = v.Produit_NUPRO ∧ t.Commande_NUCOM
= v.Commande_NUCOM))}
SQL :
Where Not Exists (Select U.*
From PRODUIT U
Where Not Exists (Select V.*
From LIGNE_COMMANDE V
Where U.NUPRO = V.PRODUIT_NUPRO
And T.COMMANDE_NUCOM = V.COMMANDE_NUCOM));

On peut traduire la requête par l’enchaînement d’opérateur (appelé
division relationnelle) suivant :
r1 = Π[NUPRO] (Produit)
r2 = Π[Commande_NUCOM, Produit_NUPRO] (Ligne_Commande)
r3 = ((Π[Commande_NUCOM] (r2)) ⊗ (r1)) - (r2)

9


Le langage SQL

r4 = (Π[Commande_NUCOM] (r2)) - (Π[Commande_NUCOM] (r3))
Dividende = spr (SPR)
Diviseur = spr’ (SPR’) et SPR’ ⊆ SPR
Quotient = (spr) ÷ (spr’) sur (SPR - SPR’)
(Π[SPR - SPR’] (spr)) - (Π[SPR - SPR’] (((Π[SPR - SPR’] (spr)) ⊗ (spr’)) - (spr)
Remarque
La requête « Quels sont les numéros des commandes qui comportent les
mêmes produits au moins que la commande numéri 751 ? » est traduite
comme suit.
{t.Commande_NUCOM / t ∈ Ligne_commande ∀ u (u ∈ Ligne_commande
∧ u.Commande_NUCOM = 751 ⇒ ∃ v (v ∈ Ligne_commande ∧
u.Produit_NUPRO = v.Produit_NUPRO ∧ t.Commande_NUCOM =
v.Commande_NUCOM))}
On remplace l’implique et ∀ u :
{t.Commande_NUCOM / t ∈ Ligne_commande ¬∃ u ¬(¬(u ∈
Ligne_commande ∧ u.Commande_NUCOM = 751) ∨ ∃ v (v ∈
Ligne_commande ∧ u.Produit_NUPRO = v.Produit_NUPRO ∧
t.Commande_NUCOM = v.Commande_NUCOM))}
On simplifie :
{t.Commande_NUCOM / t ∈ Ligne_commande ¬∃ u (u ∈ Ligne_commande
∧ u.Commande_NUCOM = 751 ¬ ∃ v (v ∈ Ligne_commande ∧
u.Produit_NUPRO = v.Produit_NUPRO ∧ t.Commande_NUCOM =
v.Commande_NUCOM))}
SQL :
Where Not Exists (Select U.*
Where U.COMMANDE_NUCOM = 751
And Not Exists (Select V.*
From LIGNE_COMMANDE V
Where U.PRODUIT_NUPRO = V.PRODUIT_NUPRO
And T.COMMANDE_NUCOM = V.COMMANDE_NUCOM));

10


Le langage SQL

Le Langage d’Interrogation des Données (LID)

L’énoncé Select

Syntaxe
Select [ALL | Distinct] {* | table.* | expr [c_alias]}
[, {table.* | expr [c_alias]} ] ...
From [user.] table [t_alias] [, [user.] table [t_alias]] ...
[Where condition]
[Group By expr [, expr] ...
[Having condition]
[Order By {expr | position} [Asc | Desc]
[, {expr | position} [Asc | Desc]];

Tout énoncé Select comprend au moins les clauses Select et From. Les
quatre autres sont facultatives.
L’ordre des clauses est fixe.
Les mots clefs soulignés sont des options par défaut.
Clause Description
All Indique que toutes les lignes qui satisfont l’énoncé Select
seront affichées.
Distinct Indique que seules les lignes différentes seront affichées.
* Indique que toutes les colonnes de toutes les tables listées
dans le From seront affichées.
table.* Indique que toutes les colonnes de la table nommée seront
affichées.
expr Désigne une expression.
c_alias Donne un nom différent à la colonne désignée par expr. Ce
nouveau nom (c_alias) apparaîtra comme entête de colonne
mais ne peut être utilisée pour nommer cette colonne ou y
faire référence dans la requête.
[user].table Indique les tables ou vues à afficher. L’option « user »
permet de préciser le nom du propriétaire de la table (par
défaut c’est l’utilisateur courant).
t_alias Donne un nom différent à la table nommée. La table ne peut
alors être nommée dans toute la requête qu’en utilisant son
nouveau nom.
condition Enoncé d’une condition.
position Désigne une colonne en donnant sa position relative dans la
liste des colonnes du Select plutôt qu’en utilisant son nom.
Asc | Desc Indique l’ordre (croissant ou décroissant) de tri d’une
colonne.
colonne Indique le nom d’une colonne appartenant à une table listée
dans la clause From.

L’exécution d’un énoncé Select se fait de la manière suivante :
11


Le langage SQL

• Définit la table opérande (From).
• Sélectionne les lignes qui satisfont la condition (Where).
• Regroupe les lignes lorsque les valeurs sont égales dans les
colonnes mentionnées (Group By).
• Sélectionne les groupes de lignes qui satisfont la condition
(Having).
• Projette sur les colonnes indiquées (Select).
• Trie les lignes (Order By).
Exemple : « Quels sont les numéros (triés en ordre croissant) des clients
ayant passé plus d’une commande depuis le 16 septembre ? »
Cette question peut être traduire en SQL par :
Select X.CLIENT_NUCLI
From COMMANDE X
Where X.DATECOM > ‘15/09/91’
Group By X.CLIENT_NUCLI
Having Count (*) > 1
Order By X.CLIENT_NUCLI;

Avec la relation Commande suivante, on obtiendrait :
NUCOM DATECOM CLIENT_NUCLI
750 15/09/91 5621
754 21/09/91 5852
752 19/09/91 5439
751 16/09/91 5852
753 19/09/91 7436
755 27/09/91 5621
756 27/09/91 5439

On obtiendrait l’enchaînement suivant :
From COMMANDE X
750 15/09/91 5621
754 21/09/91 5852
752 19/09/91 5439
751 16/09/91 5852
753 19/09/91 7436
755 27/09/91 5621
756 27/09/91 5439

Where X.DATECOM > ‘15/09/91’
NUCOM DATECOM CLIENT_NUCL
I
754 21/09/91 5852
752 19/09/91 5439
751 16/09/91 5852
12


Le langage SQL

753 19/09/91 7436
755 27/09/91 5621
756 27/09/91 5439

751 16/09/91 5852
754 21/09/91 5852
752 19/09/91 5439
756 27/09/91 5439
753 19/09/91 7436
755 27/09/91 5621

Having Coung (*) > 1
751 16/09/91 5852
754 21/09/91 5852
752 19/09/91 5439
756 27/09/91 5439

CLIENT_NUCLI
5852
5439

CLIENT_NUCLI
5439
5852

La clause From
La clause From identifie la ou les tables auxquelles on accèdera pendant
l’exécution de l’énoncé Select.
Deux tables peuvent avoir le même nom si elles appartiennent à
desutilisateurs différents. Pour faire référence à une table crée par un autre
utilisateur, on doit spécifier le nom de cet utilisateur en notation pointée,
avant le nom donné à cette table par cet utilisateur.
Exemple. Supposons que la table Client ait été créée par Martin et que celui-
ci m’en ait autorisé l’accès. Pour lire son contenu, il faudrait faire « Select *
From MARTIN.CLIENT X; » Martin n’aurait qu’à faire « Select * From CLIENT
X; ».
Remarques :
• « MARTIN.CLIENT » est appelé un identificateur de table.
L’utilisation d’une table sans préfixe entraîne l’option par défaut du
13


Le langage SQL

préfixe par le nom de l’utilisateur courant (celui qui demande
l’exécution de la requête).
On peut faire la même remarque pour les vues.
• On a définit un t_alias pour la tale Client et nous l’éavons
renommée X pour toute la requête. Ceci explique le « X.* ».
La syntaxe de la clause From permet d’indiquer plusieurs identificateurs de
tables. L’exécution d’une requête portant sur plusieurs tables respecte l’ordre
d’exécution décrit dans le diagramme ci-dessus et commence par la
clauseFrom en calculant le produit cartésien des tables mentionnées dans la
clause From.
Exemple. La requête « Quels sont les noms des clients grossistes dont le taux
de remise est inférieur à celui consenti à Durand ? » peut être traduite en
SQL par « Select X.NOMCLI From CLIENT X, CLIENT Y Where U.NOMCLI =
‘DURAND’ And X.TR% < Y.TR%; » On remarque que l’utilisation d’un t_alias
est indispensable dans ce cas puisqu’il est possible de donner le même nom à
des colonnes appartenant à des tables différents.

La clause Where
La clause Where permet de définir grâce à une condition les lignes de la (ou
des) tables(s) listée(s) dans le From. Toutes les lignes apparaissant à l’issue
de l’exécution du From sont examinées pour voir si la condition est vraie ou
fausse. Si elle est vraie, la ligne est stockée dans une table de résultats
intermédiaires.
Une condition est une combinaison d’expressions et d’opérateurs logiques aui
est Vraie ou Fausse.
Le tableau ci-dessous nous permet d’étudier les principales formes que
prendre une condition.
Voici la liste des différents types de formes de condition :
Form Description
e
1 C’est une comparaison avec une expression ou le résultat d’une
requête : « <expr> <opérateur de comparaison> <expr> » ou
« <expr> <opérateur de comparaison> <requête> ».
2 C’est une comparaison avec l’un ou tous les éléments d’une liste ou
le résultat d’une requête : « <expr> <comparaison> {ANY | ALL }
(<expr>[, <expr>] ...} » ou « <expr> <comparaison> {ANY | ALL }
<requête> ».
3 C’est un test d’appartenance à une liste ou au résultat d’une
requête : « <expr> [Not} In (<expr>[, <expr} ...) » ou « <expr>
[Not] In <requête> ».
4 C’est un test d’inclusion dans un intervalle : « <expr> [Not]
Between <expr> And <expr> ».
5 C’est un test pour une valeur non définie (valeur Null) : « <expr> Is
[Not] ».
6 C’est un test pour l’existence de lignes dans une requête : « Exists
<requête> ».
7 C’est une combinaison d’autres conditions : « (<condition>) »,
14


Le langage SQL

« Not <condition> », « <condition> And <condition> » et
« <condition> Or <condition> ».

Formes conditionnelles sans sous-requête :
1. La comparaison simple (forme 1)
Voici quelques exemples :
Requête SQL Remarques
Quel est le nom du client Select X.NOMCLI From X.NUCLI est un nom de
5621 ? CLIENT X Where X.NUCLI = colonne (ou attribut). « = » est
5621; un opérateur de comparaison.
« 5621 » est une constante
numérique.
Quels sont les noms des clients Select X.NOM From CLIENT « <> » est équivalent à « != » et
n’habitant pas Paris ? X Where X.VILLE <> à « ^= ».
‘PARIS’;
Quels sont les noms desproduits Select X.NOMPRO From On aurait aussi pu utiliser
sur lesquels la différence PV PRODUIT X Where PR + 100 « Where PV - 100 - PR = 0 ».
moins PR est égale à 100 ? = PV; ‘PARIS’ < ‘ROUEN’ et ‘Paris’
<> ‘PARIS’.
Quels sont les numéros des Select X.NUCOM From
commandes passées depuis le 15 COMMANDE X Where
Décembre 1990 ? X.DATECOM >= ‘15/12/90’;
Quels sont les numéros des Select X.NUCOM From SysDate est une fonction
commandes passées depuis 8 COMMANDE X Where retournant la date (et l’heure)
jours (le jour deconsultation X.DATECOM + 8 >= SysDate; courante.
n’étant pas compris) ?

2. L’opérateur Like (forme 2)
Quels sont les noms des clients Select X.NOMCLI From « % » représente zéro, un ou
dont le nom commence par CLIENT X Where X.NOMCLI plusieurs caractères.
‘DU’ ? Like ‘DU%’;
Quels sont les noms des clients Select X.NOMCLI From « _ » représente un caractère (et
dont le nom commence par un CLIENT X Where X.NOMCLI un seul). Pour rechercher des
‘D’, dont l’avant dernière lettre Like ‘D%N_’; clients comportant « _ »,
est un ‘N’. « % », ..., il faut utiliser une
fonction Translate.

3. Les fonctions multiples (forme 3)
Une clause Where peut contenir des conditions multiples si les opérateurs
logiques suivants sont utilisés : « (<condition>), Not <condition>,
<condition> And <condition>, <condition> Or <condition> ». Cette liste
donnée par ordre de précédence est décroissant.
« Where C1 And C2 Or C3 And C4 » est évalué comme suit :
C1 And C2 = R1
C3 And C4 = R2
R1 Or R2 = R3
« Where C1 And (C2 Or C3) » est évalué comme suit :
(C1 Or C2) = R1
R1 And C1 = R2

15


Le langage SQL

Certains systèmes ne gèrent pas l’ordre de précédence des opérateurs
logiques. Vous devez alors utiliser les parenthèses : « Where (C1 And C2) Or
(C3 And C4) ».
4. La comparaison avec intervalle (forme 4)
Quels sont les noms des clients Select X.NOMCLI From Un équivalent, plus lourd,
auxquels Parsifal accorde un CLIENT X Where X.TR% serait :
taux de remise compris entre 30 Between 30 And 35; Select X.NOMCLI From
et 35 % (bornes comprises) ? CLIENT X Where X.TR% >=
30 And X.TR% <= 35;
Quels sont les noms des clients Select X.NOMCLI From Not (A >= B And A <= C) =
auxquels Parsifal accorde un CLIENT X Where X.TR% Not ((A < B) Or (A > C))
taux de remise inférieur à 30 % Between 30 And 35;
ou un taux de remise supérieur
à 35 % ?

5. L’utilisation des opérateurs In, Any, All (forme 2 et 3)
Quels sont les noms des clients Avec la forme 7 : « In » est équivalent à « =
qui habitent Lille, Paris, Lyon Select X.NOMCLI From CLIENT Any ».
ou Caen ? X Where VILLE = ‘PARIS’ Or « Not In » est équivalent à « !
VILLE = ‘LYON’ Or VILLE = = Any ».
‘CAEN’; Il vaut mieux utiliser « In ».
Select X.NOMCLI From CLIENT Les valeurs entre parenthèses
X Where VILLE = Any (‘LILLE’, doivent respecter les règles
‘PARIS’, ‘LYON’, ‘CAEN’); suivantes :
Select X.NOMCLI From CLIENT - Elles ne doivent comprendre
X Where X.VILLE In (‘LILLE’, que des constantes.
‘PARIS’, ‘LYON’, ‘CAEN’);
- Elles doivent toutes être du
même type.
Quels sont les numéros des Select X.NUCLI From CLIENT X
clients n’habitant pas Paris qui Where X.VILLE <> ‘PARIS’ And
bénéficient d’un taux de remise X.TR% > Any (36, 25, 32);
supérieur à l’un des taux
suivants : 36, 25, 32.
Quels sont les numéros des Select X.NUCLI From CLIENT X
clients n’habitant pas Paris qui Where X.VILLE <> ‘PARIS’ And
bénéficient d’un taux de remise X.TR% > All (36, 25, 32);
supérieur à chacun des taux
suivants : 36, 25, 32 ?
Quelles sont les grandes Select X.NUCLI From CLIENT X Chaque couple
surfaces (GS) qui bénéficient Where (X.CATCLI_CATEG, (X.CATCLI_CATEG, X.TR
d’un taux de remise supérieur à X.TR%) > All ((GR, 36), (GR, %) est comparé à chaque
tous les taux de remise des 38)); élément de ((GR, 36); (GR,
grossistes (GR) ? 38)) et le numéro du client
correspondant ne fait partie du
résultat que lorsque toutes les
comparaisons rendent la
condition Vraie.

Formes conditionnelles avec sous-requêtes
1. La notion de sous-requête (forme 1)
Quels sont les noms des clients Select X.NOMCLI From Ceci est équivalent à :
qui sont de la même catégorie CLIENT X Where Select X CATCLI_CATEG
que Durand ? X.CATCLI_CATEG = (Select From CLIENT X Where

16


Le langage SQL

Y.CATCLI_CATEG From X.NOMCLI = ‘DURAND’;
CLIENT Y Where Y.NOMCLI (retourne ‘GR’)
= ‘DURAND’);
Select X.NOMCLI From
CLIENT X Where
X.CATCLI_CATEG = ‘GR’;
La forme « <expr> <opérateur
de comparaison> <requête> »
ne peut être utilisée qu’avec une
sous-requête ne ramenant
qu’une seule valeur.

2. Les opérateurs Any et All (forme 2)
Quels sont les noms des clients Select X.NOMCLI From
dont le taux de remise accordé CLIENT X Where TR% > Any
est supérieur à celui de Durand (Select Y.TR% From CLIENT
ou de Dupont ? Y Where Y.NOMCLI =
‘DURAND’ Or Y.NOMCLI =
‘DUPONT’);
Quels sont les noms des clients Select X.NOMCLI From
dont le taux de remise est CLIENT X Where X.TR% <
inférieur à celui de tout client de All (Select Y.TR% From
catégorie GR habitant Paris ? CLIENT Y Where Y.VILLE =
‘PARIS’ And
Y.CATCLI_CATEG = ‘GR’);

3. L’opérateur In (forme 3)
Quels sont les noms des produits Select X.NOMPRO From PRODUIT X
du même type que les produits Where X.TYPROD_TYP In (Select
« Sauteuse GM » ou « Faitout Y.TYPROD_TYP Where Y.NOMPRO
GM » ? = ‘SAUTEUSE GM’ Or Y.NOMPRO =
‘FAITOUT GM’;
domestiques ? Where X.TYPROD_TYP In (Select
Y.TYP From TYPROD Y Where
Y.NOMTYPE = ‘DOMESTIQUE’);
non domestiques ? Where X.TYPROD_TYP Not In (Select
Y.TYP From TYPROD Y Where
Y.NOMTYPE = ‘DOMESTIQUE’);

4. L’opérateur Exists (forme 6)
Quels sont les noms des Select X.NOMCLI From Equivalent à :
clients qui ont passé une CLIENT X Where Exists Select X.NOMCLI From CLIENT X
commande au moins ? (Select Y.* From Where X.NUCLI In (Select
COMMANDE Y Where Y.CLIENT_NUCLI From
X.NUCLI COMMANDE Y);
Y.CLIENT_NUCLI);
(Quels sont les noms des clients dont le
(Quels sont les noms des clients numéro apparaît au moins une fios
tels qu’il existe au moins un dans la colonne CLIENT_NUCLI de
tuple dans l’ensemble de tuples la relation COMMANDE ?)
résultant de l’exécution de la
sous-requête ?)

Remarques :

17


Le langage SQL

• La clause Where de la sous-requête permet de comparer X.NUCLI
(le numéro du client examiné dans la requête principale) avec
chacun des Y.CLIENT_NUCLI (de la table COMMANDE). La sous-
requête est dite à référence externe (ou sous-requête corrélée).
• « Select X.NOMCLI From CLIENT X Where Exists (Select Y.* From
COMMANDE Y); » liste tous les noms de clients à condition que la
relation COMMANDE comporte au moins un tuple.

La clause Group By et Having
La clause Group By permet de regrouper les lignes résultant de la clause
From et de la clause Where.
La clause Having permet de sélectionner certains groupes d’après leurs
caractéristiques.
Quels sont les numéros de Select X.COMMANDE_NUCOM Equivalent à :
commandes comportant une From LIGNE_COMMANDE X Select Distinct
ligne de commande au moins ? Group By X.COMMANDE_NUCO
X.COMMANDE_NUCOM; M From
LIGNE_COMMANDE X;
Quels sont les numéros de Select X.COMMANDE_NUCOM
commandes comportant trois From LIGNE_COMMANDE X
lignes au moins ? Group By
X.COMMANDE_NUCOM Having
Count (*) >= 3;
Quels sont les numéros des Select X.CLIENT_NUCLI From
clients ayant passé plus de deux COMMANDE X Group By
commandes à la même date ? X.CLIENT_NUCLI, X.DATECOM
Having Count (*) > 2;
Quels sont les numéros des Select X.CLIENT_NUCLI From
clients ayant passé plus de deux COMMANDE X Group By
commandes à des dates X.CLIENT_NUCLI, X.DATECOM
différentes ? Having Count (Distinct
X.DATECOM) > 2;

Les fonctions de groupe utilisables avec les clauses Having et Select sont les
suivantes :
Fonction Description
Avg ([All | Distinct] n) Retourne la valeur moyenne de n pour le groupe (en ignorant les
valeurs Null).
Count ([All | Distinct] expr) Retourne le nombre de lignes pour lesquelles expr n’est pas non
défini (Null).
Count (*) Retourne le nombre de lignes dans la table, y compris les doubles et
les lignes comportant des valeurs Null.
Max ([All | Distinct] expr) Retourne la valeur maximum prise par expr.
Min ([All | Distinct] expr) Retourne la valeur minimum prise par expr.
StdDev ([All | Distinct] n) Retourne la valeur de l’écart type de n (en ignorant les valeurs Null).
Sum ([All | Distinct] n) Retourne la valeur de la somme de n.
Variance ([All | Distinct] n) Retourne la valeur de la variance de n (en ignorant les valeurs Null).

Remarques :
• « n » désigne un argument de type Number.
• « expr » désigne un argument de type Number, Char ou Date.

18


Le langage SQL

La clause Select
La clause Select permet d’obtenir un « sous-ensemble vertical » d’une table,
par opposition à la clause Where qui travaille horizontalement.
Sans clause Group By :
« expr c_alias » permet de donner un nouveau nom à une colonne mais
uniquement pour l’affichage. Ce nouveau nom n’est pas connu dans la
requête.
Les formes d’expression sont les suivantes :
Form Description
e
1 nom_de_coonne, constante ou valeur spéciale
2 une fonction
3 une combinaison d’expressions (ordre de précédence)
4 une liste parenthésée d’expressions

Quels sont les numéros des select X.CLIENT_NUCLI
clients ayant plus d’une NUCLIPLUS1 From
commandee en cours ? Commande X Group By
X.CLIENT_NUCLI Having
Count (*) > 1;
Faire un état des stocks de Select X.NOMPRO X.NOMPRO, X.QES, SysDate
produits chiffré au prix de Nom_du_produit, X.QES sont de la forme 1.
revient et daté. Quant_en_stock, X.QES * X.QES * X.PR est de la forme
X.PR Valeur, SysDate Date 3.
From PRODUIT;

1. Les fonctions de groupe sont utilisables mais elles s’appliquent à
la relation résultant de la clause Where.
Quel est le prix de vente Select Max (X.PV)
maximum d’un produit PV_Max From
de type 1 ? PRODUIT X Where
X.TYPROD_TYP = 1;
Quels sont les numéros Select
des commandes portant X.COMMANDE_NUC
sur des produits dont la OM From
marge (PV - PR) est la LIGNE_COMMAND X
plus élevée ? Where
X.PRODUIT_NUPR In
(Select Y.NUPRO From
PRODUIT Y Where
Y.PV - Y.PR = (Select
Max (Z.PV - Z.PR)
From PRODUIT Z));

2. Les fonctions arithmétiques
Fonction Description Exemple
Abs (n) Retourne la valeur Abs (-32) retourne 32.
19


Le langage SQL

absolue de n.
Ceil (n) Retourne l’entier Ceil (12.43) retourne 13.
immédiatement
supérieur ou égal à n.
Floor (n) Retourne l’entier Floor (12.43) retourne
immédiatement inférieur 12.
ou égal à n.
Mod (m, n) Retourne le reste de la Mod (19, 4) retourne 3.
division de m par n. Mod (19, 0) retourne 19.
Power (m, n) Donne m élevé à la Power (4, 2) retourne 16.
puissance n.
Round (n[, m]) Retourne n arrondi avec Round (16.786, 2)
m décimales. Si m est retourne 16.79.
omis, pas de décimales. Round (16.786) retourne
Si m est négatif alors 17.
arrondi sur m chiffres
avant le point décimal (- Round (16.786, -1)
1 pour un arrondi aux retourne 20.
dizaines, -2 pour un
arrondi aux centaines).
Sign (n) Retourne -1 si n < 0, 0 si Sign (-2) retourne -1.
n = 0, 1 si n > 0.
SqrT (n) Retourne la racine SqrT (36) retourne 6.
carrée de n.
Trunc (n[, m]) Retourne n tronqué avec Trunc (16.786, 2)
m décimales. Si m est retourne 16.78.
omis, pas de décimales. Trunc (16.786) retourne
Si m est négatif, 16.
troncature sur m chiffres
à gauche du point Trunc (16.786, -1)
décimal. retourne 10.

3. Les fonctions caractères retournant des caractères
Chr (n) Retourne le caractère Chr (75) retourne K.
ayant n comme code
ASCII ou EBCDIC.
InitCap (char) Retourne Char, avec une InitCap (‘MR
majuscule en tête de DUPONT’) retourne Mr
chaque mot et des Dupont.
minuscules ensuite (un
mot est délimité par des
espaces).
Lower (char) Retourne Char en Lower (‘MR DUPONT’)
minuscules. retourne mr dupont.
Lpad (char1, n[, char2]) Retourne Char1 Lpad (D, 4, +) retourne
complété à droite +++D.
jusqu’à la longueur n
avec des Char2 (blanc
par défaut).
Ltrim (char[, set]) Retourne Char, après Ltrim (‘abaabbAbbaa’,
avoir retiré les ‘ab’ retourne ‘Abbaa’.
caractères appartenant à
20


Le langage SQL

Set situés avant le
premier caractère de
Char n’appartenant pas
à Set (blanc par défaut).
Replace (char, Retourne Char avec Replace (‘BASE’, ‘BA’,
search_string[, toute ocurrence de ‘DATABA’) retourne
replacement_string])) Search_string remplacée ‘DATABASE’.
par Replacement_string. Replace (‘BASE’, ‘BA’)
retourne ‘SE’.
Rpad (char1, n[, char2]) Retourne Char1 Rpad (D, 4, +) retourne
complété à gauche D+++.
jusqu’à la longueur n
avec des Char2 (blanc
par défaut).
Rtrim (char[, set]) Retourne Char, après Ltrim (‘abaabbAbbaa’,
avoir retiré les ‘ab’ retourne ‘abaabbA’.
caractères appartenant à
Set situés avant le
dernier caractère de
Char n’appartenant pas
à Set (blanc par défaut).
SoundEx (char) Retourne une chaîne de
caractères représentant
les sons (en anglais) du
mot dans char.
Retourne une
représentation
phonétique de chaque
mot et permet de
comparer des mots qui
s’écrivent différemment
mais se prononcent de la
même façon.
SubStr (char, m,[, n]) Retourne une partie de SubStr (‘ABCDEFG’, 2,
Char commençant au 3) retourne BCD.
caractère de rang m et SubStr (‘ABCDEFG’, 2)
d’une longueur de n retourne BCDEFG.
caractères. Si n est omis,
jusqu’à la fin de Char.
Translate (char, from, Retourne Char après Translate
to) avoir remplacé toutes les (‘DATABASE’, ‘AB’,
occurrences de From par ‘$@’) retourne
les caractères ‘D$T$@$SE’)
correspondants dans To. Translate
(‘DATABASE’, ‘AB ‘)
retourne ‘D T SE’.
Upper (char) Retourne Char en Upper (‘mr dupont’)
majuscules. retourne ‘MR
DUPONT’.

4. Les fonctions caractères retournant des valeurs numériques
Ascii (char) Retourne la valeur du Ascii (‘QUE’) retourne
premier caractère de 81.
Char.

21


Le langage SQL

Instr (char1, char2[, n[, Retourne la position de Instr (‘aaaabcaacdeaab’,
m]]) la mième occurrence de ‘a’, 5, 4) retourne 13.
Char2 dans Char1, en
commençant la
recherche à la position n
(n = 1 et m = 1 par
défaut).
Length (char) Retourne la longueur de Length (‘DATABASE’)
Char. retourne 8.

5. Les fonctions de conversion
To_Char (n[, format]) Convertit une valeur de To_Char (520, ‘09999’)
type Number en une retourne 00520.
valeur de type Char en
utilisant un format
optionnel d’édtition
numérique.
To_Char (d[, format]) Convertit une valeur de To_Char (‘01-Jan-96’,
type Date en une valeur ‘DD/MM/YY’) retourne
de type Char en utilisant 01/01/96.
un format optionnel
d’édition date.
To_Date (char[, format]) Convertit une valeur de To_Date (‘Lundi, 01
type Char en une valeur Janvier 1996’, ‘Day, DD
de type de donnée Date. MONTH YYYY’)
retourne ‘01-Jan-1996’.
To_Number (char) Convertit une valeur de To_Number (‘520’)
type Char représentant retourne 520.
un nombre en une valeur To_Number (‘SubStr
de type Number. (‘valeur520’, 7, 3))
retourne 520.
CharToRowId (char) Convertit une valeur du CharToRowId
type Char au type RowId (‘0000000F.0003.0002’)
(18 caractères). :
- numéro de bloc
0000000F,
- numéro de tuple :
0003,
- numéro de fichier
0002.
RowWidToChar (rowid) Convertit une valeur
RowId en une donnée de
type Char.

Voici le tableau de conversion des types de données courants :
De En Char Number Date
Char / To_Number To_Date
Number To_Char / To_Date
Date To_Char (invalide) /

Les formats d’édition numériques sont :
Format Exemple Valeur Affichage
22


Le langage SQL

9 99999 520 520
9 999 1520 ###
0 09999 520 00520
B B9999 520 520
B B9999 0
MI 9999MI -520 520-
9 9999 -520 -520
PR 9999PR -520 <520>
, 9,999 1520 1,520
. 999.99 520.43 520.43
V 999V99 52.437 5244 (multiple
valeur par 10n, n
= nombre de 9
après « V »)
E 9.99EEEE 12000 1.2E+04 = 1.2 x
104

Les formats d’édition date sont :
Format Exemple Valeur Affichage
YYYY 1991 1991
YYY 1991 991
YY 1991 91
Y 1991 1
MM JANVIER 01
MONTH JANVIER JANVIER
Month JANVIER Janvier
month JANVIER janvier
MON JANVIER JAN
DDD 31-Dec-91 365
DD 31-Dec-91 31
DAY 31-Dec-91 MARDI
MM/DD/YY 31-Dec-91 31/12/91
DD.MM.YYYY 31-Dec-91 31.12.1991
DD MONTH, 31-Dec-91 31 DECEMBRE,
YYYY 1991

6. Les fonctions date
Add_Months (d, n) Retourne la date d plus Add_Months (‘31-Dec-
n mois. « n » doit être 91’, 2) retourne ‘29-Fev-
un entier mais peut être 92’.
négatif.
Last_Day (d) Retourne la date du Last_Day (‘15-Dec-91’)
dernier jour du mois retourne ‘31-Dec-31’).
auquel appartient d.

23


Le langage SQL

Months_Between (d, e) Retourne le nombre de Months_Between (‘02-
mois entre les dates d et Fev-86’, ‘01-Jan-86’)
e. retourne 1.03225806.
Si d est postérieure à e
alors le résultat est
positif. Sinon, il est
négatif ou nul.
Next_Day (d, char) Retourne la date du Next_Day (‘20-Oct-91’,
premier jour de la ‘MARDI’) retourne ‘22-
semaine Char postérieur 10-91’.
à d.
Car doit être un nom de
jour de la semaine.
Round (d[, fmt]) Retourne la date d Round (‘30-Jun-91’, Y)
arrondie à l’unité définie retourne ‘01-Jan-91’.
dans fmt (par défaut le Round (‘01-Jul-91’, Y)
jour le plus proche). retourne ‘01-Jan-92’.
Round (‘16-Jul-91’, M)
retourne ‘01-Aou-91’.
SysDate Retourne la date et
l’heure système.

7. Les principales fonctions divers
Decode (expr, search1, Expr est comparé à Select X.NOMPRO,
resultat1[, search2, chacune des valeurs Decode
resultat2] ...[, default]) Search et retourne le (X.TYPROD_TYP, 1,
résultat correspondant ‘Domestique’, 2,
en cas d’égalité. ‘Professionnel’,
S’il n’y a aucune égalité, ‘Electroménager’)
alors la valeur Default Type_du_produit From
est retournée. PRODUIT X;
Expr peut être de tout
type de donnée; Search
doit être du même type
que Expr.
La valeur retournée est
forcée au même type que
Resultat1.
Dump (expr[, Affiche la valeur d’une
display_format[, expression en format
start_position[, interne « display
length]]]) format » permet de
choisir entre 8 ou octal,
10 décimal 16 pour hexa
et 17 pour caractère.
Start_position et Length
permettent de limiter
l’affichage.
Nvl (expr1, expr2) Si Expr1 est Null, Nvl (To_Char (Qte)’,
retourne Expr2. ‘Quantité non définie’)
Si Expr1 n’est pas Null,
retourne Expr1.
Expr1 et Expr2 peuvent
24


Le langage SQL

être de tout type mais
Expr2 doit être du même
type que Expr1.
Vsize (expr) Retourne le nombre
d’octets utilisés pour
stocker Expr en mode de
représentation interne
Oracle.

Avec clause Group By :
La requête « Quels sont les numéros (triés en ordre croissant) des clients
ayant passé lpus d’une commande depuis le 16 septembre ? » peut être
traduite en SQL ainsi :
From COMMANDE X
Where X.DATECOM > ‘15-Sep-91 »
Having Count (*) > 1

Table Commande :
750 15/09/91 5621
754 21/09/91 5852
752 19/09/91 5439
751 16/09/91 5852
753 19/09/91 7436
755 27/09/91 5621
756 27/09/91 5439

Après exécution de Group By X.CLIENT_NUCLI, on obtient :
751 16/09/91 5852
754 21/09/91 5852
753 19/09/91 7436
752 19/09/91 5439
756 27/09/91 5439
755 27/09/91 5621

Cette « table intermédiaire » n’est accessible qu’au niveau de chaque groupe.
Seules les valeurs de CLIENT_NUCLI, sur lesquelles ont été faits les
regroupements, pourront être affichées à l’aide de :
Sera invalide « Select X.NUCOM » puisqu’il existe plusieurs NUCOM par
groupe créé.
Seront valides « Select Count (NUCOM) », « Select Max (NUCOM) » et
« Select Count (Distinct DATECOM) ».

25


Le langage SQL

En dehors des fonctions, tout attribut apparaissant dans Select doit aussi
appraître dans Group By : Select X.CLIENT_NUCLI, X.NUCOM From CLIENT X
... Group By X.CLIENT_NUCLI, X.NUCOM;

La clause Order By
La clause Order By est toujours la dernière de l’énoncé Select. Elle trie les
tuples du résultat sur une ou plusieurs colonnes.
de commandes triés par X.CLIENT_NUCLI,
numéro de client ? X.NUCOM From
COMMANDE X Order
By X.CLIENT_NUCLI;
de commandes triés par X.CLIENT_NUCLI,
numéro de commande ? X.NUCOM From
COMMANDE X Order
By X.CLIENT_NUCLI,
X.NUCOM;
Quels sont les numéros Select X.NUCOM,
de commande du Count (*) From
nombre de lignes LIGNE_COMMANDE
commandés par X Group By X.NUCOM
commande triés par Order By 2 Desc;
nombre de lignes
décroissant ?

26

Le langage SQL

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (20)

Similar a Le langage SQL

Similar a Le langage SQL (9)

Más de Bruno Delb

Más de Bruno Delb (20)

Le langage SQL