39. Didacticiel SQL

Contenu de cette section

On peut trouver ce didacticiel SQL à http://w3.one.net/~jhoffman/sqltut.htm

Pour les commentaires ou suggestions, envoyer un courrier électronique à jhoffman@one.net

Vous pouvez également souhaiter jeter un oeil à http://w3.one.net/~jhoffman/index.html

John Hoffman suggère de visiter les sites suivants :

http://www.contrib.andrew.cmu.edu/~shadow/sql.html Référence SQL

http://www.inquiry.com/techtips/thesqlpro/ Demandez le Pro. de SQL

http://www.inquiry.com/techtips/thesqlpro/usefulsites.html Sites utiles au Pro. du SGBD Relationnel SQL

http://infoweb.magi.com/~steve/develop.html Les Sites de sources du programmeur SGBD

http://info.itu.ch/special/wwwfiles Allez-y et regardez le fichier comp_db.html

http://www.compapp.dcu.ie/databases/f017.html Ingrédients pour SGBD

http://www.stars.com/Tutorial/CGI/ Création Web

http://wfn-shop.princeton.edu/cgi-bin/foldoc Dictionnaire d'Informatique

http://www-ccs.cs.umass.edu/db.html DBMS Lab/Liens

SQL FAQ http://epoch.CS.Berkeley.EDU:8000/sequoia/dba/montage/FAQ Allez-y et regardez le fichier SQL_TOC.html

http://chaos.mur.csu.edu.au/itc125/cgi/sqldb.html SGBD SQL

http://www.it.rit.edu/~wjs/IT/199602/icsa720/icsa720postings.html Page de Conception de Bases de Données RIT

http://www.pcslink.com/~ej/dbweb.html Site de liens vers des Bases de Données http://www.eng.uc.edu/~jtilley/tutorial.html Didacticiels de programmation sur le Web

http://www.ndev.com/ndc2/support/resources.htp Ressources pour le Développement

http://ashok.pair.com/sql.htm Liste de Requêtes

http://jazz.external.hp.com/training/sqltables/main.html IMAGE SQL Diverses

http://www.eit.com/web/netservices.html Liste de Ressources Internet

Voici, ci-dessous, un extrait de la page d'accueil du didacticiel SQL.

Introduction au Langage de Requete Structure

Version 3.31

Cette page contient un didacticiel du Langage de Requete Structure( Structured 
Query Language, egalement connu sous le nom de SQL). Ce didacticiel constitue 
une nouveaute sur le World Wide Web, car c'est le premier didacticiel SQL 
complet disponible sur l'Internet. SQL permet l'acces aux donnees dans les 
systemes  de gestion de bases de donnees relationnels tels que Oracle,
Sybase, Informix, Microsoft SQL Server, Access, et autres en permettant aux 
utilisateurs de decrire les donnees qu'ils desirent obtenir. SQL permet aussi 
aux utilisateurs de definir l'organisation des donnees dans la base et de les 
manipuler. Le but de cette page est de decrire l'utilisation de SQL, et de 
donner des exemples. C'est le langage ANSI SQL, ou standard SQL, qui sera  
utilise dans ce document. Il ne sera pas question ici des fonctionnalites 
specifiques a un SGBD particulier, qui seront traitees dans la section "SQL 
non-standard". Nous vous recommandons d'imprimer cette page afin de pouvoir 
vous referer facilement aux differents exemples.
----------------------------------------------------------------------------
Table des matieres

     Principes fondamentaux de l'instruction SELECT
     Selection Conditionnelle
     Operateurs Relationnels
     Conditions Composees
     IN & BETWEEN
     Utilisation de LIKE

     Jointures
     Cles
     Realisation d'une Jointure
     Elimination des Doubles
     Alias & In/Sous-requetes

     Fonctions d'Agregation
     Vues
     Creation de Nouvelles Tables
     Modification des Tables
     Ajout de Donnees
     Suppression de Donnees
     Mise a Jour des Donnees

     Index
     GROUP BY & HAVING
     Sous-requetes Supplementaires
     EXISTS & ALL
     UNION & Jointures Externes
     SQL Integre
     Questions Courantes sur SQL
     SQL Non-standard
     Resume de la Syntaxe
     Liens Importants

----------------------------------------------------------------------------
Principes fondamentaux de l'instruction SELECT

Dans une base de donnees relationnelle, les donnees sont stockees dans des 
tables. Par exemple,  une table pourrait mettre en relation le Numero de 
Securite Sociale, le Nom et l'Adresse:

                        TableAdresseEmploye

 NSS      Prenom    Nom       Addresse        Ville       Etat
 512687458Joe       Smith     83 First Street Howard      Ohio
 758420012Mary      Scott     842 Vine Ave.   LosantivilleOhio
 102254896Sam       Jones     33 Elm St.      Paris       New York
 876512563Sarah     Ackerman  440 U.S. 110    Upton       Michigan

Maintenant, supposons que nous voulions obtenir l'adresse de chaque employe. 
On utilisera SELECT, comme ceci :

SELECT Prenom, Nom, Adresse, Ville, Etat
FROM TableAdresseEmploye;

Voici le resultat de l'interrogation de notre base de donnees :

 Prenom    Nom        Adresse         Ville        Etat
 Joe       Smith      83 First Street  Howard       Ohio
 Mary      Scott      842 Vine Ave.    Losantiville Ohio
 Sam       Jones      33 Elm St.       Paris        New York
 Sarah     Ackerman   440 U.S. 110     Upton        Michigan

Explication de ce que l'on vient de faire : on vient de rechercher dans toutes 
les donnees de la table TableAdresseEmploye les colonnes nommees Prenom, Nom, 
Adresse, Ville et Etat. Noter que les noms de colonnes et les noms de tables 
sont sans espaces... ils doivent etre saisis en un seul mot; et que 
l'instruction se termine par un point-virgule (;). La forme generale d'une 
instruction SELECT, qui permet de retrouver toutes les lignes d'une table 
est :

SELECT NomColonne, NomColonne, ...
FROM NomTable;

Pour obtenir toutes les colonnes d'une table sans avoir a taper tous les noms 
de colonne, utiliser :

SELECT * FROM NomTable;

Chaque Systeme de Gestion de Base de Donnees (SGBD) et chaque logiciel de 
base de donnees utilisent differentes methodes pour se connecter a la base 
de donnee et pour entrer les instructions SQL; consultez le "guru" de votre 
ordinateur pour qu'il vous aide a vous connecter de facon a pouvoir utiliser
SQL.
----------------------------------------------------------------------------
Selection Conditionnelle

Pour etudier plus avant l'instruction SELECT , jetons un oeil a un nouvel exemple de table
(exemple uniquement hypothetique) :

                      EmployeeStatisticsTable

 EmployeeIDNo      Salary           Benefits         Position
 010               75000            15000            Manager
 105               65000            15000            Manager
 152               60000            15000            Manager
 215               60000            12500            Manager
 244               50000            12000            Staff
 300               45000            10000            Staff
 335               40000            10000            Staff
 400               32000            7500             Entry-Level
 441               28000            7500             Entry-Level

----------------------------------------------------------------------------
Operateurs Relationnels

Il y a six Operateurs Relationnels en SQL, et, apres les avoir presentes, 
nous verrons comment les utiliser :

 =            Egal
 <> or !=
 (voir le manuel) Different
 <            Plus Petit Que
 >            Plus Grand Que
 <=           Plus Petit Que ou Egal a

 >=           Plus Grand Que ou Egal a
              
La clause WHERE est utilisee pour specifier que l'on affichera seulement 
certaines ligne de la table, selon un critere definit par cette clause WHERE. 
Ce sera plus clair en prenant une paire d'exemples.

Si l'on desire voir les numeros d'identification des employes (EMPLOYEEIDNO) 
dont le salaire est egal ou superieur a 50 000, on utilisera la requete 
suivante :

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE SALARY >= 50000;

Noter que le symbole >= (plus grand que ou egal a) est utilise, puisque l'on 
desire voir tout ceux qui gagnent plus de 50 000, ou 50 000, sur la meme 
liste. On aura l'affichage :

EMPLOYEEIDNO
------------
010
105
152
215
244

La description de WHERE, SALARY >= 50000, est appelee une condition. On pourrait
effectuer le meme traitement sur des colonnes de texte :

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE POSITION = 'Manager';

Ceci entrainera l'affichage des Numeros d'Identification de tous les Managers. 
En general, avec les colonnes contenant du texte, n'utiliser que egal a ou 
different de, et assurez vous que tout texte apparaissant dans l'instruction 
est entoure d'apostrophes (').

----------------------------------------------------------------------------
Conditions plus complexes: Conditions Composees

L'operateur AND (ET) combine deux ou plusieurs conditions et n'affiche une 
ligne que si cette ligne satisfait TOUTES les conditions requises (i.e. ou 
toutes les conditions sont realisees). Par exemple, pour afficher tout le 
personnel gagnant plus 40 000, ecrire :

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE SALARY > 40000 AND POSITION = 'Staff';

L'operateur OR (OU) combine deux ou plusieurs conditions mais retourne cette 
ligne si N'IMPORTE LAQUELLE des conditions requises est remplie. Pour 
visualiser tous ceux qui gagnent moins de 40 000 ou qui recoivent moins de 10 
000 en participation aux benefices, utilisez la requete suivante :

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE SALARY < 40000 OR BENEFITS < 10000;

