� Norme

							                 Introduction au langage SQL
       Origine : SEQUEL (beaucoup plus riche que le SQL)
       Norme : ANSI depuis 1989 ; SQL=Structured Query Language
       Dialectes SQL (selon les /= SGBD)
       3 facettes du SQL :
                - Langage de définition de données (LDD)
                   (Création et évolution du schéma relationnel).
                - Langage de manipulation de données (LMD)
                    (Interrogation et options de mises a jour).
                - Langage de contrôle de données (LCD)
                    (gestion de l’intégrité et confidentialité).

     Se veut proche du langage naturel, base sur des mots clefs anglais.
     Vocabulaire en SQL :
             Table  relation
             Colonne  attribut
             Ligne  tuple

Structure d’un bloc SQL
Chaque requête correspond a un bloc.
SELECT <liste des attributs résultats sépares par des virgules> FROM <liste des relations
concernées> WHERE <liste de conditions> ;

La projection
     S’exprime dans la clause select.
      Exemple : Nom et adresse des pilotes.
      SELECT nompil, adr FROM pilote ;
      Exemple : Liste des villes desservies par la compagnie
      SELECT ville-arr FROM vol;
      En SQL : pas d’élimination des dupliquas, c’est l’utilisateur qui doit préciser
      explicitement par le mot clef DISTINCT
      SELECT DISTINCT ville-arr FROM vol ;
     S’il n’y a pas de projection dans une requête on peut :
              - les citer tous dans le select.
              - Utiliser la caractère ‘*’

Sélection
     S’exprime dans la clause WHERE sous forme : <attribut θ constante> où θ =
      {=,<,>...)
      Des conditions peuvent être combinées avec des opérations logiques : AND, OR,
      NOT.
      Exemple :
      Quels sont les pilotes marseillais ?
      SELECT * FROM pilote WHERE adr=’Marseille’

Introduction au langage SQL                                                             Page 1/4
     Possibilités complémentaires:
      Valeur d’un attribut compris dans un intervalle (bornes incluses)
      <attribut> BETWEEN <borne_inf> AND <borne_sup>
      Valeur d’un attribut appartenant à une liste donnée:
      <attribut> IN <valeur1, valeur2...>

     Recherche de sous chaînes :
      <attribut> LIKE ‘chaine_generique’
              chaîne générique : ‘_’ remplace n’importe quel caractère.
                                 ‘%’ remplace n’importe quelle séquence de caractères.

     Recherche de valeurs nulles :
      <attribut> IS NULL

     Forme négative des possibilités précédentes avec NOT :
      NOT BETWEEN, NOT IN, NOT LIKE, IS NOT NULL.
      Exemple:toutes les informations sur les airbus de n° compris entre 100 et 200 et
      localisés à Paris, Nice, Lyon et Marseille.
      SELECT * FROM avion WHERE nomav LIKE ‘a% ’AND numav BETWEEN 100
      AND 200 AND localisation IN (‘Paris’, ‘Nice’, ‘Lyon’, ‘Marseille’);

Calculs verticaux
     Des fonctions agrégatives s’appliquent sur les valeurs d’un attribut ou un sous-
      ensemble de valeurs.

     Les fonctions classiques :
             - COUNT : comptage
             - SUM        : somme
             - AVG        : moyenne
             - MIN        : Minimum
             - MAX : Maximum
      Exemple : masse salariale des pilotes :
      SELECT SUM(sal) FROM pilote;

Les duplicates doivent être élimines manuellement par le mot clef DISTINCT.

Exemple :Nombre de villes desservies par la compagnie ?
SELECT COUNT (DISTINCT ville_ar) FROM vol ;

     Pour la fonction COUNT, on peut utiliser le caractère ‘*’ comme argument (compte le
      nombre de tuples).
      Exemple : nombre de vols a direction de paris ?
      SELECT COUNT (*) FROM vol WHERE ville_ar=’Paris’ ;

     Gestion des valeurs nulles:
      Elles sont assimiles à zéro pour COUNT et SUM et à +∞ et - ∞ pour MAX et MIN.




Introduction au langage SQL                                                              Page 2/4
Calculs horizontaux
     S’applique sur un ou plusieurs attributs, tuples après tuples.

     Opérateurs arithmétiques : +, -, *, / ainsi que des fonctions diverses (abs...)
      Exemple :Nom des pilotes qui augmentes de 10% gagnent moins de 30.000 F
      SELECT nompil FROM pilote WHERE sal*1.1 < 30.000 ;

     Problème de gestion des valeurs nulles :
      Exemple : Dans Oracle, la fonction NUL (attribut, valeur de substitution).
      NUL(salaire, 0)*1.1 ;

