SQL (partie LMD)

I. Introduction ........................................................................................................................1 Prsentation gnrale..........................................................................................................1 II. Architecture client-serveur et communication par SQL ...................................................3 Bases de donnes en client-serveur .......................................................................................3 Les serveurs de transactions ..................................................................................................4 III. Catgories d'instructions ..................................................................................................4 IV. Interroger une base Langage de manipulation de donnes (LMD) : SELECT (1 re partie) .....................................................................................................................................6 Traduction des oprateurs de projection, slection, produit cartsien de l'algbre relationnelle (1 re partie) ....................................................................................................6 Syntaxe gnrale de la commande SELECT......................................................................6 La clause SELECT : ...........................................................................................................7 La clause ORDER BY........................................................................................................8 La clause WHERE..............................................................................................................9 SQL : Sous-Interrogations (sous-requtes)..........................................................................11 V. Interroger une base Langage de manipulation de donnes (LMD) : SELECT (2 me partie) ...................................................................................................................................14 1 La clause FROM (2 me partie) : les jointures...............................................................14 .2 Les clauses GROUP BY et HAVING et les fonctions d'agrgation...........................21 VI. Traduction des oprateurs d'union, d'intersection, de diffrence et de division de l'algbre relationnelle (2 me partie)......................................................................................23 VII -Modifier une base Langage de manipulation de donnes (LMD) ............................26 .1 Insertion de n-uplets : INSERT INTO ........................................................................26 .2 Modification de n-uplets : UPDATE ..........................................................................27 .3 Suppression de n-uplets : DELETE ............................................................................28 I. Introduction Prsentation gnrale Introduction Le langage SQL (Structured Query Language) peut tre considr comme le langage d'accs normalis aux bases de donnes. Il est aujourd'hui support par la plupart des produits commerciaux que ce soit par les systmes de gestion de bases de donnes micro tel que Access ou par les produits plus professionnels tels que Oracle. Il a fait l'objet de plusieurs normes ANSI/ISO dont la plus rpandue aujourd'hui est la norme SQL2 qui a t dfinie en 1992. Le succs du langage SQL est d essentiellement sa simplicit et au fait qu'il s'appuie sur le schma conceptuel pour noncer des requtes en laissant le SGBD responsable de la stratgie d'excution. Le langage SQL propose un langage de requtes ensembliste et assertionnel. Nanmoins, le langage SQL ne possde pas la puissance d'un langage de
SQL DML M. TAIS TDI

programmation : entres/sorties, instructions conditionnelles, boucles et affectations. Pour certains traitements il est donc ncessaire de coupler le langage SQL avec un langage de programmation plus complet. De manire synthtique, on peut dire que SQL est un langage relationnel, il manipule donc des tables (i.e. des relations, c'est--dire des ensembles) par l'intermdiaire de requtes qui produisent galement des tables. Historique rapide

En 1970, E.F. CODD, directeur de recherche du centre IBM de San Jos, invente le modle relationnel qui repose sur une algbre relationnelle. Ce modle provoque une rvolution dans l'approche des bases des donnes. En 1977, cration du langage SEQUEL (Structured English Query Language) et mise en place du Systme R, prototype de base de donnes reposant sur la thorie de CODD. SEQUEL continue de s'enrichir pour devenir SQL (Structured Query Language). En 1981, la socit ORACLE CORP lance la premire version de son systme de gestion de base de donnes relationnelle (SGBDR), IBM sort SQL/DS et RTI lance INGRES. En 1982, IBM sort SQL/DS pour son environnement VM/CMS et l'ANSI (American National Standard Institute) lance un projet de normalisation d'un langage relationnel. En 1983, IBM lance DB2 pour l'environnement MVS. En 1986, la socit SYBASE lance son SGBDR conu selon le modle ClientServeur. La premire norme SQL (SQL-1) de l'ISO (International Standard Organisation) apparat. Il existe dsormais plusieurs dizaines de produits proposant le langage SQL et tournant sur des machines allant des micros aux gros systmes. Depuis, les diffrents produits phares ont volu, la norme SQL est passe SQL-2, puis SQL-3. SQL est dsormais un langage incontournable pour tout SGBD moderne. Par contre, bien qu'une norme existe, on assiste une prolifration de dialectes propres chaque produit : soit des sous-ensembles de la norme (certaines fonctionnalits n'tant pas implantes), soit des sur-ensembles (ajout de certaines fonctionnalits, propres chaque produit).

Oracle et Informix dominent le march actuel, SQL-Server (de Microsoft) tente de s'imposer dans le monde des PC sous NT. ct des ces produits, trs chers, existent heureusement des systmes libres et gratuits : MySQL et PostgreSQL sont les plus connus. Bien que ces SGBDR n'aient pas la puissance des produits commerciaux, certains s'en approchent de plus en plus. Les diffrences notables concernent principalement les
SQL DML M. TAIS TDI