Les operateurs AND et OR peuvent etre combines, par exemple :

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE POSITION = 'Manager' AND SALARY > 60000 OR BENEFITS > 12000;

En premier lieu, SQL recherche les lignes pour lesquelles la valeur de la 
colonne salaire est superieure a 60 000 et celle de position est egale a 
Manager, puis, a partir de cette liste de lignes, SQL recherche alors celles 
qui satisfont a la condition AND (ET) precedente ou a la condition specifiant 
que la colonne Indemnites est superieure a  12 000. En consequence, SQL n'affiche 
seulement que cette seconde liste de lignes, en gardant a l'esprit que tous ceux 
dont les Indemnites sont superieures a 12 000 en feront partie puisque l'operateur 
OR (OU) inclue la ligne si l'une des conditions est verifiee. Notez en passant 
que l'operation AND (ET) est effectuee en premier.

Pour generaliser ce processus, SQL effectue l(es) operation(s) AND pour determiner 
les lignes ou l(es) operation(s) AND sont verifiees (souvenez-vous bien : toutes 
les conditions sont verifiees), puis ces resultats sont utilises pour tester les 
conditions OR, et, ne seront affichees que les lignes ou les conditions requises 
par l'operateur OR seront verifiees.

Pour que les OR's soient effectues avant les AND's, par exemple si vous vouliez voir 
une liste des employes dont le salaire est eleve (>50 000) OU beneficiant d'indemnites 
importantes (>10 000), ET qui soient cadres, utilisez des parentheses :

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE POSITION = 'Manager' AND (SALARY > 50000 OR BENEFIT > 10000);

----------------------------------------------------------------------------
IN et BETWEEN

Une methode plus facile pour utiliser les conditions composees consiste a utiliser 
IN ou BETWEEN. Par exemple, si vous desirez une liste des cadres et du personnel :

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE POSITION IN ('Manager', 'Staff');

ou une liste de ceux dont le salaire est superieur ou egal a 30 000, mais inferieur
ou egal a 50 000, utilisez:

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE SALARY BETWEEN 30000 AND 50000;

Pour obtenir la liste de ceux qui n'entrent pas dans ces criteres, essayez :

SELECT EMPLOYEEIDNO
FROM EMPLOYEESTATISTICSTABLE
WHERE SALARY NOT BETWEEN 30000 AND 50000;

De la meme facon, NOT IN donne la liste de toutes les lignes exclues de la liste 
obtenue par l'operateur IN.

----------------------------------------------------------------------------
Utilisation de LIKE

Regardons la table EmployeeStatisticsTable, et disons que l'on veut voir tous les 
gens dont le nom commence par "L"; essayons :

SELECT EMPLOYEEIDNO
FROM EMPLOYEEADDRESSTABLE
WHERE LASTNAME LIKE 'L%';

Le signe pourcentage (%) est utilise pour representer n'importe quel caractere 
possible (nombre, lettre, ou signe de ponctuation) ou ensemble de caracteres 
qui peut apparaitre apres le "L". Pour trouver les gens dont le Nom se termine 
avec "L", utiliser '%L', ou si vous desirez le "L" au milieu du mot, essayez 
'%L%'. Le symbole '%' peut etre utilise pour n'importe quel caractere, et 
dont la position est relative par rapport a des caracteres donnes. NOT LIKE
affiche les lignes qui ne correspondent pas a la description donnee. Il y a 
d'autres manieres d'utiliser LIKE, de meme que n'importe lesquelles des 
conditions composees dont nous venons de parler, bien que cela depende du SGBD 
que vous utilisez; comme d'habitude, consultez un manuel ou le gestionnaire ou 
administrateur de votre systeme pour en connaitre les fonctionnalites, ou 
simplement, assurez vous que ce que vous essayer de faire est possible et 
autorise. Cet avertissement est aussi valable pour les fonctionnalites de SQL 
exposees ci-dessous. Cette section est donnee a titre d'exemple des requetes 
qui peuvent etre ecrites en SQL.
----------------------------------------------------------------------------
Jointures

Dans cette section, nous allons parler uniquement des jointures internes et 
des equi-jointures, dans la mesure ou ce sont les plus utiles. Pour avoir plus 
d'informations, voyez les liens sur des sites SQL au bas de cette  page.

On suggere qu'une bonne maniere de concevoir une base de donnees implique que 
chaque table ne contienne des donnees qui ne concernent qu'une seule entite, 
et que des informations detaillees peuvent etre obtenues, dans une base de 
donnees relationnelle, en utilisant des tables supplementaires et en effectuant 
une jointure.

Premierement, jetons un oeil a ces exemples de tables :

            AntiqueOwners

 OwnerIDOwnerLastName OwnerFirstName
 01     Jones         Bill
 02     Smith         Bob
 15     Lawson        Patricia
 21     Akins         Jane
 50     Fowler        Sam

---------------------------------------------------------

       Orders

 OwnerIDItemDesired
 02     Table
 02     Desk
 21     Chair
 15     Mirror

--------------------------------------

           Antiques

 SellerIDBuyerID Item
 01      50      Bed
 02      15      Table
 15      02      Chair
 21      50      Mirror
 50      01      Desk
 01      21      Cabinet
 02      21      Coffee Table
 15      50      Chair
 01      15      Jewelry Box
 02      21      Pottery
 21      02      Bookcase
 50      01      Plant Stand

----------------------------------------------------------------------------
Cles

En premier lieu, nous allons parler du concept de cles. Une cle primaire est 
une colonne ou en ensemble de colonnes qui identifie de maniere unique les 
autres donnees d'une ligne donnee. Par exemple, dans la table AntiqueOwners, 
la colonne OwnerID identifie de maniere unique cette ligne. Ceci signifie deux 
choses: que deux lignes ne peuvent avoir le meme OwnerID, et que, meme si 
deux proprietaires les memes noms et prenoms la colonne OwnerID garantit que 
ces deux proprietaires ne seront pas confondus l'un avec l'autre, puisque la 
colonne OwnerID unique sera utilisee a travers la base de donnees pour se 
referer a un proprietaire, plutot que son nom.

Une cle externe est une colonne d'une table qui est cle primaire d'une autre 
table, ce qui signifie que toutes les donnees d'une cle externe doivent avoir
des donnees correspondantes dans l'autre table, ou cette colonne est la cle 
primaire.
Pour parler SGBD, cette correspondance est connue sous le nom d'integre 
referentielle. Par exemple, dans la table Antiques, BuyerID et SellerID sont 
tous les deux des cles externes a la cle primaire de la table AntiqueOwners  
(OwnerID; pour les besoins de notre argumentation, on doit d'abord etre 
reference dans la table AntiqueOwners avant de pouvoir acheter ou vendre quoi 
que ce soit), puisque, dans les deux tables, les colonnes ID sont utilisees 
pour identifier les proprietaires, les acheteurs ou les vendeurs, et que  
OwnerID est la cle primaire de la table AntiqueOwners. En d'autres termes, 
toutes ces donnees "ID" sont utilisees pour se referer aux proprietaires,
acheteurs et vendeurs sans avoir a utiliser les noms effectifs.

----------------------------------------------------------------------------
Realisation d'une jointure

Le but de ces cles est ainsi de pouvoir mettre en relation les donnees a 
travers les tables sans avoir a repeter les donnees dans chaque tables,
--c'est toute la puissance des bases de donnees relationnelles. Par exemple, 
on peut trouver les noms de ceux qui ont achete une chaise sans avoir a lister 
la totalite du nom de l'acheteur dans la table Antiques... vous pouvez trouver 
ce nom en mettant en relation ceux qui ont achete une chaise avec les noms 
dans la table AntiqueOwners en utilisant le OwnerID, qui met en relation les 
donnees dans les deux tables. Pour trouver les noms de ceux qui ont achete 
une chaise, utilisez la requete suivante :

SELECT OWNERLASTNAME, OWNERFIRSTNAME
FROM ANTIQUEOWNERS, ANTIQUES
WHERE BUYERID = OWNERID AND ITEM = 'Chair';

Notez ce qui suit au sujet de cette requete... notez que les deux tables mise 
en jeux dans cette relation sont listees dans la clause FROM de l'instruction. 
Dans la clause WHERE, notez, en premier lieu, que la partie ITEM = 'Chair' de 
la clause limite la liste a ceux qui ont achete (et, dans cet exemple, de ce 
fait possedent) une chaise. En second lieu, notez comment les colonnes ID sont 
mises en relation d'une table a la suivante par l'utilisation de la clause 
BUYERID = OWNERID. Ne seront listes que les noms  de la table AntiqueOwners 
dont les ID correspondent a travers les tables et dont l'article achete est 
une chaise (a cause du AND). Parce que la condition de jointure utilisee est 
un signe egal, cette jointure est appelee une equi-jointures. le resultat de 
cette requete donnera deux noms: Smith, Bob et Fowler, Sam.

La notation avec un point (.) fait reference a l'utilisation du nom de colonne 
en suffixe du nom de table pour eviter toute ambiguite, comme par exemple:

SELECT ANTIQUEOWNERS.OWNERLASTNAME, ANTIQUEOWNERS.OWNERFIRSTNAME
FROM ANTIQUEOWNERS, ANTIQUES
WHERE ANTIQUES.BUYERID = ANTIQUEOWNERS.OWNERID AND ANTIQUES.ITEM = 'Chair';

