Bruno Delb                            http://www.brunodelb.com                        Date : 20/04/2002                   ...
Bruno Delb                http://www.brunodelb.com           Date : 20/04/2002                               Le langage SQ...
Bruno Delb                http://www.brunodelb.com         Date : 20/04/2002                           Le langage SQL     ...
Bruno Delb                 http://www.brunodelb.com        Date : 20/04/2002                             Le langage SQL   ...
Bruno Delb               http://www.brunodelb.com         Date : 20/04/2002                          Le langage SQL attrib...
Bruno Delb                   http://www.brunodelb.com            Date : 20/04/2002                                 Le lang...
Bruno Delb                      http://www.brunodelb.com              Date : 20/04/2002                                   ...
Bruno Delb                 http://www.brunodelb.com              Date : 20/04/2002                               Le langag...
Bruno Delb                       http://www.brunodelb.com                      Date : 20/04/2002                          ...
Bruno Delb                     http://www.brunodelb.com                 Date : 20/04/2002                                 ...
Bruno Delb                     http://www.brunodelb.com                     Date : 20/04/2002                             ...
Bruno Delb               http://www.brunodelb.com            Date : 20/04/2002                          Le langage SQL    ...
Bruno Delb                http://www.brunodelb.com            Date : 20/04/2002                            Le langage SQL ...
Bruno Delb                http://www.brunodelb.com                   Date : 20/04/2002                            Le langa...
Bruno Delb                    http://www.brunodelb.com                           Date : 20/04/2002                        ...
Bruno Delb                   http://www.brunodelb.com                              Date : 20/04/2002                      ...
Bruno Delb                  http://www.brunodelb.com                                Date : 20/04/2002                     ...
Bruno Delb                     http://www.brunodelb.com                                     Date : 20/04/2002             ...
Bruno Delb                   http://www.brunodelb.com                      Date : 20/04/2002                              ...
Bruno Delb                 http://www.brunodelb.com                     Date : 20/04/2002                            Le la...
Bruno Delb              http://www.brunodelb.com                           Date : 20/04/2002                          Le l...
Bruno Delb               http://www.brunodelb.com                       Date : 20/04/2002                            Le la...
Bruno Delb                http://www.brunodelb.com                     Date : 20/04/2002                           Le lang...
Bruno Delb               http://www.brunodelb.com                         Date : 20/04/2002                           Le l...
Bruno Delb               http://www.brunodelb.com                    Date : 20/04/2002                           Le langag...
Bruno Delb                http://www.brunodelb.com                   Date : 20/04/2002                             Le lang...
Prochain SlideShare
Chargement dans…5
×

Le langage SQL

1 622 vues

Publié le

Publié dans : Technologie
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
1 622
Sur SlideShare
0
Issues des intégrations
0
Intégrations
13
Actions
Partages
0
Téléchargements
159
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Le langage SQL

  1. 1. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 Le langage SQL SommaireLE 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................................................................8LE 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
  2. 2. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 Le langage SQLLe 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
  3. 3. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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
  4. 4. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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
  5. 5. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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
  6. 6. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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
  7. 7. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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; Algèbre relationnelle : 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 produitsnumé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
  8. 8. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 Le langage SQLQuels sont les numéros des commandes qui comportent simultanémentles 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 produitnuméro 10 et pas de produit numéro 80 ? Calcul à variables tuples : {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 From LIGNE_COMMANDE T Where T.PRODUIT_NUPRO = 10 And Not Exists (Select U.* From LIGNE_COMMANDE U Where T.COMMANDE_NUCOM = U.COMMANDE_NUCOM And U.PRODUIT_NUPRO = 80; Algèbre relationnelle : Π[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 Calcul à variables tuples : {(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; Algèbre relationnelle : On introduit l’opérateur du produit cartésien entre deux relations ⊗ : (r) ⊗ (s) = {(t, u) / t ∈ r, u ∈ s} 8
  9. 9. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 produitsproposés par Parsifal ? Calcul à variables tuples : {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 : Select T.COMMANDE_NUCOM From LIGNE_COMMANDE T 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)); Algèbre relationnelle : 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
  10. 10. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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. Calcul à variables tuples : {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 : Select T.COMMANDE_NUCOM From LIGNE_COMMANDE T Where Not Exists (Select U.* From LIGNE_COMMANDE 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
  11. 11. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 Le langage SQLLe 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
  12. 12. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 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 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
  13. 13. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 Le langage SQL 753 19/09/91 7436 755 27/09/91 5621 756 27/09/91 5439 Group By X.CLIENT_NUCLI NUCOM DATECOM CLIENT_NUCLI 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 NUCOM DATECOM CLIENT_NUCLI 751 16/09/91 5852 754 21/09/91 5852 752 19/09/91 5439 756 27/09/91 5439 Select X.CLIENT_NUCLI CLIENT_NUCLI 5852 5439 Order By X.CLIENT_NUCLI; CLIENT_NUCLI 5439 5852La 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
  14. 14. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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
  15. 15. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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) Voici quelques exemples : Requête SQL Remarques 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
  16. 16. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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) Voici quelques exemples : Requête SQL Remarques 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) Voici quelques exemples : Requête SQL Remarques 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) Voici quelques exemples : Requête SQL Remarques 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
  17. 17. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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) Voici quelques exemples : Requête SQL Remarques 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) Voici quelques exemples : Requête SQL Remarques 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’; Quels sont les noms des produits Select X.NOMPRO From PRODUIT X domestiques ? Where X.TYPROD_TYP In (Select Y.TYP From TYPROD Y Where Y.NOMTYPE = ‘DOMESTIQUE’); Quels sont les noms des produits Select X.NOMPRO From PRODUIT X 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) Voici quelques exemples : Requête SQL Remarques 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
  18. 18. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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. Voici quelques exemples : Requête SQL Remarques 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
  19. 19. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 Voici quelques exemples : Requête SQL Remarques 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. Voici quelques exemples : Requête SQL Remarques 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
  20. 20. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 Fonction Description Exemple 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
  21. 21. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 Fonction Description Exemple Ascii (char) Retourne la valeur du Ascii (‘QUE’) retourne premier caractère de 81. Char. 21
  22. 22. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 Fonction Description Exemple 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
  23. 23. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 Fonction Description Exemple 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
  24. 24. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 Fonction Description Exemple 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
  25. 25. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 : Select X.CLIENT_NUCLI From COMMANDE X Where X.DATECOM > ‘15-Sep-91 » Group By X.CLIENT_NUCLI Having Count (*) > 1 Order By X.CLIENT_NUCLI; Table Commande : 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 Après exécution de Group By X.CLIENT_NUCLI, on obtient : NUCOM DATECOM CLIENT_NUCLI 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 : Select X.CLIENT_NUCLI 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
  26. 26. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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. Voici quelques exemples : Requête SQL Remarques Quels sont les numéros Select de commandes triés par X.CLIENT_NUCLI, numéro de client ? X.NUCOM From COMMANDE X Order By X.CLIENT_NUCLI; Quels sont les numéros Select 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

×