environnements de dveloppement qui sont de vritables ateliers logiciels sous Oracle et qui sont rduits des interfaces de programmation C, Python, Perl sous PostgreSQL. Il en va de mme pour les interfaces utilisateurs : il en existe pour PostgreSQL, mais ils n'ont certainement pas la puissance de leurs quivalents commerciaux. II. Architecture client-serveur et communication par SQL Nous allons d'abord revoir les diffrents types d'application possibles pour la gestion de donnes distantes en commenant par les trois formes les plus simples. Monoposte. La base de donnes se trouve sur un poste et n'est pas accessible en rseau. Il faut, dans ce cas, penser la notion de scurit si plusieurs utilisateurs peuvent interroger la base (suppression accidentelle d'enregistrements). Multiposte, base sur des terminaux , lis un site central. C'est l'informatique multiposte traditionnelle. La gestion des donnes est centralise. Les applications ont t crites par le service informatique et seules ces applications peuvent interroger le serveur. Multiposte, base sur un serveur de fichiers. C'est la premire forme (la plus simple) d'architecture client-serveur. Si l'applicatif sur un PC souhaite visualiser la liste des clients habitant Paris, tous les enregistrements du fichier CLIENT transitent sur le rseau, entre le serveur et le client, la slection (des clients habitant Paris) est faite sur le PC. Le trafic sur le rseau est norme et les performances se dgradent lorsque le nombre de clients augmente. Les serveurs de fichiers restent trs utiliss comme serveurs d'images, de documents, d'archives. De nouveaux besoins sont apparus :

diminuer le trafic sur le rseau pour augmenter le nombre de postes sans nuire au fonctionnement, traiter des volumes de donnes de plus en plus grand, accder de faon transparente des donnes situes sur des serveurs diffrents, accder aux donnes de faon ensembliste, mme si les donnes sont distantes, afin de diminuer le travail du programmeur, adopter des interfaces graphiques de type Windows pour les applicatifs clients.

Bases de donnes en client-serveur Dans une architecture client-serveur, un applicatif est constitu de trois parties : l'interface utilisateur, la logique des traitements et la gestion des donnes. Le client n'excute que l'interface utilisateur et la logique des traitements, laissant au serveur de bases de donnes la gestion complte des manipulations de donnes.

Le serveur de bases de donnes fournit des services aux processus clients. Les tches qu'il doit prendre en compte sont : la gestion d'une mmoire cache, l'excution de requtes exprimes en SQL, excuter des requtes mmorises, la gestion des transactions, la scurit des donnes.
M. TAIS TDI

SQL DML -

Le client doit ouvrir une connexion pour pouvoir profiter des services du serveur. Il peut ouvrir plusieurs connexions simultanes sur plusieurs serveurs. Le client peut soumettre plusieurs requtes simultanment au serveur et traiter les rsultats de faon asynchrone. Communication entre le client et le serveur. Puisque l'application doit pouvoir se connecter divers serveurs de faon transparente, le langage de communication SQL doit tre compatible avec la syntaxe SQL de chaque serveur pressenti. Or, malgr les normes, les dialectes SQL sont nombreux et parfois source d'incompatibilit. La seule faon de permettre une communication plus large est d'adopter un langage SQL standardis de communication. Une couche fonctionnelle du client traduit les requtes du dialecte SQL client en SQL normalis. La requte transforme est envoye au serveur. Celui-ci traduit la requte dans le dialecte SQL-serveur et l'excute. Le rsultat de la requte suit le chemin inverse. Le langage de communication normalis le plus frquent est l'ODBC (Open DataBase Connectivity) de Microsoft. Signalons galement IDAPI (Integrated Database Application Programming Interface) de Borland. De plus, ces programmes permettent d'interroger des bases de donnes autres que relationnelles. Les serveurs de transactions

Une transaction correspond une procdure SQL, i.e. un groupe d'instructions SQL. Il y a un seul change requte/rponse pour la transaction. Le succs ou l'chec concerne l'ensemble des instructions SQL. Ces serveurs sont essentiellement utiliss pour l'informatique de production (ou oprationnelle) pour laquelle la rapidit des temps de rponse est importante sinon essentielle. III. Catgories d'instructions Les instructions SQL sont regroupes en catgories en fonction de leur utilit et des entits manipules. Nous pouvons distinguer cinq catgories, qui permettent : 1. la dfinition des lments d'une base de donnes (tables, colonnes, clefs, index, contraintes, ...), 2. la manipulation des donnes (insertion, suppression, modification, extraction, ...), 3. la gestion des droits d'accs aux donnes (acquisition et rvocation des droits), 4. la gestion des transactions, 5. et enfin le SQL intgr. Langage de dfinition de donnes Le langage de dfinition de donnes (LDD, ou Data Definition Language, soit DDL en anglais) est un langage orient au niveau de la structure de la base de donnes. Le LDD permet de crer, modifier, supprimer des objets. Il permet galement de dfinir le domaine des donnes (nombre, chane de caractres, date, boolen, ...) et d'ajouter des contraintes de valeur sur les donnes. Il permet enfin d'autoriser ou d'interdire l'accs aux donnes et d'activer ou de dsactiver l'audit pour un utilisateur donn.
SQL DML M. TAIS TDI

Les instructions du LDD sont : CREATE, ALTER, DROP, AUDIT, NOAUDIT, ANALYZE, RENAME, TRUNCATE. Langage de manipulation de donnes Le langage de manipulation de donnes (LMD, ou Data Manipulation Language, soit DML en anglais) est l'ensemble des commandes concernant la manipulation des donnes dans une base de donnes. Le LMD permet l'ajout, la suppression et la modification de lignes, la visualisation du contenu des tables et leur verrouillage. Les instructions du LMD sont : INSERT, UPDATE, DELETE, SELECT, EXPLAIN, PLAN, LOCK TABLE. Ces lments doivent tre valids par une transaction pour qu'ils soient pris en compte. Langage de protections d'accs : Le langage de protections d'accs (ou Data Control Language, soit DCL en anglais) s'occupe de grer les droits d'accs aux tables. Les instructions du DCL sont : GRANT, REVOKE. Langage de contrle de transaction : Le langage de contrle de transaction (ou Transaction Control Language, soit TCL en anglais) gre les modifications faites par le LMD, c'est--dire les caractristiques des transactions et la validation et l'annulation des modifications. Les instructions du TCL sont : COMMIT, SAVEPOINT, ROLLBACK, SET TRANSACTION SQL intgr : Le SQL intgr (Embedded SQL) permet d'utiliser SQL dans un langage de troisime gnration (C, VB, Java, Cobol, etc.) :

dclaration d'objets ou d'instructions ; excution d'instructions ; gestion des variables et des curseurs ; traitement des erreurs.

Les instructions du SQL intgr sont : DECLARE, TYPE, DESCRIBE, VAR, CONNECT, PREPARE, EXECUTE, OPEN, FETCH, CLOSE, WHENEVER.

SQL DML -

M. TAIS

TDI

IV. Interroger une base Langage de manipulation de donnes (LMD) : SELECT (1 re partie) Traduction des oprateurs de projection, slection, produit cartsien de l'algbre relationnelle (1 re partie) Traduction de l'oprateur de projection : L'oprateur de projection (A1, An)(relation) se traduit tout simplement en SQL par la requte : SELECT DISTINCT A_1, ..., A_n FROM relation DISTINCT permet de ne retenir qu'une occurrence de n-uplet dans le cas o une requte produit plusieurs n-uplets identiques Traduction de l'oprateur de slection : SELECT * FROM relation WHERE prdicat De manire simplifie, un prdicat est une expression logique sur des comparaisons. Reportez-vous la section pour une description plus complte. Traduction de l'oprateur de produit cartsien : SELECT * FROM relation_1, relation_2 Nous reviendrons sur le produit cartsien dans les sections Syntaxe gnrale de la commande SELECT Voici la syntaxe gnrale d'une commande SELECT : SELECT [ ALL | DISTINCT ] { * | expression [ AS nom_affich ] } [, ...] FROM nom_table [ [ AS ] alias ] [, ...] [ WHERE prdicat ] [ GROUP BY expression [, ...] ] [ HAVING condition [, ...] ] [ {UNION | INTERSECT | EXCEPT [ALL]} requte ] [ ORDER BY expression [ ASC | DESC ] [, ...] ] En fait l'ordre SQL SELECT est compos de 7 clauses dont 5 sont optionnelles : SELECT : Cette clause permet de spcifier les attributs que l'on dsire voir apparatre dans le rsultat de la requte FROM : Cette clause spcifie les tables sur lesquelles porte la requte WHERE : Cette clause permet de filtrer les n-uplets en imposant une condition remplir pour qu'ils soient prsents dans le rsultat de la requte GROUP BY : Cette clause permet de dfinir des groupes (i.e. sous-ensemble ) HAVING : Cette clause permet de spcifier un filtre (condition de regroupement des nuplets) portant sur les rsultats UNION, INTERSECT et EXCEPT : Cette clause permet d'effectuer des oprations ensemblistes entre plusieurs rsultats de requte (i.e. entre plusieurs SELECT)
SQL DML M. TAIS TDI

ORDER BY : Cette clause permet de trier les n-uplets du rsultat La clause SELECT : Pour illustrer par des exemples les sections qui suivent, nous utiliserons une table dont le schma est le suivant : Employee (id_employee, surname, name, salary) Cette table contient respectivement l'identifiant, le nom, le prnom et le salaire mensuel des employs d'une compagnie. L'oprateur toile (*) Le caractre toile (*) permet de rcuprer automatiquement tous les attributs de la table gnre par la clause FROM de la requte. Pour afficher la table employee on peut utiliser la requte : SELECT * FROM employee Les oprateurs DISTINCT et ALL Lorsque le SGBD construit la rponse d'une requte, il rapatrie toutes les lignes qui satisfont la requte, gnralement dans l'ordre ou il les trouve, mme si ces dernires sont en double (comportement ALL par dfaut). C'est pourquoi il est souvent ncessaire d'utiliser le mot clef DISTINCT qui permet d'liminer les doublons dans la rponse. Par exemple, pour afficher la liste des prnoms, sans doublon, des employs de la compagnie, il faut utiliser la requte : SELECT DISTINCT name FROM employee Les oprations mathmatiques de base Il est possible d'utiliser les oprateurs mathmatiques de base (i.e. +, -, * et /) pour gnrer de nouvelles colonnes partir, en gnrale, d'une ou plusieurs colonnes existantes. Pour afficher le nom, le prnom et le salaire annuel des employs, on peut utiliser la requte : SELECT surname, name, salary*12 FROM employee L'oprateur AS Le mot clef AS permet de renommer une colonne, ou de nommer une colonne cre dans la requte. Pour afficher le nom, le prnom et le salaire annuel des employs, on peut utiliser la requte : SELECT surname AS nom, name AS prnom, salary*12 AS salaire FROM employee L'oprateur de concatnation
SQL DML M. TAIS TDI

L'oprateur || (double barre verticale) permet de concatner des champs de type caractres. Pour afficher le nom et le prnom sur une colonne, puis le salaire annuel des employs, on peut utiliser la requte : SELECT surname || ' ' || name AS nom, salary*12 AS salaire FROM employee Dlimiteurs : apostrophes simples et doubles Pour spcifier littralement une chane de caractres, il faut l'entourer d'apostrophes (i.e. guillemets simples). Par exemple, pour slectionner les films policiers, on utilise la requte : SELECT * FROM film WHERE genre='Policier' Les date doivent galement tre entoure d'apostrophes (ex : '01/01/2005'). Comme l'apostrophe est utilise pour dlimiter les chanes de caractres, pour la reprsenter dans une chane, il faut la ddoubler (exemple : 'larbre'), ou la faire prcder d'un antislash (exemple : 'l\'arbre'). Lorsque le nom d'un lment d'une base de donnes (un nom de table ou de colonne par exemple) est identique un mot clef du SQL, il convient de l'entourer d'apostrophes doubles. Par exemple, si la table achat possde un attribut date, on pourra crire : SELECT ''date'' FROM achat Bien entendu, les mots rservs du SQL sont dconseills pour nommer de tels objets. Les apostrophes doubles sont galement ncessaires lorsque le nom (d'une colonne ou d'une table) est compos de caractres particuliers tels que les blancs ou autres, ce qui est videmment dconseill. La clause ORDER BY Comme nous l'avons dj dit, la clause ORDER BY permet de trier les n-uplets du rsultat et sa syntaxe est la suivante : ORDER BY expression [ ASC | DESC ] [, ...] expression dsigne soit une colonne, soit une opration mathmatique de base (nous avons abord ce type d'oprations dans la section sur La clause SELECT ) sur les colonnes. ASC spcifie l'ordre ascendant et DESC l'ordre descendant du tri. En l'absence de prcision ASC ou DESC, c'est l'ordre ascendant qui est utilis par dfaut. Quand plusieurs expressions, ou colonnes sont mentionnes, le tri se fait d'abord selon les premires, puis suivant les suivantes pour les n-uplet qui sont gaux selon les premires. Le tri est un tri interne sur le rsultat final de la requte, il ne faut donc placer dans cette clause que les noms des colonnes mentionns dans la clause SELECT. La clause ORDER BY permet de trier le rsultat final de la requte, elle est donc la dernire clause de tout ordre SQL et ne doit figurer qu'une seule fois dans le SELECT, mme s'il existe des requtes imbriques ou un jeu de requtes ensemblistes
SQL DML M. TAIS TDI