Cependant, puisque les noms de colonnes sont differents dans chaque table, 
cela n'etait pas necessaire.

----------------------------------------------------------------------------
DISTINCT et l'Elimination des Doubles

Disons que vous ne vouliez seulement que la liste des Identificateurs (ID) et 
des noms des gens qui ont vendu une antiquite. Evidemment, vous ne desirez 
une liste ou chaque vendeur n'apparait qu'une fois--vous ne voulez pas savoir 
combien d'antiquites ont ete vendues par une personne, mais uniquement le fait 
que cette personne en a vendu une (pour les comptages, voir la fonction 
d'Agregation ci-dessous). Cela signifie qu'il vous faudra dire a SQL d'eliminer 
les doubles des lignes des ventes, et de ne seulement lister chaque personne 
qu'une fois. Pour realiser cela, utilisez le mot-cle DISTINCT.

Premierement, vous aurez besoin de faire un equi-jointures sur la table 
AntiqueOwners pour obtenir les donnees concernant le Nom et le Prenom de la 
personne. Cependant, gardez a l'esprit que, puisque la colonne SellerID dans 
la table Antiques est une cle externe de la table AntiqueOwners, un vendeur 
ne sera liste que s'il y a une ligne dans la table AntiqueOwners contenant les 
ID et les noms. Nous voulons egalement eliminer les multiples occurrences du 
SellerID dans notre liste, donc, nous utiliserons le mot-cle DISTINCT pour les 
colonnes ou les repetitions peuvent se produire.

Pour ajouter une difficulte, nous voulons aussi que cette liste soit classee 
par ordre alphabetique des Noms, puis des Prenoms (a l'interieur des noms), 
puis des  OwnerID (a l'interieur des noms et des prenoms). Pour cela, nous 
utiliserons la clause ORDER BY :

SELECT DISTINCT SELLERID, OWNERLASTNAME, OWNERFIRSTNAME
FROM ANTIQUES, ANTIQUEOWNERS
WHERE SELLERID = OWNERID
ORDER BY OWNERLASTNAME, OWNERFIRSTNAME, OWNERID;

Dans cet exemple, puisque tout le monde a vendu un article, nous aurons une 
liste de tous les proprietaires, classes par ordre alphabetique sur les noms. 
Pour reference ulterieure (au cas ou quelqu'un le demande), ce type de jointure 
est considere comme appartenant a la categorie des jointures internes.

----------------------------------------------------------------------------
Alias et In/Sous-requetes

Dans cette section, nous parlerons des Alias, In et de l'utilisation des 
sous-requetes, et de la maniere de les utiliser dans un exemple de 3-table. 
En premier lieu, regardez cette requete qui imprime le nom des proprietaires 
qui ont passe une commande et la nature de cette commande, en ne listant 
seulement que les commandes qui peuvent etre satisfaites (c'est a dire qu'il 
y a un vendeur qui possede l'article commande) :

SELECT OWN.OWNERLASTNAME Last Name, ORD.ITEMDESIRED Item Ordered
FROM ORDERS ORD, ANTIQUEOWNERS OWN
WHERE ORD.OWNERID = OWN.OWNERID
AND ORD.ITEMDESIRED IN

     (SELECT ITEM
     FROM ANTIQUES);

Ce qui donne :

Last name Item Ordered
--------- ------------
Smith     Table
Smith     Desk
Akins     Chair
Lawson    Mirror

Il y a plusieurs choses a noter a propos de cette requete :

  1. Tout d'abord, les mots "Last Name" et "Item Ordered" dans les lignes 
     SELECT donnent les en-tetes du rapport.
  2. Les mots OWN et ORD sont des alias; ce sont de nouveaux noms pour les 
     deux tables donnees dans la clause FROM qui sont utilises comme prefixes 
     pour toutes les notations point (.) de noms de colonnes dans les requetes
     (voir ci-dessus). Ceci elimine les risques ambiguite, specialement dans
     l'equi-jointure de la clause WHERE ou les deux tables ont une colonne 
     nommee OwnerID, et cette notation point (.) precise a SQL que nous 
     designons deux OwnerID differents de deux tables differentes.
  3. Notez que la table des commandes (ORDERS) est indiquee la premiere dans 
     la clause FROM; ceci apporte la certitude que la liste sera realisee a 
     partir de cette table, et que la table AntiqueOwners
     est utilisee uniquement pour obtenir les informations detaillees (Last 
     Name / Nom).
  4. Plus important, la clause AND dans la clause WHERE (OU) force l'utilisation
     de la Sous-requete  In ("= ANY" ou "= SOME" sont deux utilisations 
     equivalentes de IN). Cela entraine que la sous-requete est effectuee, 
     retournant une liste de tous les articles (Items) appartenant a la table  
     Antiques, comme s'il n'y avait pas de clause WHERE (OU). Donc, pour lister
     une ligne de la table ORDERS, le ItemDesired (article_desire) doit etre 
     dans la liste retournee des articles appartenant a la table Antiques, et 
     donc un article ne sera liste que si la commande ne peut etre honoree 
     que par un autre proprietaire. On peut se le representer comme ceci: la 
     sous-requete retourne un ensemble d'articles (Items) auquel chaque 
     ItemDesired (Article_Desire) dans la table des commandes (ORDERS) est 
     compare; la condition IN (DANS) n'est vraie que si le ItemDesired 
     appartient a l'ensemble provenant de la table ANTIQUES.
  5. Notez egalement, comme c'est le cas ici, qu'il y a un objet ancien pour 
     chaque demande, ce qui, evidemment, n'est pas toujours le cas... De plus,
     notez aussi que, lorsque  IN, "= ANY", ou "= SOME" est utilise, ces 
     mots-cles font reference a toutes les lignes qui conviennent, pas aux 
     colonnes... c'est a dire que vous ne pouvez pas mettre de multiples 
     colonnes dans un clause SELECT de sous-requete, pour tenter de faire 
     correspondre la colonne de la clause WHERE externe avec l'une des 
     multiples valeurs de colonnes possibles de la sous-requete; une seule 
     colonne peut etre indiquee dans la sous-requete, et la correspondance 
     possible provient de multiples valeurs de lignes, dans cette colonne 
     unique, et non pas l'inverse.

Ouf! Ce sera tout sur ce sujet des requetes SELECT complexes pour l'instant. 
Maintenait, voyons d'autres instructions SQL.
----------------------------------------------------------------------------
Instructions SQL Diverses

Fonctions d'Agregation

Je parlerai de cinq fonctions d'agregation importantes: SUM, AVG, MAX, MIN, et
COUNT. On les appelle fonctions d'agregation parce qu'elles resument les 
resultats d'une requete, plutot que de donner une liste de toutes les lignes.

   * SUM () donne la somme, pour une colonne donnee, de toutes les lignes qui 
satisfont aux conditions requises, et ou la colonne donnee est numerique.
   * AVG () donne la moyenne de la colonne donnee.
   * MAX () donne la plus grande valeur dans la colonne donnee.
   * MIN () donne la plus petite valeur dans la colonne donnee.
   * COUNT(*) donne le nombre de lignes qui satisfont aux conditions.

En utilisant les tables du debut de ce document, regardons trois exemples :

SELECT SUM(SALARY), AVG(SALARY)
FROM EMPLOYEESTATISTICSTABLE;

Cette requete donne la somme des de salaires tous les salaries presents dans 
la table et le salaire moyen.

SELECT MIN(BENEFITS)
FROM EMPLOYEESTATISTICSTABLE
WHERE POSITION = 'Manager';

Cette requete donne le chiffre de la colonne indemnites le plus faible des 
employes qui sont Managers, cette valeur est 12 500.

SELECT COUNT(*)
FROM EMPLOYEESTATISTICSTABLE
WHERE POSITION = 'Staff';

Cette requete vous donne le nombre d'employes ayant le statut de cadre (Staff, 
i.e. 3).

----------------------------------------------------------------------------
Les Vues

En SQL, vous pouvez (verifiez aupres de votre Administrateur de Base de Donnees, 
DBA) avoir acces a la creation de vues par vous-meme. Une vue vous permet d'affecter 
les resultats d'une requete a une nouvelle table personnelle, que vous pourrez 
utiliser dans d'autres requetes, pour laquelle vous donnez le nom de la vue dans 
votre clause FROM. Quand vous accedez a une vue, la requete qui est definie dans 
l'instruction de creation de la vue est effectuee (generalement), et les resultats 
de cette requete ont la meme allure qu'une autre table dans la requete que vous 
avez ecrit en invoquant la vue. Par exemple, pour creer une vue :

CREATE VIEW ANTVIEW AS SELECT ITEMDESIRED FROM ORDERS;

Maintenant, ecrivons une requete utilisant cette vue comme une table, ou la 
table est seulement une liste de tous les articles desires (ITEMDESIRED) de 
la table ORDERS :

SELECT SELLERID
FROM ANTIQUES, ANTVIEW
WHERE ITEMDESIRED = ITEM;

Cette table montre tous les Identifiants de Vendeurs (SellerID) de la table 
ANTIQUES ou l'article (Item) dans cette table apparait dans la vue ANTVIEW, 
qui consiste justement en tous les Articles Desires (Items Desired) dans la 
table ORDERS. La liste est cree en parcourant les articles AntiquesItems un 
par un jusqu'a ce qu'il y ait correspondance avec la vue ANTVIEW. Les vues 
peuvent etre utilisees pour restreindre les acces a la base de donnees, 
ainsi que, dans ce cas, pour simplifier une requete complexe.

----------------------------------------------------------------------------
Creation de Nouvelles Tables

Toutes les tables, dans une base de donnees doivent etre creees a un certain 
moment... voyons comment mous pourrions creer la table des commandes (ORDERS) :

CREATE TABLE ORDERS
(OWNERID INTEGER NOT NULL,
ITEMDESIRED CHAR(40) NOT NULL);

Cette instruction donne un nom a la table et renseigne le SGBD sur la nature 
de chaque colonne de la table. Veuillez noter que cette instruction utilise 
des types de donnees generiques, et que les types de donnees peuvent etre 
differents, selon le SGBD que vous utilisez. Comme d'habitude, verifiez vos 
conditions locales. Voici quelques types de donnees generiques courants:

   * Char(x) - Une colonne de caracteres, ou x est un nombre indiquant le 
     nombre maximum de caracteres permis (taille maximale) de la colonne.
   * Integer - Une colonne de nombres entiers, positifs ou negatifs.
   * Decimal(x, y) - Une colonne de nombre decimaux, ou x est la taille 
     maximum, en digits, des nombres decimaux dans cette colonne, et y le 
     nombre maximal de digits autorises apres la virgule. Le nombre maximal  
     (4,2) sera 99.99.
   * Date - Une colonne de date dans un format specifique au SGBD.
   * Logical - Une colonne qui ne peut contenir que deux valeurs: VRAI ou FAUX.

Autre remarque, l'indication NOT NULL (non nul) signifie que la colonne doit 
avoir une valeur pour chacune des lignes. Si l'on avait utilise NULL (nul), 
cette colonne peut etre laissee vide dans certaines lignes.

----------------------------------------------------------------------------
Modification des tables

Ajoutons une colonne a la table ANTIQUES pour permettre la saisie du prix d'un 
article donne :

ALTER TABLE ANTIQUES ADD (PRICE DECIMAL(8,2) NULL);

On verra plus tard comment les donnees pour cette nouvelle colonne peuvent 
etre mises a jour ou ajoutees.

----------------------------------------------------------------------------
Ajout de Donnees

Pour inserer des lignes dans une table, faites ce qui suit :

INSERT INTO ANTIQUES VALUES (21, 01, 'Ottoman', 200.00);

Ceci insere les donnees dans la table, en tant que nouvelle ligne, colonne 
par colonne, dans un ordre predefinit. Au lieu de cela, changeons cet ordre 
et laissons le Prix vide:

INSERT INTO ANTIQUES (BUYERID, SELLERID, ITEM)
VALUES (01, 21, 'Ottoman');

----------------------------------------------------------------------------
Suppression de donnees

Supprimons cette nouvelle ligne de la base de donnees :

DELETE FROM ANTIQUES
WHERE ITEM = 'Ottoman';

Mais s'il y a une autre ligne qui contient 'Ottoman', cette ligne sera 
egalement supprimee. Supprimons toutes les lignes (une, dans ce cas) qui 
contient les donnees specifiques que nous avons ajoute plus
 tot :

DELETE FROM ANTIQUES
WHERE ITEM = 'Ottoman' AND BUYERID = 01 AND SELLERID = 21;

----------------------------------------------------------------------------
Mise a Jour des Donnees

Mettons un Prix a jour dans une ligne qui n'en contient pas encore :

UPDATE ANTIQUES SET PRICE = 500.00 WHERE ITEM = 'Chair';

Ceci met le Prix de toutes les Chaises (Chair) a 500.00. Comme indique 
ci-dessus, conditions WHERE supplementaires, utilisation de AND, il faut 
utiliser ces conditions pour limiter la mise a jour a des lignes specifiques. 
De plus, des colonnes supplementaires peuvent etre renseignees en separant 
les instructions "egal" par des virgules.

----------------------------------------------------------------------------
Considerations Diverses

Index

Les Index permettent a un SGBD d'acceder au donnees plus rapidement (veuillez 
noter que cette fonctionnalite est non-standard/indisponible sur certains 
systemes). Le systeme cree une structure de donnee interne (l'index) qui 
entraine une selection de lignes beaucoup plus rapide, quand la selection 
est basee sur des colonnes indexees. Cet index indique au SGBD ou se trouve 
une certaine ligne dans une table etant donne une valeur de colonne indexee, 
exactement comme l'index d'un livre vous indique a quelle page un mot donne 
se trouve. Creons un index pour le OwnerID dans la colonne AntiqueOwners :

CREATE INDEX OID_IDX ON ANTIQUEOWNERS (OWNERID);

Maintenant sur les noms:

CREATE INDEX NAME_IDX ON ANTIQUEOWNERS (OWNERLASTNAME, OWNERFIRSTNAME);

Pour etre debarrasse d'un index, supprimez le :

DROP INDEX OID_IDX;

A propos, vous pouvez aussi bien "supprimer" une table (attention!--cela 
signifie que votre table est detruite). Dans le second exemple, l'index est 
construit a partir des deux colonnes, agregees ensembles--un comportement 
bizarre peut resulter de cette situation... verifiez dans votre manuel avant 
d'effectuer une telle operation.

Quelques SGBD n'imposent pas l'utilisation de cles primaires; en d'autres 
termes, l'unicite d'une colonne n'est pas imposee automatiquement. Cela 
signifie que, par exemple, j'aurais pu essayer d'inserer une autre ligne 
dans la table  AntiqueOwners avec un OwnerID de 02, quelques systemes me 
permettent de faire cela, bien qu'il ne le faille pas, puisque cette colonne 
est supposee etre unique dans cette table (chaque valeur de ligne est supposee 
etre differente). Une maniere de contourner cela est de creer un index unique 
sur la colonne que nous souhaitons voir etre la cle primaire pour forcer le 
systeme a interdire les doubles :

CREATE UNIQUE INDEX OID_IDX ON ANTIQUEOWNERS (OWNERID);

----------------------------------------------------------------------------
GROUP BY et HAVING

Une utilisation speciale de la clause GROUP BY est l'association d'une fonction 
agregee (specialement COUNT; qui compte le nombre de lignes dans chaque groupe) 
avec des groupes de lignes. Premierement, supposons que la table ANTIQUES 
possede la colonne Prix (Price)t, et que chaque ligne contienne une valeur 
dans cette colonne. Nous voulons voir le prix de l'article le plus cher achete 
par chaque proprietaire. Il nous faut donc dire a SQL de grouper les achats de 
chacun des proprietaires, et de nous dire le prix d'achat maximum :

SELECT BUYERID, MAX(PRICE)
FROM ANTIQUES
GROUP BY BUYERID;

Maintenant, disons que nous ne voulons voir que le prix maximum si l'achat 
depasse 1000, nous devrons utiliser la clause HAVING :

SELECT BUYERID, MAX(PRICE)
FROM ANTIQUES
GROUP BY BUYERID
HAVING PRICE > 1000;

----------------------------------------------------------------------------
Sous-requetes Supplementaires

Un autre usage commun des sous-requetes amene a l'utilisation des operateurs 
pour permettre a une condition WHERE d'inclure la sortie SELECT d'une 
sous-requete. En premier, demandons la liste des acheteurs ayant achete un 
article cher (le prix de cet article est superieur de 100 au prix moyen de tous 
les articles achetes) :

SELECT OWNERID
FROM ANTIQUES
WHERE PRICE >

     (SELECT AVG(PRICE) + 100
     FROM ANTIQUES);

La sous-requete calcule le Prix moyen, ajoute 100, et, et en utilisant ce 
chiffre on imprime un OwnerID pour chaque article coutant plus que ce chiffre. 
On peut utiliser DISTINCT OWNERID, pour eliminer les doubles.

Listons les Noms (Last Names) de ceux qui sont dans la table AntiqueOwners, 
SEULEMENT s'ils ont achete un article :

SELECT OWNERLASTNAME
FROM ANTIQUEOWNERS
WHERE OWNERID =

     (SELECT DISTINCT BUYERID
     FROM ANTIQUES);

Cette sous-requete retourne une liste des acheteurs, et le Nom du proprietaire 
d'un objet ancien est imprime seulement si l'identificateur du Proprietaire 
(Owner's ID) dans la liste obtenue par la sous-requete (appelee quelquefois 
liste des candidats).

Voici un exemple de mise a jour: nous savons que la personne qui a achete la 
bibliotheque a un Prenom errone dans la base de donnees... Ce devrait etre 
John :

UPDATE ANTIQUEOWNERS
SET OWNERFIRSTNAME = 'John'
WHERE OWNERID =

     (SELECT BUYERID
     FROM ANTIQUES
     WHERE ITEM = 'Bookcase');

Tout d'abord, la sous-requete trouve le BuyerID pour la (les) personne(s) qui 
a (ont) achete(s) la bibliotheque, puis la requete externe met a jour son 
Prenom.

Souvenez vous de cette regle a propos des sous-requetes: quand vous avez une 
sous-requete faisant partie d'une condition WHERE, la clause SELECT dans la 
sous-requete doit avoir des colonnes qui correspondent en nombre et en type 
a celle de la clause WHERE de la requete externe. En d'autres termes, si vous 
avez "WHERE ColumnName = (SELECT...);", le SELECT ne peut faire reference qu'a 
une seule colonne, pour pouvoir correspondre a la clause WHERE externe, et 
elles doivent etre du meme type (les deux etant soit entiers, soit chaines 
de caracteres, etc.).

----------------------------------------------------------------------------
EXISTS et ALL

EXISTS utilise une sous-requete comme condition, ou cette condition est Vraie 
si la sous-requete retourne au moins une ligne et Fausse si la sous-requete 
n'en retourne aucune; c'est une fonctionnalite qui n'est pas intuitive et 
n'est utilisee que dans peu de cas. Cependant, si un client eventuel voulait 
consulter la liste des proprietaires pour voir s'il y a des chaises (Chairs), 
essayez :

SELECT OWNERFIRSTNAME, OWNERLASTNAME
FROM ANTIQUEOWNERS
WHERE EXISTS

     (SELECT *
     FROM ANTIQUES
     WHERE ITEM = 'Chair');

S'il y a des Chaises (Chair) dans une colonne de la table ANTIQUES, la 
sous-requete renverra une ou plusieurs lignes, rendant la clause EXISTS 
vraie, ce qui amenera SQL a donner une liste des proprietaires dans 
ANTIQUEOWNERS. S'il n'y avait eu aucune Chaise, la requete externe n'aurait 
pas renvoye de ligne.

ALL est une autre fonctionnalite peu commune, et en general, on peut realiser 
une requete avec ALL de manieres differentes et eventuellement plus simples; 
regardons cet exemple de requete :

SELECT BUYERID, ITEM
FROM ANTIQUES
WHERE PRICE >= ALL

     (SELECT PRICE
     FROM ANTIQUES);

Ceci va nous retourner l'article de prix le plus eleve (ou plus d'un article 
s'il y a des ex-aequo), et son acheteur. La sous-requete renvoie la liste de 
tous les Prix (PRICE) dans la table ANTIQUES, puis la requete externe examine 
chaque ligne de la table ANTIQUES et si son Prix est superieur ou egal a chacun 
(ou ALL, TOUS) des Prix de cette liste, il est affiche, donnant ainsi l'article 
de prix le plus eleve. La raison pour laquelle ">=" doit etre utilise est que 
l'article de prix le plus eleve sera egal au prix le plus eleve, puisque cet 
Article est dans la liste de Prix.

----------------------------------------------------------------------------
UNION et Jointure Externe

Il y a des occasions  ou vous pouvez desirer voir ensembles les resultats de 
requetes multiples, leurs sorties etant combinees; pour cela utilisez UNION. 
Pour fusionner la sortie des deux requetes suivantes, en affichant l'identificateur 
de tous les Acheteurs plus tous ceux qui ont passe une Commande :

SELECT BUYERID
FROM ANTIQUEOWNERS
UNION
SELECT OWNERID
FROM ORDERS;

Il faut noter que SQL necessite que les types de donnees des listes des clauses 
SELECT correspondent colonne par colonne. Dans cet exemple, les identificateurs 
BuyerID et OwnerID sont du meme type (entier). Notez egalement que SQL 
effectue automatiquement une elimination des doubles quand on utilise la clause 
UNION (comme si c'etaient deux "ensembles"); dans une requete simple, il faut 
utiliser la clause DISTINCT.

La jointure externe est utilisee quand une requete de jointure est "unifiee", 
les lignes n'etant pas incluses dans la jointure. Ceci est particulierement 
utile si des "balises" de type constante texte sont inclus. D'abord, 
regardez la requete :

SELECT OWNERID, 'is in both Orders & Antiques'
FROM ORDERS, ANTIQUES
WHERE OWNERID = BUYERID
UNION
SELECT BUYERID, 'is in Antiques only'
FROM ANTIQUES
WHERE BUYERID NOT IN

     (SELECT OWNERID
     FROM ORDERS);

La premiere requete effectue une jointure pour lister tous les proprietaires 
qui sont dans les deux tables, et met une balise apres l'identificateur (ID) 
en inserant le texte correspondant a la balise. La clause UNION fusionne cette 
liste avec la liste suivante. La seconde liste est generee premierement en 
listant les identificateurs (ID) qui ne sont pas dans la table ORDERS, c'est a 
dire en generant une liste des ID exclus de la requete de jointure.. Puis, 
chaque ligne de la table ANTIQUES est analysee, et, si l'identifiant de 
l'acheteur (BuyerID) n'est pas dans cette liste d'exclusion, il est liste avec 
le texte correspondant a sa balise. Il y aurait peut-etre une meilleure 
maniere de creer cette liste, mais c'est difficile de generer des balises 
informationnelles.

Ce concept est utile dans des situations ou une cle primaire est en relation 
avec une cle externe, et ou la valeur de la cle externe est NULLE (NULL) pour 
quelques cles primaires. Par exemple, dans une table, la cle primaire est 
vendeur, et dans une autre table client, avec le vendeur enregistre dans la 
meme ligne. Cependant, si un vendeur n'a pas de clients, le nom de cette 
personne n'apparaitra pas dans la table des clients. Une jointure externe sera 
utilisee pour imprimer une liste de tous les vendeurs, avec leurs clients, que 
le vendeur ait un client ou pas--c'est a dire qu'il n'y aura pas de client 
imprime (valeur logique NULL) si le vendeur n'a pas de client, mais existe dans 
la table des vendeurs. Autrement, le vendeur sera liste avec chaque client.

ASSEZ DE REQUETES!!! Qu'est-ce que vous dites?...Eh bien, maintenant voyons 
quelque chose de completement different...
 
----------------------------------------------------------------------------
SQL incorpore--un vilain exemple (n'ecrivez pas un programme comme cela... il 
est la UNIQUEMENT a titre d'exemple)

/* -Voici un exemple de programme qui utilise le SQL incorpore (Embedded
    SQL). Le SQL incorpore permet aux programmeurs de se connecter a une 
    base de donnees et d'inclure du code SQL en plein programme, et ainsi, 
    leurs programmes peuvent utiliser, manipuler, et traiter les donnees 
    d'une base de donnees.
   -Cet exemple de Programme C (qui utilise du SQL incorpore) doit imprimer 
    un rapport.
   -Les instructions SQL devront etre precompilees avant d'effectuer la 
    compilation normale.
   -Si vous utilisez un langage different les parties EXEC SQL seront les 
    memes (standard), mais le code C qui les entourent devront etre 
    modifiees, y compris les declarations de variables hotes.
   -Le SQL incorpore differe de systeme a systeme, aussi, encore une fois, 
    verifiez la documentation locale, specialement les declarations de 
    variables et les procedures de connexion pour lesquelles le reseau, le 
    SGBD, et le systeme d'exploitation sont cruciaux. */

/***************************************************/
/* CE PROGRAMME N'EST PAS COMPILABLE OU EXECUTABLE */
/* IL EST UNIQUEMENT DONNE A TITRE D'EXEMPLE       */
/***************************************************/

#include <stdio.h>

/* Section de declaration des variables hotes; ce seront les variables 
utilisees par votre programme, mais egalement celles utilisees par SQL 
pour y mettre ou y lire des valeurs,. */
EXEC SQL BEGIN DECLARE SECTION;
  int BuyerID;
  char Prenom[100], Nom[100], Item[100];
EXEC SQL END DECLARE SECTION;

/* Cette section,insere les variables SQLCA, de facon a pouvoir tester les erreurs. */
EXEC SQL INCLUDE SQLCA;

main() (

/* Ceci est une possibilite pour se connecter a la base de donnees */
EXEC SQL CONNECT UserID/Password;

/* Cette partie de code soit vous indique que vous etes connecte  soit 
teste si un code erreur a ete genere, signifiant que la connexion etait 
incorrecte ou impossible. */
  if(sqlca.sqlcode) (
    printf(Printer, "Erreur de connexion au serveur de base de donnees.\n");
    exit();
  )
  printf("Connecte au serveur de base de donnees.\n");

/* Ici, on declare un "Curseur". C'est utilise lorsqu'une requete retourne 
   plus d'une ligne, et qu'on doit effectuer un traitement sur chaque ligne 
   obtenue de la requete. Je vais utiliser pour le rapport, chaque ligne obtenue 
   par cette requete. Ensuite, on utilisera "FETCH" (va chercher) pour recuperer 
   les lignes, une par une, mais pour que la requete soit effectivement executee, 
   il faut utiliser l'instruction "OPEN". La "Declaration" (Declare) sert 
   uniquement a construire la requete. */
EXEC SQL DECLARE ItemCursor CURSOR FOR
  SELECT ITEM, BUYERID
  FROM ANTIQUES
  ORDER BY ITEM;
EXEC SQL OPEN ItemCursor;

/*
 +-- Inserer ici un test d'erreur similaire au precedent si vous le desirez --+ 
*/

/* L'instruction FETCH insere les valeurs de la ligne suivante respectivement 
dans chacune des variables hotes. Cependant un "priming fetch" (technique de 
programmation) doit etre execute en premier. Lorsque le curseur n'a plus de 
donnees un code (sqlcode) est genere nous permettant de sortir de la boucle. 
Notez que, pour des raisons de simplicite, on abandonne la boucle pour n'importe
quel sqlcode, meme s'il correspond a un code erreur. Autrement, il faut 
effectuer un test d'erreur specifique. */
EXEC SQL FETCH ItemCursor INTO :Item, :BuyerID;
  while(!sqlca.sqlcode) (

/* Nous effectuerons egalement deux traitements pour chaque ligne. Premierement, 
augmenter le prix de 5 (retribution du marchand) et ensuite, lire le nom de 
l'acheteur pour le mettre dans le rapport. Pour faire cela, j'utiliserai les 
instructions Update et Select, avant d'imprimer la ligne sur l'ecran. La mise a 
jour suppose, cependant, qu'un acheteur donne n'a achete qu'un seul article, 
ou, sinon, le prix sera augmente de trop nombreuses fois. Sinon, il aurait 
fallu utiliser une logique "RowID" (consulter la documentation). De plus, 
notez la presence du signe : (deux points) qui doit etre place devant les 
noms de variables hotes quand elles sont utilisees dans des instructions 
SQL. */

EXEC SQL UPDATE ANTIQUES
  SET PRICE = PRICE + 5
  WHERE ITEM = :Item AND BUYERID = :BuyerID;

EXEC SQL SELECT OWNERFIRSTNAME, OWNERLASTNAME
  INTO :Prenom, :Nom
  FROM ANTIQUEOWNERS
  WHERE BUYERID = :BuyerID;

    printf("%25s %25s %25s", Prenom, Nom, Item);

/* Rapport grossier--uniquement a but d'exemple! Aller chercher la ligne suivante */
EXEC SQL FETCH ItemCursor INTO :Item, :BuyerID;
  )

/* Fermer le curseur, enregistrer les modifications (voir ci-dessous), 
et quitter le programme. */
EXEC SQL CLOSE DataCursor;
EXEC SQL COMMIT RELEASE;
  exit();
)

----------------------------------------------------------------------------
Questions courantes sur SQL--Sujets avances 
(Consulter les liens FAQ pour en avoir plusieurs autres)

  1. Pourquoi ne puis-je pas demander uniquement les trois premieres lignes 
     d'une table? --Parce que, dans une base de donnees relationnelle, les
     lignes sont inserees sans aucun ordre particulier, c'est a dire que le 
     systeme les inserent dans un ordre arbitraire; de ce fait, vous ne pouvez 
     demander des lignes qu'en utilisant des fonctionnalites SQL valides, 
     telles que ORDER BY, etc.
  2. Que sont ces DDL et DML dont j'entends parler ? --DDL (Data 
     Definition Language - Langage de Definition de Donnees) fait reference a 
     (en SQL) l'instruction de Creation de Table (Create Table)...DML (Data 
     Manipulation Language - Langage de Manipulation de Donnees) fait reference 
     aux instructions Select, Update, Insert, et Delete.
  3. Les tables des base de donnees ne sont elles pas simplement des fichiers? 
     --Eh bien, les SGBD stockent les donnees dans des fichiers declares par 
     le gestionnaire du systeme avant que de nouvelles tables ne soient creees 
     (sur les grands systemes), mais le systeme stocke les donnees dans un 
     format special, et peut repartir les donnees d'une table dans plusieurs 
     fichiers. Dans le monde des bases de donnees, un ensemble de fichiers 
     crees pour une base de donnees est appele un "espace de tables". En 
     general, sur les petits systemes, tout ce qui concerne une base de donnees 
     (definitions et toutes les tables de donnees) est stocke dans un seul 
     fichier.
  4. (Question en relation avec la precedente) Les bases de donnees ne sont 
     elles pas simplement que des tableurs? --Non, et ceci pour deux raisons. 
     Premierement, les tableurs peuvent avoir des donnees dans une cellule, mais 
     une cellule est plus qu'une intersection ligne-colonne. Selon votre 
     tableur, une cellule peut aussi contenir des formules et un formatage, 
     ce que les bases de donnees (actuelles) ne permettent pas. Deuxiemement, 
     les cellules dependent souvent des donnees presentes dans d'autres 
     cellules. Dans les bases de donnees, les "cellules" sont independantes, 
     sauf que les colonnes sont en relation logique (heureusement: ensembles, 
     une ligne et une colonne decrivent une entite), et, en dehors des 
     contraintes de cle primaire et de cle externe, chaque ligne d'une table 
     est independante des autres.
  5. Comment puis-je importer un fichier texte de donnees dans une base de 
     donnees? --Eh bien, vous ne pouvez pas le faire directement...il vous faut 
     utiliser un programme utilitaire, tel que le SQL*Loader pour Oracle,
     ou ecrire un programme pour charger les donnees dans la base de donnees. 
     Un programme pour realiser cela lit simplement chaque enregistrement du 
     fichier texte, le separe en colonnes, et effectue une insertion (INSERT) 
     dans la base de donnees.
  6. Qu'est-ce qu'un schema? --Un schema est un ensemble logique de tables, tel 
     que la base de donnees ANTIQUES ci-dessus...habituellement, on s'y refere 
     simplement en tant que "base de donnees", mais une base de donnees peut 
     contenir plus d'un schema. Par exemple, un schema en etoile est un ensemble
     de tables ou une table centrale, de grande taille, contient toutes les 
     informations importantes, et est liee, via des cles externes, a des tables 
     de dimension qui contiennent l'information detaillee, et qui peuvent etre 
     utilisees dans une jointure pour creer des rapports detailles.
  7. Quels conseils generaux pourriez vous donner pour rendre mes requetes SQL 
     et mes bases de donnees meilleures et plus rapides (optimisees)?  
        o Vous devriez essayer, si vous le pouvez, d'eviter, dans les clauses 
          SELECT, des expressions telles que SELECT ColumnA + ColumnB, etc. 
          L'optimiseur de requetes de la base de donnees, partie du SGBD qui 
          determine la meilleure maniere d'extraire les donnees requises de la 
          base de donnees elle-meme, traite les expressions d'une facon telle 
          que cela demande en general plus de temps pour extraire les donnees 
          que si les colonnes avaient ete selectionnees normalement, et que 
          l'expression elle-meme calculee par programme.
        o Minimisez le nombre de colonnes incluses dans une clause Group By.
        o Si vous effectuez une jointure, tachez d'avoir les colonnes, de cette
          jointure, indexees (dans les deux tables).
        o Si vous avez un doute, creez un index.
        o A moins que vous ne fassiez de multiple comptages ou une requete 
          complexe, utilisez COUNT(*) (le nombre de lignes sera genere par la 
          requete) plutot que COUNT(Column_Name).
  8. Qu'est-ce que la Normalisation? --La Normalisation est une technique de 
     conception de base de donnees qui suggere qu'un certain critere doit etre 
     pris en compte quand on definit l'organisation des tables (prise de 
     decision sur le nombre de colonnes de chaque table, et creation de la 
     structure des cles), ou l'idee est d'eliminer la redondance a travers les 
     tables des donnees qui ne sont pas des cles. On parle de la normalisation 
     en s'y referant habituellement en termes de "formes", et j'introduirais ici
     uniquement les trois premieres, bien qu'il soit tout a fait courant d'en 
     utiliser d'autres formes, plus avancees (quatrieme, cinquieme, Boyce-Codd; 
     consultez la documentation).

     La Premiere Forme Normale consiste a placer les donnees dans des tables 
     separees ou les donnees dans chaque tables sont de type similaire, et a 
     donner a chaque table une cle primaire.

     Mettre les donnees en Seconde Forme Normale consiste a mettre les donnees 
     dans les tables ou elle ne dependent uniquement que d'une partie de la cle.
     Par exemple, si j'avais laisse les noms des proprietaires d'objets anciens 
     dans la table des articles, ce n'aurait pas ete une seconde forme normale 
     puisque les donnees auraient ete redondantes; le nom aurait du etre 
     repete pour chaque article possede, donc, les noms ont ete places dans 
     leur propre table. Les noms en eux-memes n'ont rien a voir avec les 
     articles, seules les identites des acheteurs et des vendeurs sont 
     concernees.

     La Troisieme Forme Normale consiste a se debarrasser, dans une table, a 
     tout ce qui ne depend pas uniquement de la cle primaire. On met uniquement 
     l'information qui depend de la cle, et l'on deplace, dans d'autres tables, 
     tout ce qui est independant de la cle primaire, et l'on cree des cles 
     primaires pour les nouvelles tables.

     Il y a une certaine forme de redondance dans chaque forme, et si les 
     donnees sont en 3NF (abrege pour 3ieme forme normale), elles sont deja en  
     1NF et 2NF. En terme d'organisation des donnees, organisez vos donnees de 
     facon que les colonnes qui ne sont pas des cles primaires dependent 
     seulement de la cle primaire entiere. Si vous jetez un oeil sur la base de 
     donnees en exemple, vous verrez que, lorsque vous naviguez a travers la 
     base de donnees, c'est au travers de jointures qui utilisent les colonnes 
     de cle commune.

     Deux autre points importants dans la conception de bases de donnees sont 
     l'utilisation de noms significatifs, bien choisis, coherents et logiques 
     pour les tables et les colonnes et l'utilisation de noms significatifs pour
     la base de donnees elle-meme. Sur le dernier point, ma base de donnees 
     peche, puisque j'utilise des codes numeriques comme identificateurs. C'est 
     en general bien meilleur d'utiliser, si possible, des cles qui ont, en 
     elles-memes, un sens; par exemple, une meilleure cle pourrait consister 
     des quatre premieres lettres du nom et de la premiere initiale du prenom, 
     comme JONEB pour Bill Jones (ou pour eviter les doubles, ajoutez-y des 
     nombres a la fin pour differencier deux ou plusieurs personnes ayant le 
     meme nom, ainsi, on pourrait essayer JONEB1, JONEB2, etc.).
  9. Quelle est la difference entre une requete simple ligne et une requete 
     multi-lignes et pourquoi est-ce important de connaitre cette 
     difference? --Premierement, pour parler de ce qui est evident, une requete
     simple ligne est une requete qui retourne une ligne unique comme resultat,
     et le resultat d'une requete multi-lignes est constitue de plusieurs 
     lignes. Qu'une requete retourne une ligne ou plusieurs depend completement
     de la conception (ou schema) des tables qui constituent la base de donnees.
     Assurez-vous d'inclure suffisamment de conditions, et structurez vos 
     instructions SQL correctement, de facon a obtenir le resultat desire (soit 
     une ligne, soit plusieurs). Par exemple, si vous vouliez etre sur qu'une 
     requete sur la table AntiqueOwners ne retourne qu'une ligne, employez une 
     condition d'egalite sur la cle primaire, OwnerID.

     Trois raisons, concernant l'importance de ce sujet, viennent immediatement 
     a l'esprit.
     Premierement, l'obtention de plusieurs lignes alors que vous n'en attendez 
     qu'une, ou vice-versa, peut signifier que la requete est erronee, que la 
     base de donnees est incomplete, ou simplement que vous decouvrez quelque
     chose de nouveau concernant vos donnees.
     Deuxiemement, si vous utilisez une instruction de mise a jour (UPDATE) ou 
     de suppression (DELETE), il vaudrait mieux vous assurer que l'instruction 
     que vous ecrivez effectue bien l'operation sur la ligne desiree (ou les 
     lignes)...ou sinon, vous pourriez supprimer ou mettre a jour plus de lignes
     que vous ne le desirez. 
     Troisiemement, il faut soigneusement penser au nombre de lignes qui seront 
     retournees pour toutes les requetes redigees  en SQL incorpore. Si vous 
     ecrivez une requete simple ligne, une seule instruction SQL peut suffire 
     pour satisfaire a la logique du programme. D'un autre cote, si votre 
     requete retourne de multiples lignes, il vous faudra utiliser 
     l'instruction FETCH, et tres certainement quelque chose comme une structure 
     de boucle sera necessaire dans votre programme pour traiter chaque ligne 
     retournee par la requete.
 10. Que sont les relations? --C'est une autre question de conception...le 
     terme "relation" fait habituellement reference aux relations entre cles 
     primaires et externes entre les tables. Ce concept est important parce que, 
     quand les tables d'une base de donnees relationnelle sont concues, ces 
     relations doivent etre definies parce que cela determine quelles colonnes 
     sont ou ne sont pas des cles primaires ou externes. Vous avez peut-etre 
     entendu parler des diagrammes Entites-Relations, qui sont une 
     representation graphique des tables dans les schema de la base de donnees. 
     Voyez l'exemple de diagramme a la fin de cette section ou consultez 
     quelques sites indiques ci-dessous concernant ce sujet, car il y a de 
     nombreuses manieres de dessiner les diagrammes E-R. Mais d'abord, jetons 
     un oeil a chaque type de relation...

     Une relation 1-a-1 (ou 1:1, ou 1-1) signifie que vous avez une colonne cle 
     primaire  et que chaque cle primaire est en relation avec une cle externe. 
     Par exemple, dans le premier exemple, dans la table des adresses des 
     employes TableAdresseEmploye nous avons une colonne numero d'identification
     de l'employe (EmployeeIDNo). Donc, la table TableAdresseEmploye est en 
     relation avec la table EmployeeStatisticsTable (deuxieme exemple de table) 
     par l'intermediaire du numero EmployeeIDNo. Plus precisement, chaque 
     employe, de la table TableAdresseEmploye possede des statistiques (une 
     ligne de donnees) dans la table EmployeeStatisticsTable. Meme si c'est un 
     exemple invente, c'est une relation "1-1". Inscrivez en caracteres gras le 
     "has" ("a" ou "possede")...quand on decrit une relation, il est important 
     de decrire une relation en utilisant un verbe.

     Les deux autres types de relations peuvent ou pas utiliser une cle primaire
     logique et des contraintes par rapport aux cles externes...cela depend 
     strictement des souhaits du concepteur. La premiere de ces relations est la
     relation un-a-plusieurs ("1-M").
     Cela signifie que pour chaque valeur d'une colonne dans une table, il y a 
     une ou plusieurs valeurs correspondantes dans une autre table. Des 
     contraintes de cle peuvent etre ajoutees au modele, ou eventuellement une 
     colonne d'identification peut etre utilisee pour etablir une relation. Un 
     exemple serait que pour chaque OwnerID dans la table AntiqueOwners, il y 
     ait un ou plusieurs (la valeur zero est egalement autorisee) articles 
     (Items) achetes dans la table  ANTIQUES (verbe: acheter).

     Finalement, la relation plusieurs-a plusieurs ("M-M") n'utilise 
     generalement pas de cles, et habituellement utilise des identificateurs de 
     colonnes. L'apparition inhabituelle d'une relation "M-M" signifie qu'une 
     colonne, dans une table est en relation avec une autre colonne dans une 
     autre table, et que pour chaque valeur de l'une de ces deux colonnes, il y 
     a une ou plusieurs valeurs correspondantes dans la colonne correspondante 
     de l'autre table (et vice-versa), ou possibilite plus courante, les deux 
     tables ont une relation  1-M avec l'autre (deux relations, une 1-M dans 
     chaque direction). Un [mauvais] exemple de la situation la plus courante 
     consisterait, si vous avez une bases de donnees de fonctions, a avoir une 
     table possedant une ligne pour chaque employe et sa fonction, et d'avoir 
     une autre table contenant une ligne pour chaque fonction avec un des 
     employes l'occupant. Dans ce cas, vous auriez plusieurs lignes pour chaque
     employe dans la premiere table, une pour chaque fonction, et plusieurs 
     lignes pour chaque fonction dans le seconde table, une pour chaque employe 
     ayant cette fonction.
     Ces tables sont en relation M-M: chaque employe, dans la premiere table a 
     plusieurs fonctions dans la seconde table, et chaque fonction, dans la 
     seconde table, a plusieurs attributaires dans la premiere table. Ceci est 
     la partie emergee de l'iceberg concernant ce sujet...consultez les liens 
     ci-dessous pour avoir de plus amples informations et regardez le diagramme 
     ci-dessous donnant un exemple simplifie de diagramme E-R.
     [Exemple Simplifie de Diagramme Entites-Relations]

 11. Quelles sont quelques unes des fonctionnalites importantes, non standard, 
     de SQL (Question extremement courante)? --Eh bien, nous allons voir ca dans
     la section suivante...

