SlideShare une entreprise Scribd logo
1  sur  26
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
Bruno Delb                http://www.brunodelb.com           Date : 20/04/2002

                               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
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
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
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
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
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 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
Bruno Delb                 http://www.brunodelb.com              Date : 20/04/2002

                               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 ?
     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
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 produits
proposé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
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
Bruno Delb                     http://www.brunodelb.com                     Date : 20/04/2002

                                    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
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
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
                    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
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
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
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
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
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
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
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
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
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
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
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
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
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

Contenu connexe

En vedette

La reforma laboral de 2012 y los Expedientes de Regulación de Empleo. Estudio...
La reforma laboral de 2012 y los Expedientes de Regulación de Empleo. Estudio...La reforma laboral de 2012 y los Expedientes de Regulación de Empleo. Estudio...
La reforma laboral de 2012 y los Expedientes de Regulación de Empleo. Estudio...
Universidad Autónoma de Barcelona
 
Sobre el Estado del Bienestar y el modelo social europeo. ¿Qué futuro para la...
Sobre el Estado del Bienestar y el modelo social europeo. ¿Qué futuro para la...Sobre el Estado del Bienestar y el modelo social europeo. ¿Qué futuro para la...
Sobre el Estado del Bienestar y el modelo social europeo. ¿Qué futuro para la...
Universidad Autónoma de Barcelona
 
Ley de empleo. Financiación de las PAE y servicios prestados a la ciudadanía ...
Ley de empleo. Financiación de las PAE y servicios prestados a la ciudadanía ...Ley de empleo. Financiación de las PAE y servicios prestados a la ciudadanía ...
Ley de empleo. Financiación de las PAE y servicios prestados a la ciudadanía ...
Universidad Autónoma de Barcelona
 
Crisis económica y protección social. Estudio de la reforma de la normativa d...
Crisis económica y protección social. Estudio de la reforma de la normativa d...Crisis económica y protección social. Estudio de la reforma de la normativa d...
Crisis económica y protección social. Estudio de la reforma de la normativa d...
Universidad Autónoma de Barcelona
 
Ultraactividad. Convenio de artes gráficas de Bizkaia. El TSJ desestima el re...
Ultraactividad. Convenio de artes gráficas de Bizkaia. El TSJ desestima el re...Ultraactividad. Convenio de artes gráficas de Bizkaia. El TSJ desestima el re...
Ultraactividad. Convenio de artes gráficas de Bizkaia. El TSJ desestima el re...
Universidad Autónoma de Barcelona
 
Aproximaciones
AproximacionesAproximaciones
Aproximaciones
Vanessa
 
Exploracion de pares craneales
Exploracion de pares cranealesExploracion de pares craneales
Exploracion de pares craneales
UNAM
 

En vedette (20)

Cours+sql++ +base+de+données+-+bac+informatique+(2009-2010)++elève++khmiri+zied
Cours+sql++ +base+de+données+-+bac+informatique+(2009-2010)++elève++khmiri+ziedCours+sql++ +base+de+données+-+bac+informatique+(2009-2010)++elève++khmiri+zied
Cours+sql++ +base+de+données+-+bac+informatique+(2009-2010)++elève++khmiri+zied
 
Informatique s3
Informatique s3Informatique s3
Informatique s3
 
Sql
SqlSql
Sql
 
SGBDR - MySQL
SGBDR - MySQLSGBDR - MySQL
SGBDR - MySQL
 
Le langage sql
Le langage sqlLe langage sql
Le langage sql
 
SQL partie III
SQL partie IIISQL partie III
SQL partie III
 
Requisitos Fitosanitarios para la Importación de Productos Agropecuarios
Requisitos Fitosanitarios para la Importación de Productos AgropecuariosRequisitos Fitosanitarios para la Importación de Productos Agropecuarios
Requisitos Fitosanitarios para la Importación de Productos Agropecuarios
 
Incidiendo en los presupuestos públicos para incrementar el financiamiento p...
 Incidiendo en los presupuestos públicos para incrementar el financiamiento p... Incidiendo en los presupuestos públicos para incrementar el financiamiento p...
Incidiendo en los presupuestos públicos para incrementar el financiamiento p...
 