En l'absence de clause ORDER BY, l'ordre des n-uplet est alatoire et non garanti. Souvent, le fait de placer le mot clef DISTINCT suffit tablir un tri puisque le SGBD doit se livrer une comparaison des lignes, mais ce mcanisme n'est pas garanti car ce tri s'effectue dans un ordre non contrlable qui peut varier d'un serveur l'autre. La clause WHERE Comportement Comme nous l'avons dj dit, la clause WHERE permet de filtrer les n-uplets en imposant une condition remplir pour qu'ils soient prsents dans le rsultat de la requte ; sa syntaxe est la suivante : WHERE prdicat Concrtement, aprs que la table intermdiaire (i.e. virtuelle) de la clause FROM a t construite, chaque ligne de la table est confronte au prdicat afin de vrifier si la ligne satisfait (i.e. le prdicat est vrai pour cette ligne) ou ne satisfait pas (i.e. le prdicat est faux ou NULL pour cette ligne) le prdicat. Les lignes qui ne satisfont pas le prdicat sont supprimes de la table intermdiaire. Le prdicat n'est rien d'autre qu'une expression logique. En principe, celle-ci fait intervenir une ou plusieurs lignes de la table gnre par la clause FROM, cela n'est pas impratif mais, dans le cas contraire, l'utilit de la clause WHERE serait nulle. Expression simple Une expression simple peut tre une variable dsigne par un nom de colonne ou une constante. Si la variable dsigne un nom de colonne, la valeur de la variable sera la valeur situe dans la table l'intersection de la colonne et de la ligne dont le SGBD cherche vrifier si elle satisfait le prdicat de la clause WHERE. Les expressions simples peuvent tre de trois types : numrique, chane de caractres ou date. Une expression simple peut galement tre le rsultat d'une sous-requte, spcifie entre parenthses, qui retourne une table ne contenant qu'une seule ligne et qu'une seule colonne (i.e. une sous-requte retournant une valeur unique). Prdicat simple Un prdicat simple peut tre le rsultat de la comparaison de deux expressions simples au moyen de l'un des oprateurs suivants : = gal != diffrent < strictement infrieur <= infrieur ou gal > strictement suprieur >= suprieur ou gal
SQL DML M. TAIS TDI