----------------------------------------------------------------------------
SQL Non-standard..."A verifier pour votre site"

   * INTERSECT et MINUS sont comme des instructions UNION , sauf que INTERSECT
     produits des lignes qui apparaissent dans les deux requetes, et que MINUS 
     produit des lignes provenant de la premiere requete mais pas de la 
     seconde.
   * Fonctionnalites de la Generation de Rapport: la clause COMPUTE est placee 
     a la fin d'une requete pour placer le resultat d'une fonction agregee a 
     la fin d'une liste, comme COMPUTE SUM (PRICE); Une autre solution est 
     d'utiliser une logique d'interruption: definir une interruption pour 
     diviser les resultats de la requete en groupes bases sur une colonne, 
     comme BREAK ON BUYERID. Alors, pour sortir un resultat apres la liste d'un 
     groupe, utilisez COMPUTE SUM OF PRICE ON BUYERID. Si, par exemple, vous 
     avez utilise ces trois clauses ("BREAK" en premier, "COMPUTE on break" en 
     second, "COMPUTE overall sum" en troisieme), vous obtiendrez un rapport qui 
     regroupera les articles par acheteurs, listera la somme de Prix pour chaque
     groupe d'articles d'un acheteur, puis, apres que tous les groupes aient ete
     listes, listera la somme de tous les Prix, le tout, avec des en-tetes et 
     des lignes generes par SQL.
   * En plus des fonctions agregees indiquees ci-dessus, quelques SGBD ont des 
     fonctions supplementaires qui peuvent etre utilisees dans des listes de 
     selection (SELECT), sauf que ces fonctions (quelques fonctions caracteres 
     autorisent des resultats de plusieurs lignes) doivent etre utilisees avec 
     une valeur individuelle (pas de groupes), pour des requetes simple ligne. 
     De plus, les fonctions ne doivent etre utilisees qu' avec les types de 
     donnees appropries. Voici quelques Fonctions Mathematiques:

      ABS(X)       Valeur A-convertit les nombres negatifs en nombres positifs 
                   et laisse les positifs inchanges
      CEIL(X)      X est une valeur decimale qui sera arrondie a la valeur 
                   superieure.
      FLOOR(X)     X est une valeur decimale qui sera arrondie a la valeur 
                   inferieure.
      GREATEST(X,Y)Retourne la plus grande des deux valeurs.
      LEAST(X,Y)   Retourne la plus petite des deux valeur.
      MOD(X,Y)     Retourne le reste de X / Y.
      POWER(X,Y)   Retourne X a la puissance Y.

      ROUND(X,Y)   Arrondit X a Y positions decimales. i Y n'est pas donne, X 
                   est arrondi a la valeur de l'entier le plus proche.
      SIGN(X)      Retourne le signe - si X < 0, sinon retourne un signe plus.
      SQRT(X)      Retourne la racine carree de  X.

                               Fonctions Caracteres

      LEFT(<string>,X)
                           Retourne les X caracteres les plus a gauche de la 
                           chaine de caracteres.

      RIGHT(<string>,X)
                           Retourne les X caracteres les plus a droite de la 
                           chaine de caracteres.
      UPPER(<string>)
                           Convertit tous les caracteres de la chaine en 
                           majuscules.
      LOWER(<string>)
                           Convertit tous les caracteres de la chaine en 
                           minuscules.
      INITCAP(<string>)
                           Convertit les caracteres initiaux de la chaine en 
                           Capitales.
      LENGTH(<string>)
                           Retourne le nombre de caracteres de la chaine.

      <string>||<string>
                           Combine les deux chaines en une seule chaine, 
                           concatenee, ou la premiere chaine est immediatement 
                           suivie par la seconde.

      LPAD(<string>,X,'*')
                           Insere des caracteres * (ou n'importe quel autre, mis
                           entre guillemets) a gauche de la chaine de 
                           caracteres pour lui donner une longueur de X 
                           caracteres.

      RPAD(<string>,X,'*')
                           Insere des caracteres * (ou n'importe quel autre, mis
                           entre guillemets) a droite de la chaine de 
                           caracteres pour lui donner une longueur de X 
                           caracteres.

      SUBSTR(<string>,X,Y)
                           Extrait Y lettres de la chaine a partir de la 
                           position X.

      NVL(<column>,<value>)
                           La fonction NVL va substituer la valeur <value>
                           pour chaque valeur nulle dans la colonne <column>. Si
                           la valeur courante dans la colonne <column> n'est pas
                           nulle (NULL), NVL est sans effet.