Expression prédicative aux jointures :
     S’exprime dans la clause WHERE sous la forme :
      <attribut1> θ <attribut2> où θ = {=, /=, <...}

     Lorsque deux attributs ont le même nom, on les préfixes par le nom de la relation.
      Exemple : n° et horaire des vols au départ de paris et assurés par un A320.
      SELECT numvol, heure_dep, heure_arr FROM vol, avion WHERE
      ville_dep=’Paris’ AND avnum=’A320’ AND vol.numav = avion.numav ;

     Cas des auto-jointures :
      On utilise plusieurs fois le même nom de relation dans le FROM et a chaque
      utilisation on introduit un alias (juste après le nom de la relation)
      Exemple : nom des pilotes gagnant le même salaire que Dupont :
      SELECT les_autres.nompil FROM pilote pil_dupont, pilote les_autres WHERE
      pil_dupont.nompil=’Dupont’ AND pil_dupont.salaire = les_autres.salaire ;
      Remarque : quand un alias est introduit, il faut l’utiliser dans toute la requête.

Expression imbriquées des jointures :
On peut imbriquer des blocs SQL. Le résultat d’un bloc imbrique est alors utilise par le bloc
de niveau supérieur.
Un bloc imbrique est parenthèsé. On l’appelle aussi sous-requête.

1ère cas : la sous requête rend une valeur unique :
exemple : nom des pilotes gagnant plus que la moyenne :
SELECT nompil FROM pilote WHERE sal > (SELECT AVG(sal) FROM pilote) ;

2ème cas : la sous-requête rend une liste de valeurs:
     La condition doit être vrai pour une valeur de la liste. On utilise entre les 2 blocs : θ
       ANY où θ = {/= , =, <...)
       Exemple : nom des pilotes assurant un vol au départ de paris :
       SELECT nompil FROM pilote WHERE numpil = ANY (SELECT numpil FROM vol
       WHERE ville_dep=’Paris’) ;

     La condition doit être vérifiée pour toutes les valeurs de la liste. On utilise entre les 2
      blocs θ ALL avec θ = {=, /=, <...}
      Exemple : nom des pilotes marseillais gagnant plus que tous les pilotes parisiens :

Introduction au langage SQL                                                                Page 3/4
       SELECT nompil FROM pilote WHERE adresse=’Marseille’ AND salaire > ALL
       (SELECT DISTINCT salaire FROM pilote WHERE adresse=’Paris’);
 éme
3 cas : le résultat de la sous requête est un ensemble de colonnes :
     Le nombre d’attributs dans le SELECT imbriqué doit être le même que dans le
        WHERE.
     La comparaison se fait dans l’ordre.
    Exemple : nom des avions localises dans la même ville et ayant le même nom que l’avion
    n°100 :
    SELECT nomav FROM avion WHERE (nomav, loc) = (SELECT nomav, loc FROM
    avion WHERE numav=100);

Les opérateurs ensemblistes :
     Les opérateurs ensemblistes sont indiques entre 2 blocs SQL et ils opèrent l’union,
      l’intersection ou la différence des résultats des deux blocs.

     Les attributs des deux SELECT doivent être compatibles 2 à 2.

     Dans Oracle : UNION, INTERSECT, MINUS.
      Exemple : n° des pilotes effectuant un vol atterrissant à Paris ou habitant Paris :
      SELECT numpil FROM pilote WHERE adresse=’Paris’ UNION SELECT numpil
      FROM vol WHERE villle_arr=’Paris’);

        Exemple : nom des pilotes qui ne sont pas en service :
        SELECT nompil FROM pilote WHERE numpil IN (SELECT numpil FROM pilote)
        MINUS SELECT numpil FROM vol ;

La clause de tri :
     C’est toujours la dernière clause d’une requête :
      ORDER BY attribut1 {ASC ; DES}, attribut2.... ;

     Par défaut, l’ordre de tri est croissant.
      Exemple : Liste alphabétique des pilotes :
      SELECT nompil FROM pilote ORDER BY nompil ;




Introduction au langage SQL                                                           Page 4/4