Dans ce cas, les trois types d'expressions (numrique, chane de caractres et date) peuvent tre compars. Pour les types date, la relation d'ordre est l'ordre chronologique. Pour les caractres, la relation d'ordre est l'ordre lexicographique. LIKE : LIKE est un autre mot-cl utilis dans la clause WHERE. LIKE permet deffectuer une recherche base plutt sur un modle quune spcification exacte de ce qui est souhait (comme dans IN) ou une dfinition dun intervalle (comme dans BETWEEN). La syntaxe est comme suit : SELECT "nom de colonne" FROM "nom de table" WHERE "nom de colonne" LIKE {modle} {modle} reprsente souvent des caractres de remplacement. Voici quelques exemples : 'A_Z' : toutes les chanes commenant par 'A', ou un autre caractre, et terminant par 'Z'. Par exemple, 'ABZ' et 'A2Z' satisferaient la condition, alors 'AKKZ' ne le ferait pas (car il y a deux caractres entre A et Z au lieu dun). 'ABC%' : toutes les chanes commenant par 'ABC'. Par exemple, 'ABCD' et 'ABCABC' satisferaient la condition. '%XYZ' : toutes les chanes terminant par 'XYZ'. Par exemple, 'WXYZ' et 'ZZXYZ' satisferaient la condition. '%AN%' : toutes les chanes contenant le modle 'AN' quelle que soit sa position. Par exemple, 'LOS ANGELES' et 'SAN FRANCISCO' satisferaient la condition. Supposons que nous avons la table suivante : Table Store_Information store_name LOS ANGELES SAN DIEGO SAN FRANCISCO BOSTON Sales 1500 250 300 700 Date 05-Jan-1999 07-Jan-1999 08-Jan-1999 08-Jan-1999

Pour rechercher tous les magasins dont le nom contient 'AN', il faut saisir : SELECT * FROM Store_Information WHERE store_name LIKE '%AN%'

SQL DML -

M. TAIS

TDI

10

Rsultat : store_name LOS ANGELES SAN DIEGO SAN FRANCISCO Sales 1500 250 300 Date 05-Jan-1999 07-Jan-1999 08-Jan-1999

Un prdicat simple peut enfin correspondre l'un des tests suivants : expr IS NULL test sur l'indtermination de expr expr IN (expr_1 [, ...]) comparaison de expr une liste de valeurs expr NOT IN (expr_1 [, ...]) test d'absence d'une liste de valeurs expr IN (requte) mme chose, mais la liste de valeurs est le rsultat d'une expr NOT IN (requte) sous-requte qui doit imprativement retourner une table ne contenant qu'une colonne EXIST (requte) vraie si la sous-requte retourne au moins un n-uplet expr operateur ANY (requte) comparaison expr oprateur n-uplet ; la sous-requte doit imprativement retourner une table ne contenant qu'une colonne ; IN est quivalent = ANY vraie si tous les n-uplets de la sous-requte vrifient la condition expr operateur ALL (requte) comparaison expr oprateur n-uplet ; la sous-requte doit imprativement retourner une table ne contenant qu'une colonne Dans ce tableau, expr dsigne une expression simple et requte une sous-requte. Prdicat compos Les prdicats simples peuvent tre combins au sein d'expression logiques en utilisant les oprateurs logiques AND (et logique), OR (ou logique) et NOT (ngation logique).

SQL : Sous-Interrogations (sous-requtes) SELECT imbriqus Les sous-interrogations, ou SELECT imbriqus, permettent de raliser des interrogations complexes qui ncessiteraient normalement plusieurs interrogations avec stockage des rsultats intermdiaires. Elles se caractrisent par une interrogation (clause SELECT) inclue dans la clause WHERE, la clause HAVING ou la clause SELECT d'une autre interrogation.

SQL DML -

M. TAIS

TDI

11

Exemple : soit la base suivante :

Dictionnaire des donnes simplifi Mnmonique Ancien Cdsexe Coeff Dtnaiss Grade Lbsexe Nomat Nomens Nometu Note Numat Numens Numetu Libell Anciennet dans le grade Code sexe Coefficient de la matire Date de naissance Grade de l'enseignant Libell du sexe Nom de la matire Nom de l'enseignant Nom de l'tudiant Note obtenue la matire N de la matire N de l'enseignant N de l'tudiant

- Dterminer le nom le sexe et l'ge de l'tudiant le plus g. SELECT Nometu, Cdsexe, (CURRENT_DATE-Dtnaiss)/365 AS Age FROM ETUDIANT WHERE (CURRENT_DATE-Dtnaiss)/365 = (SELECT MAX((CURRENT_DATE-Dtnaiss)/365) FROM ETUDIANT); Prdicats IN, ANY, ALL, EXISTS
SQL DML M. TAIS TDI

12

Une sous-interrogation peut retourner un sous ensemble de zro n valeurs. En fonction des conditions que l'on veut exprimer au niveau des valeurs renvoyes par la requte, on peut utiliser les prdicats IN, ANY, ALL ou EXISTS. Prdicat IN ANY ALL EXISTS Utilisation L'oprateur de comparaison est l'galit et l'opration logique entre les valeurs est OU. Permet de vrifier si au moins une valeur de la liste satisfait la condition. Permet de vrifier si la condition est ralise pour toutes les valeurs de la liste. Si la sous-interrogation renvoie un rsultat, la valeur retourne est Vrai sinon la valeur Faux est retourne.

- Afficher les notes de l'tudiant numro 1 qui sont gales aux notes de l'tudiant numro 2. SELECT Note FROM NOTES WHERE Numetu=1 AND Note IN (SELECT Note FROM NOTES WHERE Numetu=2); - Afficher les notes de l'tudiant numro 1 qui sont suprieures aux notes de l'tudiant numro 2. SELECT Note FROM NOTES WHERE Numetu=1 AND Note > ANY (SELECT Note FROM NOTES WHERE Numetu=2); - Afficher les notes de l'tudiant numro 1 qui sont infrieures toutes les notes de l'tudiant numro 9. SELECT Note FROM NOTES WHERE Numetu=1 AND Note < ALL (SELECT Note FROM NOTES WHERE Numetu=9); - Afficher toutes les informations sur les tudiants qui n'ont aucune note. SELECT * FROM ETUDIANT E WHERE NOT EXISTS (SELECT Numetu FROM NOTES WHERE Numetu=E.Numetu); (voire autres exemples dans les pages suivantes : division, insert, delete, update)
SQL DML M. TAIS TDI

13

V. Interroger une base Langage de manipulation de donnes (LMD) : SELECT (2 me partie) 1 La clause FROM (2 me partie) : les jointures Recommandation Dans la mesure du possible, et contrairement ce que nous avons fait jusqu' prsent, il est prfrable d'utiliser un oprateur de jointure normalis SQL2 (mot-clef JOIN) pour effectuer une jointure. En effet, les jointures faites dans la clause WHERE (ancienne syntaxe datant de 1986) ne permettent pas de faire la distinction, de prime abord, entre ce qui relve de la slection et ce qui relve de la jointure puisque tout est regroup dans une seule clause (la clause WHERE). La lisibilit des requtes est plus grande en utilisant la syntaxe de l'oprateur JOIN qui permet d'isoler les conditions de slections (clause WHERE) de celles de jointures (clauses JOIN), et qui permet galement de cloisonner les conditions de jointures entre chaque couples de table. De plus, l'optimisation d'excution de la requte est souvent plus pointue lorsque l'on utilise l'oprateur JOIN. Enfin, lorsque l'on utilise l'ancienne syntaxe, la suppression de la clause WHERE des fins de tests pose videmment des problmes. Il existe plusieurs types de jointures: Cross Jointure (= produit cartsien) Jointure Interne (= Inner Join, Equi-join, Natural Join) Jointure Externe (= Outer Join) Auto Jointure (= Self Join) Semi-jointure Le produit cartsien Nous avons vu que la jointure n'est rien d'autre qu'un produit cartsien suivi d'une slection : Nous avons vu que le produit cartsien entre deux tables table_1 et table_2 peut s'crire en SQL : SELECT * FROM table_1, table_2 Il peut galement s'crire en utilisant le mot-cl JOIN ddi aux jointures de la manire suivante : SELECT * FROM table_1 CROSS JOIN table_2 Traduction de l'oprateur d'qui-jointure SELECT * FROM relation_1, relation_2 WHERE relation_1.A_1 = relation_2.A_2 Ex : Select Client.mat, nom, ville, codefacture, datefacture
SQL DML M. TAIS TDI