----------------------------------------------------------------------------
Resume de la Syntaxe--Pour Utilisateurs Avances Seulement

Voici la forme generale des instructions dont il a ete question dans ce
didacticiel, avec, en plus, quelques autres, (des explications sont donnees). 
SOUVENEZ-VOUS que toutes ces instructions peuvent ne pas etre disponibles sur 
votre systeme, aussi verifiez leur disponibilite dans la documentation:

ALTER TABLE <TABLE NAME> ADD|DROP|MODIFY (COLUMN SPECIFICATION[S]...voir
Create Table); --vous permet d'ajouter ou de supprimer une ou plusieurs colonnes
d'une table, ou de changer les specifications(donnees, types, etc.) d'une colonne
existante;
cette instruction est egalement utilisee pour changer les specifications 
physiques d'une table
(comment la table est stockee, etc.), mais ces definitions sont specifiques au 
SGBD, aussi, lire la documentation. De meme, ces specifications physiques sont 
utilisees avec les instructions de creation de table, lorsqu'une table est creee 
pour la premiere fois. De plus, seulement une seule option peut etre executee 
par instruction de modification: (Alter Table)--soit add (ajout), drop 
(suppression), OU modify (modification) dans une simple instruction.

COMMIT; --rend les modifications effectuees sur une bases de donnees permanentes
(depuis le dernier COMMIT; connu sous le nom de transaction)