Yeombley (Côte d'Ivoire)
Yeombley (Côte d'Ivoire)Yeombley (Côte d'Ivoire)
Yeombley (Côte d'Ivoire)
 
El transporte no urgente de usuarios de la sanidad pública como prestación s...
El transporte no urgente de usuarios de la sanidad pública  como prestación s...El transporte no urgente de usuarios de la sanidad pública  como prestación s...
El transporte no urgente de usuarios de la sanidad pública como prestación s...
 
La reforma laboral de 2012 y los Expedientes de Regulación de Empleo. Estudio...
La reforma laboral de 2012 y los Expedientes de Regulación de Empleo. Estudio...La reforma laboral de 2012 y los Expedientes de Regulación de Empleo. Estudio...
La reforma laboral de 2012 y los Expedientes de Regulación de Empleo. Estudio...
 
Normas aplicables para exportar prendas de niños y bebes a EE.UU.
Normas aplicables para exportar prendas de niños y bebes a EE.UU.Normas aplicables para exportar prendas de niños y bebes a EE.UU.
Normas aplicables para exportar prendas de niños y bebes a EE.UU.
 
Sobre el Estado del Bienestar y el modelo social europeo. ¿Qué futuro para la...
Sobre el Estado del Bienestar y el modelo social europeo. ¿Qué futuro para la...Sobre el Estado del Bienestar y el modelo social europeo. ¿Qué futuro para la...
Sobre el Estado del Bienestar y el modelo social europeo. ¿Qué futuro para la...
 
Ley de empleo. Financiación de las PAE y servicios prestados a la ciudadanía ...
Ley de empleo. Financiación de las PAE y servicios prestados a la ciudadanía ...Ley de empleo. Financiación de las PAE y servicios prestados a la ciudadanía ...
Ley de empleo. Financiación de las PAE y servicios prestados a la ciudadanía ...
 
Crisis económica y protección social. Estudio de la reforma de la normativa d...
Crisis económica y protección social. Estudio de la reforma de la normativa d...Crisis económica y protección social. Estudio de la reforma de la normativa d...
Crisis económica y protección social. Estudio de la reforma de la normativa d...
 
Ultraactividad. Convenio de artes gráficas de Bizkaia. El TSJ desestima el re...
Ultraactividad. Convenio de artes gráficas de Bizkaia. El TSJ desestima el re...Ultraactividad. Convenio de artes gráficas de Bizkaia. El TSJ desestima el re...
Ultraactividad. Convenio de artes gráficas de Bizkaia. El TSJ desestima el re...
 
IECBW choisit EASI financials comme nouveau logiciel de comptabilite
IECBW choisit EASI financials comme nouveau logiciel de comptabiliteIECBW choisit EASI financials comme nouveau logiciel de comptabilite
IECBW choisit EASI financials comme nouveau logiciel de comptabilite
 
Aproximaciones
AproximacionesAproximaciones
Aproximaciones
 
Exploracion de pares craneales
Exploracion de pares cranealesExploracion de pares craneales
Exploracion de pares craneales
 
Mise en place d'un cadre sectoriel de qualification
Mise en place d'un cadre sectoriel de qualificationMise en place d'un cadre sectoriel de qualification
Mise en place d'un cadre sectoriel de qualification
 

Similaire à Le langage SQL (9)

Catalogue général 2017 - Spécifique industriel
Catalogue général 2017 - Spécifique industrielCatalogue général 2017 - Spécifique industriel
Catalogue général 2017 - Spécifique industriel
 
Jaga Play FR
Jaga Play FRJaga Play FR
Jaga Play FR
 
T270 French KOLD-DRAFT Commercial Ice Machines
T270 French KOLD-DRAFT Commercial Ice MachinesT270 French KOLD-DRAFT Commercial Ice Machines
T270 French KOLD-DRAFT Commercial Ice Machines
 
6053422 T906 2 Ind B Dossier Mtce Corrective Arbre Lent
6053422 T906 2 Ind B Dossier Mtce Corrective Arbre Lent6053422 T906 2 Ind B Dossier Mtce Corrective Arbre Lent
6053422 T906 2 Ind B Dossier Mtce Corrective Arbre Lent
 
6053422 T906 2 Ind B Dossier Mtce Corrective Arbre Lent
6053422 T906 2 Ind B Dossier Mtce Corrective Arbre Lent6053422 T906 2 Ind B Dossier Mtce Corrective Arbre Lent
6053422 T906 2 Ind B Dossier Mtce Corrective Arbre Lent
 
Catalogo de Peças Colheitadeiras( SLC - JONH DEERE ) 6200 7100 7200
Catalogo de Peças Colheitadeiras( SLC - JONH DEERE ) 6200 7100 7200Catalogo de Peças Colheitadeiras( SLC - JONH DEERE ) 6200 7100 7200
Catalogo de Peças Colheitadeiras( SLC - JONH DEERE ) 6200 7100 7200
 
Daitsu ASD9KI-DB / ASD12KI-DB / ASD18KI-DB / ASD21KI-DB
Daitsu ASD9KI-DB / ASD12KI-DB / ASD18KI-DB / ASD21KI-DBDaitsu ASD9KI-DB / ASD12KI-DB / ASD18KI-DB / ASD21KI-DB
Daitsu ASD9KI-DB / ASD12KI-DB / ASD18KI-DB / ASD21KI-DB
 
1086178403 nights2004 2
1086178403 nights2004 21086178403 nights2004 2
1086178403 nights2004 2
 
6053422 T908 Ind A Mise En Situation
6053422 T908 Ind A Mise En Situation6053422 T908 Ind A Mise En Situation
6053422 T908 Ind A Mise En Situation
 

Plus de Bruno Delb

Plus de Bruno Delb (20)

Introduction to Swift (tutorial)
Introduction to Swift (tutorial)Introduction to Swift (tutorial)
Introduction to Swift (tutorial)
 
Android Lab Test : Storage of data with SharedPreferences (english)
Android Lab Test : Storage of data with SharedPreferences (english)Android Lab Test : Storage of data with SharedPreferences (english)
Android Lab Test : Storage of data with SharedPreferences (english)
 
Android Lab Test : Using the sensor gyroscope (english)
Android Lab Test : Using the sensor gyroscope (english)Android Lab Test : Using the sensor gyroscope (english)
Android Lab Test : Using the sensor gyroscope (english)
 
Android Lab Test : Using the network with HTTP (english)
Android Lab Test : Using the network with HTTP (english)Android Lab Test : Using the network with HTTP (english)
Android Lab Test : Using the network with HTTP (english)
 
Android Lab Test : Managing sounds with SoundPool (english)
Android Lab Test : Managing sounds with SoundPool (english)Android Lab Test : Managing sounds with SoundPool (english)
Android Lab Test : Managing sounds with SoundPool (english)
 
Android Lab Test : Using the text-to-speech (english)
Android Lab Test : Using the text-to-speech (english)Android Lab Test : Using the text-to-speech (english)
Android Lab Test : Using the text-to-speech (english)
 
Android Lab Test : Reading the foot file list (english)
Android Lab Test : Reading the foot file list (english)Android Lab Test : Reading the foot file list (english)
Android Lab Test : Reading the foot file list (english)
 
Android Lab Test : Creating a menu dynamically (english)
Android Lab Test : Creating a menu dynamically (english)Android Lab Test : Creating a menu dynamically (english)
Android Lab Test : Creating a menu dynamically (english)
 
Android Lab Test : Creating a dialog Yes/No (english)
Android Lab Test : Creating a dialog Yes/No (english)Android Lab Test : Creating a dialog Yes/No (english)
Android Lab Test : Creating a dialog Yes/No (english)
 
Android Lab Test : The styles of views (english)
Android Lab Test : The styles of views (english)Android Lab Test : The styles of views (english)
Android Lab Test : The styles of views (english)
 
Android Lab Test : Creating a menu context (english)
Android Lab Test : Creating a menu context (english)Android Lab Test : Creating a menu context (english)
Android Lab Test : Creating a menu context (english)
 
Android Lab Test : Using the camera preview (english)
Android Lab Test : Using the camera preview (english)Android Lab Test : Using the camera preview (english)
Android Lab Test : Using the camera preview (english)
 
Android Lab Test : The views, the Gallery (english)
Android Lab Test : The views, the Gallery (english)Android Lab Test : The views, the Gallery (english)
Android Lab Test : The views, the Gallery (english)
 
Android Lab Test : Using the WIFI (english)
Android Lab Test : Using the WIFI (english)Android Lab Test : Using the WIFI (english)
Android Lab Test : Using the WIFI (english)
 
Android Lab Test : Managing the telephone calls (english)
Android Lab Test : Managing the telephone calls (english)Android Lab Test : Managing the telephone calls (english)
Android Lab Test : Managing the telephone calls (english)
 
Android Lab Test : Reading the SMS-inbox (english)
Android Lab Test : Reading the SMS-inbox (english)Android Lab Test : Reading the SMS-inbox (english)
Android Lab Test : Reading the SMS-inbox (english)
 
Android Lab Test : Installation of application in Java (english)
Android Lab Test : Installation of application in Java (english)Android Lab Test : Installation of application in Java (english)
Android Lab Test : Installation of application in Java (english)
 
Android Lab Test : Ecrire un texte sur le canevas (français)
Android Lab Test : Ecrire un texte sur le canevas (français)Android Lab Test : Ecrire un texte sur le canevas (français)
Android Lab Test : Ecrire un texte sur le canevas (français)
 
Android Lab Test : La connectivité réseau avec HTTP (français)
Android Lab Test : La connectivité réseau avec HTTP (français)Android Lab Test : La connectivité réseau avec HTTP (français)
Android Lab Test : La connectivité réseau avec HTTP (français)
 
Android Lab Test : Le capteur gyroscope (français)
Android Lab Test : Le capteur gyroscope (français)Android Lab Test : Le capteur gyroscope (français)
Android Lab Test : Le capteur gyroscope (français)
 

Le langage SQL

  • 1. 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
  • 2. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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
  • 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. 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. 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. 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. 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 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
  • 8. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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 ? 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. 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 produits proposé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. 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. Bruno Delb http://www.brunodelb.com Date : 20/04/2002 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
  • 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. 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 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
  • 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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