14

From client, facture

where client.mat=facture.matcli

Syntaxe gnrale des jointures Sans compter l'oprateur CROSS JOIN, voici les trois syntaxes possibles de l'expression d'une jointure dans la clause FROM en SQL : table_1 { [INNER] { LEFT | RIGHT | FULL } [OUTER] } JOIN table_2 ON predicat [...] table_1 { [INNER] { LEFT | RIGHT | FULL } [OUTER] } JOIN table_2 USING (colonnes) [...] table_1 NATURAL { [INNER] { LEFT | RIGHT | FULL } [OUTER] } JOIN table_2 [...] Ces trois syntaxes diffrent par la condition de jointure spcifie par les clause ON ou USING, ou implicite dans le cas d'une jointure naturelle introduite par le mot-cl NATURAL. ON : La clause ON correspond la condition de jointure la plus gnrale. Le prdicat predicat est une expression logique de la mme nature que celle de la clause WHERE dcrite dans la section USING : La clause USING est une notation abrge correspondant un cas particulier de la clause ON. Les deux tables, sur lesquelles portent la jointure, doivent possder toutes les colonnes qui sont mentionnes, en les sparant par des virgules, dans la liste spcifie entre parenthses juste aprs le mot-cl USING. La condition de jointure sera l'galit des colonnes au sein de chacune des paires de colonnes. De plus, les paires de colonnes seront fusionnes en une colonne unique dans la table rsultat de la jointure. Par rapport une jointure classique, la table rsultat comportera autant de colonnes de moins que de colonnes spcifies dans la liste de la clause USING. NATURAL : Il s'agit d'une notation abrge de la clause USING dans laquelle la liste de colonnes est implicite et correspond la liste des colonnes communes aux deux tables participant la jointure. Tout comme dans le cas de la clause USING, les colonnes communes n'apparaissent qu'une fois dans la table rsultat. INNER et OUTER : Les mots-cl INNER et OUTER permettent de prciser s'il s'agit d'une jointure interne ou externe. INNER et OUTER sont toujours optionnels. En effet, le comportement par dfaut est celui de la jointure interne (INNER) et les mots clefs LEFT, RIGHT et FULL impliquent forcment une jointure externe (OUTER). INNER JOIN : La table rsultat est constitue de toutes les juxtapositions possibles d'une ligne de la table table_1 avec une ligne de la table table_2 qui satisfont la condition de jointure. LEFT OUTER JOIN :
SQL DML M. TAIS TDI

15