CREATE [UNIQUE] INDEX <INDEX NAME>
ON <TABLE NAME> (<COLUMN LIST>); --UNIQUE est optionnel; entre parentheses.

CREATE TABLE <TABLE NAME>
(<COLUMN NAME> <DATA TYPE> [(<SIZE>)] <COLUMN CONSTRAINT>,
...autres colonnes); (valide egalement avec ALTER TABLE)
--ou SIZE est uniquement utilise avec certains types de donnees (voir 
ci-dessus), et les contraintes incluent les possibilites suivantes (impose 
automatiquement par le SGBD;
(un non respect entraine la generation d'une erreur) :

  1. NULL ou NOT NULL (voir ci-dessus)
  2. UNIQUE impose que deux lignes ne peuvent avoir la meme valeur pour cette 
colonne
  3. PRIMARY KEY indique a la base de donnees que cette colonne est la colonne 
cle primaire (utilise uniquement si la cle est une colonne cle, autrement une 
instruction
     PRIMARY KEY (column, column, ...) apparait apres la derniere definition de
colonne.
  4. CHECK permet de tester une condition quand on insere ou on met a jour une 
donnee dans cette colonne; par exemple, CHECK (PRICE > 0) amene le systeme a 
tester si la colonne Prix est superieure ou egale a zero avant d'accepter la 
valeur...quelquefois implante comme instruction CONSTRAINT.
  5. DEFAULT insere une valeur par defaut dans la base de donnees si l'on veut 
inserer une ligne qui ne contienne pas de valeur pour cette colonne; par 
exemple,
     BENEFITS INTEGER DEFAULT = 10000
  6. FOREIGN KEY fonctionne comme la Cle Primaire, mais est suivi par:
     REFERENCES <TABLE NAME> (<COLUMN NAME>), qui fait reference a la cle primaire 
     de reference.

CREATE VIEW <TABLE NAME> AS <QUERY>;

DELETE FROM <TABLE NAME> WHERE <CONDITION>;

INSERT INTO <TABLE NAME> [(<COLUMN LIST>)]
VALUES (<VALUE LIST>);

ROLLBACK; --Annule toutes les modifications effectuees dans la base de donnees, 
celles qui ont ete faites depuis la derniere commande COMMIT...Attention! 
Quelques logiciels travaillant en transactions, donc, la commande ROLLBACK peut 
ne pas fonctionner.

SELECT [DISTINCT|ALL] <LIST OF COLUMNS, FUNCTIONS, CONSTANTS, ETC.>
FROM <LIST OF TABLES OR VIEWS>
[WHERE <CONDITION(S)>]
[GROUP BY <GROUPING COLUMN(S)>]
[HAVING <CONDITION>]
[ORDER BY <ORDERING COLUMN(S)> [ASC|DESC]]; --ou ASC|DESC permet le classement en
ordre ascendant (ASCending) ou descendant (DESCending)

UPDATE <TABLE NAME>
SET <COLUMN NAME> = <VALUE>
[WHERE <CONDITION>]; --si la clause WHERE n'est pas donnee, toutes les lignes 
seront mises a jour selon l'instruction SET

----------------------------------------------------------------------------
Liens Importants

Liens Informatique & SQL/DB : Netscape -- Oracle -- Sybase -- Informix
--Microsoft
Page de Reference -- Ask the SQL Pro -- SQL Pro's Relational DB 
Sites Utiles
Programmer's Source -- DBMS Sites -- inquiry.com -- DB Ingredients
Web Authoring -- Computing Dictionary -- DBMS Lab/Links -- SQL FAQ -- SQL
Databases
RIT Database Design Page -- Database Jump Site -- Didacticiels de programmation sur le Web
Ressources pour le Developpement -- Query List -- IMAGE SQL

Divers: CNN -- USA Today -- Pathfinder -- ZDNet -- Metroscope -- CNet

Liste de ressources sur Internet -- Netcast Weather -- TechWeb -- LookSmart

Moteurs de Recherche: Yahoo -- Alta Vista -- Excite -- WebCrawler -- Lycos --
Infoseek -- search.com

L'auteur n'est pas reponsable de ces sites.
----------------------------------------------------------------------------
Avertissement

J'espere que vous aurez appris quelque chose de ce premier regard sur un langage 
tres important qui est en train de devenir plus repandu dans le mode de 
l'informatique client-serveur. J'ai redige cette page web pour apporter quelque 
chose d'utile au  web et a la communaute des utilisateurs du web. En realite, 
j'ai appris que ce document est utilise dans plusieurs colleges pour des cours 
sur les bases de donnees et par des chercheurs. En outre, lisez cette page dans 
le nouveau livre, edite par Waite Publishing, sur Borland C++ Builder, qui sera 
publie cet ete et dans une version a venir chez Sams Publishing. De plus, je 
voudrais remercier tous les gens, sur les cinq continents, qui m'ont contactes 
a propos de cette page.

J'espere aussi continuer a ajouter plus d'elements a ce didacticiel, tels que 
des articles sur la conception d'une base de donnees et les extensions SQL non 
standard, meme si je souhaite me tenir a l'ecart de particularites propres a 
un Systeme de Gestion de Base de Donnee. Bonne chance pour vos developpements 
en SQL et autres aventures informatiques.

Jim Hoffman
----------------------------------------------------------------------------
Commentaires ou Suggestions? Envoyez-moi un courrier electronique a jhoffman@one.net.

Ou vous pouvez desirer jeter un oeil aux pages Web de  Jim Hoffman's Web Pages 
pour plus d'informations me concernant.

Copyright 1996-1997, James Hoffman. Ce document peut etre utilise gratuitement 
par n'importe quel utilisateur d'Internet, mais ne peut pas etre inclus dans 
un autre document, publie sous une autre forme, ou produit en masse de quelque 
facon que ce soit.

Netscape Navigator donne le meilleur affichage de cette page; celui-ci n'est pas
tres bon si l'on utilise Microsoft Internet Explorer.

Derniere mise a jour : 8-25-1997; ajout de quelques elements.


Chapitre suivant, Chapitre Précédent

Table des matières de ce chapitre, Table des matières générale

Début du document, Début de ce chapitre