Dans un premier temps, une jointure interne (i.e. de type INNER JOIN) est effectue. Ensuite, chacune des lignes de la table table_1 qui ne satisfait pas la condition de jointure avec aucune des lignes de la table table_2 (i.e. les lignes de table_1 qui n'apparaissent pas dans la table rsultat de la jointure interne) est ajoute la table rsultats. Les attributs correspondant la table table_2, pour cette ligne, sont affects de la valeur NULL. Ainsi, la table rsultat contient au moins autant de lignes que la table table_1. RIGHT OUTER JOIN : Mme scnario que pour l'opration de jointure de type LEFT OUTER JOIN, mais en inversant les rles des tables table_1 et table_2. FULL OUTER JOIN : La jointure externe bilatrale est la combinaison des deux oprations prcdentes (LEFT OUTER JOIN et RIGHT OUTER JOIN) afin que la table rsultat contienne au moins une occurrence de chacune des lignes des deux tables impliques dans l'opration de jointure. La jointure externe droite peut tre obtenue par une jointure externe gauche dans laquelle on inverse l'ordre des tables (et vice-versa). La jointure externe bilatrale peut tre obtenue par la combinaison de deux jointures externes unilatrales avec l'oprateur ensembliste UNION que nous verrons dans la section Des jointures de n'importe quel type peuvent tre chanes les unes derrires les autres. Les jointures peuvent galement tre imbriques tant donn que les tables table_1 et table_2 peuvent trs bien tre elles-mmes le rsultat de jointures de n'importe quel type. Les oprations de jointures peuvent tre parenthses afin de prciser l'ordre dans lequel elles sont effectues. En l'absence de parenthses, les jointures s'effectuent de gauche droite. Dfinition de deux tables pour les exemples qui suivent Afin d'illustrer les oprations de jointure, considrons les tables realisateur et film dfinies de la manire suivante : create table realisateur ( id_real integer primary key, nom varchar(16), prenom varchar(16) ); create table film ( num_film integer primary key, id_real integer, titre varchar(32) ); On notera que dans la table film, l'attribut id_real correspond une clef trangre et aurait d tre dfini de la manire suivante : id_real integer references realisateur. Nous ne l'avons pas fait dans le but d'introduire des films dont le ralisateur n'existe pas dans la table realisateur afin d'illustrer les diffrentes facettes des oprations de jointure.
SQL DML M. TAIS TDI

16

La table realisateur contient les lignes suivantes : id_real | nom | prenom ---------+-----------+--------1 | von Trier | Lars 4 | Tarantino | Quentin 3 | Eastwood | Clint 2 | Parker | Alan La table film contient les lignes suivantes : id_film | id_real | titre ---------+---------+---------------------------1| 1 | Dogville 2| 1 | Breaking the waves 3| 5 | Faux-Semblants 4| 5 | Crash 5| 3 | Chasseur blanc, coeur noir Exemples de jointures internes La jointure naturelle entre les tables film et ralisateur peut s'crire indiffremment de l'une des manires suivante : SELECT * FROM film NATURAL JOIN realisateur SELECT * FROM film NATURAL INNER JOIN realisateur; SELECT * FROM film JOIN realisateur USING (id_real); SELECT * FROM film INNER JOIN realisateur USING (id_real); pour produire le rsultat suivant : id_real | id_film | titre | nom | prenom ---------+---------+----------------------------+-----------+-------1| 1 | Dogville | von Trier | Lars 1| 2 | Breaking the waves | von Trier | Lars 3| 5 | Chasseur blanc, coeur noir | Eastwood | Clint Nous aurions galement pu effectuer une qui-jointure en crivant : SELECT * FROM film, realisateur WHERE film.id_real = realisateur.id_real; SELECT * FROM film JOIN realisateur ON film.id_real = realisateur.id_real; SELECT * FROM film INNER JOIN realisateur ON film.id_real = realisateur.id_real; Mais la colonne id_real aurait t duplique : id_film | id_real | titre | id_real | nom | prenom ---------+---------+----------------------------+---------+-----------+-------1| 1 | Dogville | 1 | von Trier | Lars 2| 1 | Breaking the waves | 1| von Trier | Lars 5| 3 | Chasseur blanc, coeur noir | 3| Eastwood | Clint
SQL DML M. TAIS TDI

17

Exemples de jointures externes gauches La jointure externe gauche entre les tables film et ralisateur permet de conserver, dans la table rsultat, une trace des films dont le ralisateur n'apparat pas dans la table realisateur. Une telle jointure peut s'crire indiffremment comme suit : SELECT * FROM film NATURAL LEFT JOIN realisateur; SELECT * FROM film NATURAL LEFT OUTER JOIN realisateur; SELECT * FROM film LEFT JOIN realisateur USING (id_real); SELECT * FROM film LEFT OUTER JOIN realisateur USING (id_real); Elle produit le rsultat suivant : id_real | id_film | titre | nom | prenom ---------+---------+----------------------------+-----------+-------1| 1 | Dogville | von Trier | Lars 1| 2 | Breaking the waves | von Trier | Lars 5| 3 | Faux-Semblants | | 5| 4 | Crash | | 3| 5 | Chasseur blanc, coeur noir | Eastwood | Clint Naturellement, en crivant : SELECT * FROM film LEFT JOIN realisateur ON film.id_real = realisateur.id_real; SELECT * FROM film LEFT OUTER JOIN realisateur ON film.id_real = realisateur.id_real; la colonne id_real serait duplique : id_film | id_real | titre | id_real | nom | prenom ---------+---------+----------------------------+---------+-----------+-------1| 1 | Dogville | 1 | von Trier | Lars 2| 1 | Breaking the waves | 1 | von Trier | Lars 3| 5 | Faux-Semblants | | | 4| 5 | Crash | | | 5| 3 | Chasseur blanc, coeur noir | 3 | Eastwood | Clint Exemples de jointures externes droites La jointure externe droite entre les tables film et ralisateur permet de conserver, dans la table rsultat, une trace des ralisateurs dont aucun film n'apparat dans la table film. Une telle jointure peut s'crire indiffremment comme suit : SELECT * FROM film NATURAL RIGHT JOIN realisateur; SELECT * FROM film NATURAL RIGHT OUTER JOIN realisateur; SELECT * FROM film RIGHT JOIN realisateur USING (id_real); SELECT * FROM film RIGHT OUTER JOIN realisateur USING (id_real); Elle produit le rsultat suivant : id_real | id_film | titre | nom ---------+---------+----------------------------+-----------+--------SQL DML M. TAIS TDI

| prenom
18

1| 1| 2| 3| 4|

1 2 5

| Dogville | von Trier | Lars | Breaking the waves | von Trier | Lars | | Parker | Alan | Chasseur blanc, coeur noir | Eastwood | Clint | | Tarantino | Quentin

Exemples de jointures externes bilatrales La jointure externe bilatrale entre les tables film et ralisateur permet de conserver, dans la table rsultat, une trace de tous les ralisateurs et de tous les films. Une telle jointure peut indiffremment s'crire : SELECT * FROM film NATURAL FULL JOIN realisateur; SELECT * FROM film NATURAL FULL OUTER JOIN realisateur; SELECT * FROM film FULL JOIN realisateur USING (id_real); SELECT * FROM film FULL OUTER JOIN realisateur USING (id_real); Elle produit le rsultat suivant : id_real | id_film | titre | nom | prenom ---------+---------+---------------------------+----------+--------1| 1 | Dogville | von Trier | Lars 1| 2 | Breaking the waves | von Trier | Lars 2| | | Parker | Alan 3| 5 | Chasseur blanc, coeur noir | Eastwood | Clint 4| | | Tarantino | Quentin 5| 3 | Faux-Semblants | | 5| 4 | Crash | | Auto-jointure (self join) C'est la jointure d'une table avec elle-mme. Cette opration est utile lorsque l'on souhaite relier des attributs qui se trouvent l'intrieur d'une mme table. Exemple1 : Soit la table des employs Emp (matr, nome, poste, #Matchef) comm : cest montant de la commission Matchef: mat du chef de lemploy sal : salaire Matr 1 2 3
SQL DML -

Nom Alaoui Ismaili Hafidi

prnom Ali Said Kamal

Poste Directeur Magasinier Comptable

Matchef null 1 1
19

Requte qui retourne le chef de chaque employ ?. SELECT E1. Nom AS Employ, E2. Nom AS Chef FROM Emp AS E1 INNER JOIN Emp AS E2 ON E1. Matchef = E2. Matr Employ Ismaili Hafidi Ex2: Notes(#Numetu, #Numat , Note) - Afficher le numro des tudiants qui ont une note dans la matire numro 1 infrieure la note qu'ils ont obtenue dans la matire numro 2. SELECT N1.Numetu FROM NOTES N1, NOTES N2 WHERE N1.Numetu=N2.Numetu AND N1.Numat=1 AND N2.Numat=2 AND N1.Note<N2.Note; Semi jointure gauche: (entre tables : DEPT and EMP) Liste des dpartements qui ont au moins un employ. Table : dept(deptno, dname) Et emp (empno, empname, #deptno) SELECT D.deptno, D.dname FROM dept D WHERE EXISTS ( SELECT 1 FROM emp E WHERE E.deptno = D.deptno ) ORDER BY D.deptno; Anti jointure: Une anti-join entre deux tables retourne des lignes de la 1 table qui nont pas de correspondent dans la 2 table. Cest le contraire de la semi-join. ; SELECT D.deptno, D.dname FROM dept D WHERE NOT EXISTS ( SELECT * FROM emp E
SQL DML M. TAIS TDI

Chef Alaoui Alaoui

20

WHERE E.deptno = D.deptno ) ORDER BY D.deptno

.2 Les clauses GROUP BY et HAVING et les fonctions d'agrgation Syntaxe La syntaxe d'une requte faisant ventuellement intervenir des fonctions d'agrgation, une clause GROUP BY et une clause HAVING est la suivante : SELECT expression_1, [...,] expression_N [, fonction_agrgation [, ...] ] FROM nom_table [ [ AS ] alias ] [, ...] [ WHERE prdicat ] [ GROUP BY expression_1, [...,] expression_N ] [ HAVING condition_regroupement ] La clause GROUP BY La commande GROUP BY permet de dfinir des regroupements (i.e. des agrgats) qui sont projets dans la table rsultat (un regroupement correspond une ligne) et d'effectuer des calculs statistiques, dfinis par les expressions fonction_agrgation [, ...], pour chacun des regroupements. La liste d'expressions expression_1, [...,] expression_N correspond gnralement une liste de colonnes colonne_1, [...,] colonne_N. La liste de colonnes spcifie derrire la commande SELECT doit tre identique la liste de colonnes de regroupement spcifie derrire la commande GROUP BY. A la place des noms de colonne il est possible de spcifier des oprations mathmatiques de base sur les colonnes (comme dfinies dans la section Dans ce cas, les regroupements doivent porter sur les mmes expressions. Si les regroupements sont effectus selon une expression unique, les groupes sont dfinis par les ensembles de lignes pour lesquelles cette expression prend la mme valeur. Si plusieurs expressions sont spcifies (expression_1, expression_2, ...) les groupes sont dfinis de la faon suivante : parmi toutes les lignes pour lesquelles expression_1 prend la mme valeur, on regroupe celles ayant expression_2 identique, etc. Un SELECT avec une clause GROUP BY produit une table rsultat comportant une ligne pour chaque groupe. Les fonctions d'agrgation AVG( [ DISTINCT | ALL ] expression ) : Calcule la moyenne des valeurs de l'expression expression. COUNT( * | [DISTINCT | ALL] expression ) : Dnombre le nombre de lignes du rsultat de la requte. Si expression est prsent, on ne compte que les lignes pour lesquelles cette expression n'est pas NULL.
SQL DML M. TAIS TDI

21

MAX( [ DISTINCT | ALL ] expression ) : Retourne la plus petite des valeurs de l'expression expression. MIN([ DISTINCT | ALL ] expression ) : Retourne la plus grande des valeurs de l'expression expression. STDDEV([ DISTINCT | ALL ] expression) : Calcule l'cart-type des valeurs de l'expression expression. SUM([ DISTINCT | ALL ] expression) : Calcule la somme des valeurs de l'expression expression. VARIANCE([ DISTINCT | ALL ] expression) : Calcule la variance des valeurs de l'expression expression. DISTINCT indique la fonction de groupe de ne prendre en compte que des valeurs distinctes. ALL indique la fonction de groupe de prendre en compte toutes les valeurs, c'est la valeur par dfaut. Aucune des fonctions de groupe ne tient compte des valeurs NULL l'exception de COUNT(*). Ainsi, SUM(col) est la somme des valeurs non NULL de la colonne col. De mme AVG est la somme des valeurs non NULL divise par le nombre de valeurs non NULL. Il est tout fait possible d'utiliser des fonctions d'agrgation sans clause GROUP BY. Dans ce cas, la clause SELECT ne doit comporter que des fonctions d'agrgation et aucun nom de colonne. Le rsultat d'une telle requte ne contient qu'une ligne. Exemples Prenons la base de donnes dont le schma relationnel est :

film cinema individu jouer projection

(num_film, num_realisateur, titre, genre, annee) (num_cinema, nom, adresse) (num_individu, nom, prenom) (num_acteur, num_film, role) (num_cinema, num_film, jour)

Pour connatre le nombre de fois que chacun des films a t projet on utilise la requte : SELECT num_film, titre, COUNT(*) FROM film NATURAL JOIN projection GROUP BY num_film, titre; Si l'on veut galement connatre la date de la premire et de la dernire projection, on utilise : SELECT num_film, titre, COUNT(*), MIN(jour), MAX(jour) FROM film NATURAL JOIN projection GROUP BY num_film, titre;

SQL DML -

M. TAIS

TDI

22

Pour connatre le nombre total de films projets au cinma Le Fontenelle, ainsi que la date de la premire et de la dernire projection dans ce cinma, la requte ne contient pas de clause GROUP BY mais elle contient des fonctions d'agrgation : SELECT COUNT(*), MIN(jour), MAX(jour) FROM film NATURAL JOIN projection NATURAL JOIN cinema WHERE cinema.nom = 'Le Fontenelle'; La clause HAVING De la mme faon qu'il est possible de slectionner certaines lignes au moyen de la clause WHERE, il est possible, dans un SELECT comportant une fonction de groupe, de slectionner certains groupes par la clause HAVING. Celle-ci se place aprs la clause GROUP BY. Le prdicat dans la clause HAVING suit les mmes rgles de syntaxe qu'un prdicat figurant dans une clause WHERE. Cependant, il ne peut porter que sur des caractristiques du groupe : fonction d'agrgation ou expression figurant dans la clause GROUP BY. Une requte de groupe (i.e. comportant une clause GROUP BY) peut contenir la fois une clause WHERE et une clause HAVING. La clause WHERE sera d'abord applique pour slectionner les lignes, puis les groupes seront constitus partir des lignes slectionnes, les fonctions de groupe seront ensuite values et la clause HAVING sera enfin applique pour slectionner les groupes. Exemples Pour connatre le nombre de fois que chacun des films a t projet en ne s'intressant qu'aux films projets plus de 2 fois, on utilise la requte : SELECT num_film, titre, COUNT(*) FROM film NATURAL JOIN projection GROUP BY num_film, titre HAVING COUNT(*)>2; Si en plus, on ne s'intresse qu'aux films projets au cinma Le Fontenelle, il faut ajouter une clause WHERE : SELECT num_film, titre, COUNT(*) FROM film NATURAL JOIN projection NATURAL JOIN cinema WHERE cinema.nom = 'Le Fontenelle' GROUP BY num_film, titre HAVING COUNT(*)>2; VI. Traduction des oprateurs d'union, d'intersection, de diffrence et de division de l'algbre relationnelle (2 me partie) Syntaxe : requte_1 { UNION | INTERSECT | EXCEPT } [ALL] requte_2 [...] Pour que l'opration ensembliste soit possible, il faut que requte_1 et requte_2 aient le mme schma, c'est dire le mme nombre de colonnes respectivement du mme type. Les noms de colonnes (titres) sont ceux de la premire requte (requte_1).
SQL DML M. TAIS TDI

23

Contrairement la commande SELECT, le comportement par dfaut des oprateurs ensemblistes limine les doublons. Pour les conserver, il faut utiliser le mot-clef ALL. Attention, il s'agit bien d'oprateurs portant sur des tables gnres par des requtes. On ne peut pas faire directement l'union de deux tables de la base de donnes. Traduction de l'oprateur d'union : SELECT * FROM relation_1 UNION SELECT * FROM relation_2 Traduction de l'oprateur d'intersection : SELECT * FROM relation_1 INTERSECT SELECT * FROM relation_2 Traduction de l'oprateur de diffrence : SELECT * FROM relation_1 EXCEPT SELECT * FROM relation_2 Traduction de l'oprateur de division Il n'existe pas de commande SQL permettant de raliser directement une division. Prenons la requte : Quels sont les acteurs qui ont jou dans tous les films de Lars von Trier ? Cela peut se reformuler par : Quels sont les acteurs qui vrifient : quel que soit un film de Lars von Trier, l'acteur a jou dans ce film. Malheureusement, le quantificateur universel (quelque soit) n'existe pas en SQL. Par contre, le quantificateur existentiel existe : EXISTS. On peut donc reformuler le problme de la manire suivante : Quels sont les acteurs qui vrifient : il est faux qu'il existe un film de Lars von Trier dans lequel l'acteur n'a pas jou. Ce qui correspond la requte SQL : SELECT DISTINCT nom, prenom FROM individu AS acteur_tous_lars WHERE NOT EXISTS ( SELECT * FROM ( film JOIN individu ON num_realisateur = num_individu AND nom = 'von Trier' AND prenom = 'Lars' ) AS film_lars WHERE NOT EXISTS ( SELECT * FROM individu JOIN jouer ON num_individu = num_acteur AND num_individu = acteur_tous_lars.num_individu AND num_film = film_lars.num_film ) ); En prenant le problme d'un autre point de vue, on peut le reformuler de la manire suivante : Quels sont les acteurs qui vrifient : le nombre de films raliss par Lars von Trier dans lequel l'acteur jou est gal au nombre de films raliss par Lars von Trier. Ce qui peut se traduire en SQL indiffremment par l'une des deux requtes suivantes : SELECT acteur.nom, acteur.prenom FROM individu AS acteur JOIN jouer ON acteur.num_individu = jouer.num_acteur JOIN film ON jouer.num_film = film.num_film JOIN individu AS realisateur ON film.num_realisateur = realisateur.num_individu
SQL DML M. TAIS TDI

24

WHERE realisateur.nom = 'von Trier' AND realisateur.prenom = 'Lars' GROUP BY acteur.nom, acteur.prenom HAVING COUNT (DISTINCT film.num_film) = ( SELECT DISTINCT COUNT(*) FROM film JOIN individu ON num_realisateur = num_individu WHERE nom = 'von Trier' AND prenom = 'Lars' ); SELECT DISTINCT acteur_tous_lars.nom, acteur_tous_lars.prenom FROM individu AS acteur_tous_lars WHERE ( SELECT DISTINCT COUNT(*) FROM jouer JOIN film ON jouer.num_film = film.num_film JOIN individu ON num_realisateur = num_individu WHERE nom = 'von Trier' AND prenom = 'Lars' AND jouer.num_acteur = acteur_tous_lars.num_individu )=( SELECT DISTINCT COUNT(*) FROM film JOIN individu ON num_realisateur = num_individu WHERE nom = 'von Trier' AND prenom = 'Lars' ); Exemple2 : il est toujours possible de trouver une autre solution, notamment par l'intermdiaire des oprations de calcul et de regroupement. Dans l'exemple prsent, on souhaite trouver les athltes qui participent toutes les preuves. En algbre relationnelle une autre solution que la division pourrait tre : N=CALCULER(EPREUVE, Comptage()) R1=REGROUPER_ET_CALCULER(PARTICIPER, Athlte, Nb:Comptage()) R2=SELECTION(R1, Nb=N) R3=PROJECTION(R2, Athlte) et en SQL : SELECT Athlte FROM PARTICIPER GROUP BY Athlte HAVING COUNT(*) = (SELECT COUNT(*) FROM EPREUVE) ; On pourra trouver cette solution imparfaite par rapport aux solutions plus "propres" gnralement donnes pour la division, solutions souvent bases sur une double ngation et mettant en oeuvre plusieurs SELECT imbriqus et corrls (trs coteux en temps d'excution) comme dj vu dans le 1 exemple. Approfondissons les choses avec un autre jeu d'essai volontairement plus contraignant :
SQL DML M. TAIS TDI

25

PARTICIPER Athlte Dupont Dupont Dupont Dupont Martin Martin Martin Bertrand Bertrand Michel

Epreuve 200 m 400 m 110 m H 100 m 200 m 400 m 110 m H 200 m 400 m 200 m

EPREUVE Epreuve 200 m 400 m 110 m H 200 m

VII -Modifier une base Langage de manipulation de donnes (LMD) .1 Insertion de n-uplets : INSERT INTO La commande INSERT permet d'insrer une ligne dans une table en spcifiant les valeurs insrer. La syntaxe est la suivante : INSERT INTO nom_table(nom_col_1, nom_col_2, ...) VALUES (val_1, val_2, ...) La liste des noms de colonne est optionnelle. Si elle est omise, la liste des colonnes sera par dfaut la liste de l'ensemble des colonnes de la table dans l'ordre de la cration de la table. Si une liste de colonnes est spcifie, les colonnes ne figurant pas dans la liste auront la valeur NULL. Il est possible d'insrer dans une table des lignes provenant d'une autre table. La syntaxe est la suivante : INSERT INTO nom_table(nom_col1, nom_col2, ...) SELECT ... Le SELECT peut contenir n'importe quelle clause sauf un ORDER BY Soit table dpartement : Dept (numd, nomd, lieud) Et table : Emp (matr, nome, poste, sal, comm # numd) . comm : cest la commission que peut percevoir un employ. Participation( # matr, #numd) Exemples 1 (a) INSERT INTO dept VALUES (10, 'FINANCES', TAZA)
SQL DML M. TAIS TDI

26

(b) INSERT INTO dept (lieud, nomd, numd) VALUES ('GRENOBLE', 'RECHERCHE', 20) La forme qui suit, avec la clause SELECT, permet d'insrer dans une table des lignes provenant d'une table de la base. Le SELECT a la mme syntaxe qu'un SELECT normal. Exemple 2 Enregistrer la participation de MARTIN au groupe de projet numro 10 : INSERT INTO PARTICIPATION (MATR, numd) SELECT MATR, 10 FROM EMP WHERE NOME = 'MARTIN' .2 Modification de n-uplets : UPDATE La commande UPDATE permet de modifier les valeurs d'une ou plusieurs colonnes, dans une ou plusieurs lignes existantes d'une table. La syntaxe est la suivante : UPDATE nom_table SET nom_col_1 = {expression_1 | ( SELECT ...) }, nom_col_2 = {expression_2 | ( SELECT ...) }, ... nom_col_n = {expression_n | ( SELECT ...) } WHERE predicat Les valeurs des colonnes nom_col_1, nom_col_2, ..., nom_col_n sont modifies dans toutes les lignes qui satisfont le prdicat predicat. En l'absence d'une clause WHERE, toutes les lignes sont mises jour. Les expressions expression_1, expression_2, ..., expression_n peuvent faire rfrence aux anciennes valeurs de la ligne. Exemples 3 (a) Faire passer MARTIN dans le dpartement 10 : UPDATE EMP SET numd = 10 WHERE NOME = 'MARTIN' (b) Augmenter de 10 % les commerciaux : UPDATE EMP SET SAL = SAL * 1.1 WHERE POSTE = 'COMMERCIAL'

SQL DML -

M. TAIS

TDI

27

(c) Donner CLEMENT un salaire 10 % au dessus de la moyenne des salaires des secrtaires : UPDATE EMP SET SAL = (SELECT AVG(SAL) * 1.10 FROM EMP WHERE POSTE = 'SECRETAIRE') WHERE NOME = 'CLEMENT' On remarquera que la moyenne des salaires sera calcule pour les valeurs qu'avaient les salaires au dbut de l'excution de la commande UPDATE et que les modifications effectues sur la base pendant l'excution de cette commande ne seront pas prises en compte. (d) Enlever (plus exactement, mettre la valeur :NULL) la commission de MARTIN : UPDATE EMP SET COMM = NULL WHERE NOME = 'MARTIN' .3 Suppression de n-uplets : DELETE La commande DELETE permet de supprimer des lignes d'une table. La syntaxe est la suivante : DELETE FROM nom_table WHERE predicat Toutes les lignes pour lesquelles predicat est valu vrai sont supprimes. En l'absence de clause WHERE, toutes les lignes de la table sont supprimes. Exemple 4: DELETE FROM dept WHERE numd = 10

SQL DML -

M. TAIS

TDI

28