Différences

Ci-dessous, les différences entre deux révisions de la page.

--- nsi:terminales:sql_requests [2021/04/15 14:21] – créée goupillwiki
+++ nsi:terminales:sql_requests [2022/08/29 21:45] (Version actuelle) – goupillwiki
@@ Ligne 1: / Ligne 1: @@
-<markdown>
+====== Requêtes SQL ======
-# Requêtes SQL
 Structured Query Language : C'est un langage visant à exploiter des bases de données relationnelles.
-> EN 1970, Aurait dû s'appeler SEQUEL pour Strutuctured English QUEry Language, mais la marque SEQUEL existait déjà. SQL a donc été choisi en 1975.
+<WRAP info>EN 1970, Aurait dû s'appeler SEQUEL pour Strutuctured English QUEry Language, mais la marque SEQUEL existait déjà. SQL a donc été choisi en 1975.</WRAP>
-Ce langage est utilisé, à quelques variantes près, par tous les grands noms des SGBDR - *systèmes gestion BDD relationnelle* : Oracle, MySQL, MariaDB, Access, Microsoft SQL Server, PostgreSQL, SQLite, MongoDB
+Ce langage est utilisé, à quelques variantes près, par tous les grands noms des SGBDR -- //systèmes gestion BDD relationnelle// -- Oracle, MySQL, MariaDB, Access, Microsoft SQL Server, PostgreSQL, SQLite, MongoDB
-Ce langage est utilisé pour piloter une base de données depuis n'importe quel langage : Python, PHP...
+Il s'agit d'emettre des requêtes, c'est à dire des commandes, consistant à modifier une données, en insérer une, en effacer ou bien à lire le contenu de la base de données. En général, ces requêtes sont émises automatiquement depuis un programme écrit dans n'importe quel langage : Python, PHP...
-Dans le cadre de ce premier cours, nous allons utiliser un outil permettant d'envoyer directement des requêtes SQL et de visualiser la base comme dans Microsoft Access, sous forme de tables. Je propose l'utilisation de [SQLiteBrowser](https://sqlitebrowser.org/dl/).
+Dans le cadre de ce premier cours, nous allons utiliser un outil permettant d'envoyer manuellement des requêtes SQL et de visualiser la base comme dans Microsoft Access, sous forme de tables. Je propose l'utilisation de [[https://sqlitebrowser.org/dl/|SQLiteBrowser]].
-## Exemple
+===== Exemple =====
 Afin d'illustrer notre travail, on utilisera un exemple.
-![uml](sql-1.svg)
+{{ nsi:terminales:database:sql-1.png?direct&400 |}}
 Pour cette base, nous besoin de deux tables FILM et ARTISTE et aussi d'une table JOUEDANS pour la relation du haut :
-</markdown>
   * **ARTISTE :** __idArtiste__, nom, prénom, biographie, naissance
@@ Ligne 25: / Ligne 23: @@
   * **JOUEDANS :** __//idArtiste//__, __//idFilm//__, rôle
-<markdown>
 Les clés primaires sont soulignées et les clés étrangères sont en italique.
-> Nous allons utiliser des requêtes SQL pour ajouter des films, des acteurs... Evidemment, en situation réelle, on ne demandera pas à la personne chargée de rentrer les données, peut-être un simple internaute, d'écrire ces commandes complexes. Pour l'internaute ou l'utilisateur moyen, il faudra prévoir une interface, comme une page web avec des cases à remplir. Mais nous verrons cela plus tard, on commence avec les requêtes SQL brutes.
+<WRAP important>Nous allons utiliser des requêtes SQL pour ajouter des films, des acteurs... Évidemment, en situation réelle, on ne demandera pas à la personne chargée de rentrer les données, peut-être un simple internaute, d'écrire ces commandes complexes. Pour l'internaute ou l'utilisateur moyen, il faudra prévoir une interface, comme une page web avec des cases à remplir. Mais nous verrons cela plus tard, on commence avec les requêtes SQL brutes.</WRAP>
-## Créer les tables
+===== Créer les tables =====
 Pour créer une table on doit se poser ce genre de question :
-* quel est le nom de la table,
+  * quel est le nom de la table,
-* pour chaque attribut, quel est son domaine - *quel est le type de valeur autorisée*,
+  * pour chaque attribut, quel est son **domaine** -- //quel est le type de valeur autorisée//,
-* quel est la clé primaire (ou les clés primaires)
+  * quel est la clé primaire (ou les clés primaires)
-* y a t-il des clés étrangères.
+  * y a t-il des clés étrangères.
-> Dans ce qui suit, j'écrirais certaines commande en majuscules comme `CREATE`. Ce n'est pas obligé, cela fonctionne aussi en minuscules.
+<WRAP tip>Dans ce qui suit, j'écrirais certaines commande en majuscules comme ''CREATE''. Ce n'est pas obligé, cela fonctionne aussi en minuscules.
->
-> On revient à la ligne pour plus de lisibilité mais on pourrait tout écrire à la suite. Le `;` indique qu'une commande est complète.
-```sql
+On revient à la ligne pour plus de lisibilité mais on pourrait tout écrire à la suite. Le '';'' indique qu'une commande est complète.
+</WRAP>
+<code sql linenums>
 CREATE TABLE ARTISTE (
     idArtiste INTEGER PRIMARY KEY,
@@ Ligne 69: / Ligne 67: @@
     FOREIGN KEY(idFilm) REFERENCES FILM(idFilm)
 );
-```
+</code>
-> Dans sqlitebrowser, commencer par créer une bdd vide puis dans les onglets en haut à gauche, chercher "Exécuter le SQL". On peut entrer des requêtes SQL et les exécuter. Un message indique si la requête a abouti ou non.
+<WRAP box>Dans //sqlitebrowser//,
+  * commencer par créer une bdd vide,
+  * chercher "Éditer les pragmas" dans les onglets, cocher "Foreign keys" -- ainsi les clés étrangères seront prises en comtpe,
+  * chercher "Exécuter le SQL" dans les onglets puis exécuter les requêtes SQL précédentes. Un message indique si la requête a abouti ou non.
+</WRAP>
+==== Les domaines = types de données ====
 Vous pouvez voir différents types de données :
-* **INTEGER :** entier 4 octets. Il existe des types entiers prenant moins de place, des plus grands, des types pour les flottants...
+  * **INTEGER :** entier 4 octets. Il existe des types entiers prenant moins de place, des plus grands, des types pour les flottants...
-* **VARCHAR :** du texte. On précise la taille de la chaîne. VARCHAR(20) est une chaîne qui ne pourra pas dépasser 20 caractères. Se pose le problème de l'encoage. Unicode tend à s'imposer. Nous n'en parlerons pas ici.
+  * **VARCHAR :** du texte. On précise la taille de la chaîne. ''VARCHAR(20)'' est une chaîne qui ne pourra pas dépasser 20 caractères. Se pose le problème de l'encodage. Unicode tend à s'imposer. Nous n'en parlerons pas ici.
-* **TEXT :** du texte en taille illimitée.****
+  * **TEXT :** du texte en taille illimitée.
-* **DATE :** une date au format AAAA-MM-JJ. On utilise aussi souvent DATETIME au format AAAA-MM-JJ hh:mm:ss
+  * **DATE :** une date au format AAAA-MM-JJ. On utilise aussi souvent DATETIME au format AAAA-MM-JJ hh:mm:ss
+Vous remarquez également quelques ''NOT NULL'' destinés à empêcher qu'un champ reste vide. Si on avait toléré qu'un film n'ait pas de réalisateur, on n'aurait pas mis le ''NOT NULL''. En écrivant ''NOT NULL'' pour ''idReal'', on interdit l'absence de réalisateur.
-Vous remarquez également quelques `NOT NULL` destinés à empêcher qu'un champ reste vide. Si on avait toléré qu'un film n'ait pas de réalisateur, on aurait pas mis le `NOT NULL`. En écrivant `NOT NULL` pour `idReal`, on interdit l'absence de réalisateur.
+Enfin, vous pouvez voir l'écriture des contraintes de clés étrangères. Ici, un ''FILM'' doit avoir un ''idReal'', et ''FILM.idReal'' doit correspondre à un ''ARTISTE.idArtiste''.
-Enfin, vous pouvez voir l'écriture des contraintes de clés étrangères. Ici, un `FILM` doit avoir un `idReal`, et `FILM.idReal` doit correspondre à un `ARTISTE.idArtiste`.
+===== Insérer des données =====
-## Insérer des données
+==== Insertion d'un artiste ====
-```sql
+<code sql linenums>
 INSERT INTO ARTISTE(prénom, nom, biographie, naissance) VALUES('Bruce', 'Willis', 'Né sur une base américaine à Idar-Oberstein en Allemagne de l''Ouest où son père, un soldat américain, était affecté, Bruce Willis passe le reste de son enfance dans le New Jersey. Au Collège d''Etat de Montclair, il s''adonne à la musique, joue de l''harmonica et suit les cours de la section théâtrale.', '1955-03-19');
-```
+</code>
 Exemple d'une insertion d'un artiste, Bruce Willis. La syntaxe est assez explicite.
-> Dans sqlitebrowser, l'onglet "Parcourir les données" vous permet de voir que Bruce Willis a bien été ajouté dans la table ARTISTE.
+<WRAP tip>Dans sqlitebrowser, l'onglet "Parcourir les données" vous permet de voir que Bruce Willis a bien été ajouté dans la table ARTISTE.</WRAP>
-**Gestion des apostrophes :** Dans le texte de la biographie, vous pouvez voir la présence de caractères `'`, mais ces caractères servent à délimiter les chaînes de texte... La convention est de doubler les `'` pour qu'ils soient compris comme une simple apostrophe. C'est pourquoi vous pouvez voir des `''` ici et là dans la biographie.
+==== Gestion des apostrophes ====
-**Pas d'idArtiste :** `idArtiste` est la clé primaire, elle se crée toute seule, nous n'avons pas besoin de la préciser.
+Dans le texte de la biographie, vous pouvez voir la présence de caractères ''%%'%%'', mais ces caractères servent à délimiter les chaînes de texte... La convention est de doubler les ''%%'%%'' pour qu'ils soient compris comme une simple apostrophe. C'est pourquoi vous pouvez voir des ''%%''%%'' ici et là dans la biographie.
+<WRAP tip>
+==== Préciser ou non la clé primaire ? ====
+On a le choix : on peut décider de préciser un ''idArtiste''. Dans ce cas on pourra écrire
+<code sql>
+INSERT INTO ARTISTE(idArtiste, prénom, nom, biographie, naissance) VALUES(129, 'Jo', 'Bill', 'blablabla', '1955-03-19');
+</code>
+et on précise l'identifiant voulu **à condition qu'il ne soit pas déjà utilisé**.
+Puisque dans la requête précédente figurent toutes les colonnes de la table, on peut se contenter de :
+<code sql>
+INSERT INTO ARTISTE VALUES(129, 'Jo', 'Bill', 'blablabla', '1955-03-19');
+</code>
+Dans les sujets de bac, l'identifiant est précisé en général. Mais dans un cas d'utilisation réelle, il sera sans doute plus pratique de laisser le SGBD automatiquement identifiant : sans cela il faudrait d'abord consulter la BDD pour savoir quel identifiant est disponible...
+</WRAP>
+==== Erreur si insertion de film sans idReal ====
 Essayons maintenant une commande qui ne passe pas.
-```sql
+<code sql linenums>
 INSERT INTO FILM(titreVO, titreVF, année) VALUES('Die Hard', 'Piège de Cristal', 1988);
-```
+</code>
+Cette commande renverra une erreur car on n'a pas précisé ''idReal'', or on a dit lors de la définition que ''idReal'' est ''NOT NULL'', il faut une valeur.
-Cette commande renverra une erreur car on n'a pas précisé `idReal`, or on a préciser que `idReal` est `NOT NULL`, il faut une valeur.
+==== idReal est une clé étrangère ====
 Cette autre commande échoue.
-```sql
+<code sql linenums>
 INSERT INTO FILM(titreVO, titreVF, année, idReal) VALUES('Die Hard', 'Piège de Cristal', 1988, 45);
-```
+</code>
-Cette fois, on a bien précisé un `idReal` mais il n'y a pour l'instant aucun artiste avec un `idArtiste = 45`. C'est la **clé étrangère** qui fait échouer la commande.
+Cette fois, on a bien précisé un ''idReal'' mais il n'y a pour l'instant aucun artiste avec un ''idArtiste = 45''. C'est la **clé étrangère** qui fait échouer la commande.
 On comprend qu'il faudra d'abord insérer l'artiste réalisateur avant de pouvoir insérer le film.
-```sql
+<code sql linenums>
 INSERT INTO ARTISTE(prénom, nom, biographie, naissance) VALUES('John', 'McTiernan', 'Diplômé en théâtre de l''école de Juillard dans l''état de New York,...', '1952-01-08');
-```
+</code>
-Après l'insertion du réalisateur, on peut aller voir qu'il a bien été créé avec `idArtiste = 2`, et donc maintenant on peut exécuter :
+Après l'insertion du réalisateur, on peut aller voir qu'il a bien été créé avec ''idArtiste = 2'', et donc maintenant on peut exécuter :
-```sql
+<code sql linenums>
 INSERT INTO FILM(titreVO, titreVF, année, idReal) VALUES('Die Hard', 'Piège de Cristal', 1988, 2);
-```
+</code>
+==== insertion d'une association JOUEDANS ====
 Pour compléter, ajoutons une entrée JOUEDANS :
-```sql
+<code sql linenums>
 INSERT INTO JOUEDANS(idArtiste, idFilm, rôle) VALUES (1,1,'Mc Lain');
-```
+</code>
+===== Modification d'une donnée =====
-## Modification d'une donnée
 John McTiernan n'est pas né le 08/01/1952 mais le 08/01/1951. On souhaite donc modifier cette donnée.
-```sql
+<code sql linenums>
 UPDATE ARTISTE SET naissance = '1951-01-08' WHERE idArtiste = 2;
-```
+</code>
+Là encore la commande est assez explicite.
-Là encore la commande est assez explicite. Attention cependant au mot-clé `WHERE` qui permet de préciser quelle(s) ligne(s) de la table on souhaite modifier. On pourrait très bien modifier plusieurs lignes simultanément. Par exemple, on pourrait décider de mettre les noms des artistes en majuscules :
+<WRAP important>Attention cependant au mot-clé ''WHERE'' qui permet de préciser quelle(s) ligne(s) de la table on souhaite modifier. On pourrait très bien modifier plusieurs lignes simultanément. Par exemple, on pourrait décider de mettre les noms des artistes en majuscules :
-```sql
+<code sql linenums>
 UPDATE ARTISTE SET nom = UPPER(nom);
-```
+</code>
+En l'absence de clause ''WHERE'' **toutes les lignes** sont modifiées. Il faut donc faire attention.
+</WRAP>
-En l'absence de clause `WHERE` toutes les lignes sont modifiées. Il faut donc faire attention.
 Bien sûr, la commande suivante échoue :
-```sql
+<code sql linenums>
 UPDATE FILM SET idReal = 25 WHERE titreVO = 'Die Hard';
-```
+</code>
 à cause de la contrainte de clé étrangère : l'artiste 25 n'existe pas. En revanche, ceci fonctionne :
-```sql
+<code sql linenums>
 UPDATE FILM SET idReal = 1 WHERE titreVO = 'Die Hard';
-```
+</code>
-S'il y avait plusieurs films de même `titreVO`, ils seraient tous affectés.
+S'il y avait plusieurs films de même ''titreVO'', ils seraient tous affectés.
-*Remettez idReal à 2 pour la suite.*
+//Remettez idReal à 2 pour la suite.//
-## Suppression d'une donnée
+===== Suppression d'une donnée =====
-La commande est `DELETE`. Commençons par un cas qui ne fonctionne pas pour cause de clé étrangère :
+La commande est ''DELETE''. Commençons par un cas qui ne fonctionne pas pour cause de clé étrangère :
-```sql
+<code sql linenums>
 DELETE FROM ARTISTE WHERE prénom = 'Bruce';
-```
+</code>
 D'abord cette commande est un peu dangereuse car elle effacera tous les artistes de prénom Bruce, il pourrait y en avoir plusieurs.
-Ici, comme Bruce Willis est rattaché au film Die Hard, la suppresion de Bruce Willis est impossible.
+Ici, comme Bruce Willis est rattaché au film Die Hard, la suppression de Bruce Willis est impossible.
-En revanche, celle ci fonctionne - *remarquez au passage l'utilisation de AND* :
+En revanche, celle ci fonctionne -- //remarquez au passage l'utilisation de AND// :
-```sql
+<code sql linenums>
 DELETE FROM JOUEDANS WHERE idArtiste = 1 AND idFilm = 1;
-```
+</code>
-## Consulter la table
+===== Consulter la table =====
-Nous abons vu comment créer la base, créer des items, en supprimer, en modifier.
+Nous avons vu comment créer la base, créer des items, en supprimer, en modifier.
 Nous allons passer maintenant aux commandes permettant d'en explorer le contenu.
-Une base est construite par des milliers d'insertions individuelles. On ne va donc pas le faire et nous allons continuer à travailler avec une base déjà faite.
+<WRAP box>Une base est construite par des milliers d'insertions individuelles. On ne va donc pas le faire et nous allons continuer à travailler avec une base déjà faite.
-Vous disposez du fichier `films.sql` qui contient toutes les commandes pour créer une base de donnée. Dans sqlitebrowser vous pouvez importer un fichier `*.sql`.
+Vous disposez du fichier {{ nsi:terminales:database:films.sql |}} qui contient toutes les commandes pour créer une base de donnée. Dans //sqlitebrowser// vous pouvez importer un fichier ''*.sql''. <wrap tip>Fichier -> Importer -> Base de données à partir du fichier SQL...</wrap>
+</WRAP>
-### Sélection
+==== Sélection ====
-La commande `SELECT` permet d'extraire des données de la base. Au plus simple :
+=== cas le plus simple ===
-```sql
+La commande ''SELECT'' permet d'extraire des données de la base. Au plus simple :
+<code sql linenums>
 SELECT * FROM ARTISTE;
-```
+</code>
-`*` est un symbole couramment utilisé quand on veut dire TOUT. Donc ici on renvoie toutes les colonnes pour toute la table ARTISTE.
+''%%*%%'' est un symbole couramment utilisé quand on veut dire TOUT. Donc ici on renvoie toutes les colonnes pour toute la table ARTISTE.
-```sql
+=== projection ===
+<code sql linenums>
 SELECT nom, prénom FROM ARTISTE;
-```
+</code>
+Presque la même chose, sinon que l'on ne demande que la colonne ''nom'' et la colonne ''prénom''. On parle de **projection**.
-Presque la même chose, sinon que l'on ne demande que la colonne nom et la colonne prénom. On parle de **projection**.
+=== clause WHERE ===
-```sql
+<code sql linenums>
 SELECT nom, prénom FROM ARTISTE WHERE naissance > '1970-01-01';
-```
+</code>
 La clause WHERE permet de limiter le retour aux seuls artistes dont la naissance vient après le 01/01/1970.
-```sql
+=== clause LIKE ===
+<code sql linenums>
 SELECT nom, prénom FROM ARTISTE WHERE nom LIKE 'Bo%';
-```
+</code>
-LIKE signifie RESSEMBLE, ici on ne garde que les artistes dont le nom commence par 'Bo'.
+''LIKE'' signifie //RESSEMBLE//, ici on ne garde que les artistes dont le nom commence par "Bo".
-On peut éviter d'afficher des doublons. Ci-dessous la première commande fait apparaître des rôle identiques (*Belatrix Lestrange par exemple, même rôle dans 2 films différents*), la deuxième commande supprime les doublons.
+=== doublons, clause DISTINCT ===
-```sql
+On peut éviter d'afficher des doublons. Ci-dessous la première commande fait apparaître des rôle identiques -- //Belatrix Lestrange// par exemple, même rôle dans 2 films différents -- la deuxième commande supprime les doublons.
+<code sql linenums>
 SELECT rôle FROM JOUEDANS;
 SELECT DISTINCT rôle FROM JOUEDANS;
-```
+</code>
-Et on peut trier - *tri par naissance puis nom dans le premier cas, ordre descendant dans le second cas*.
+=== tri ===
-```sql
+Et on peut trier :
+  * tri par naissance puis nom dans le premier cas,
+  * ordre descendant dans le second cas -- mot clé ''DESC''.
+<code sql linenums>
 SELECT nom, prénom FROM ARTISTE ORDER BY naissance, nom;
 SELECT nom, prénom FROM ARTISTE ORDER BY naissance DESC;
-```
+</code>
+<wrap important>Dans le cas du requête avec ''WHERE'' et ''ORDER BY'', il faut placer ''ORDER BY'' après.</wrap>
+=== compte ===
+On peut compter les items. Par exemple la requête suivante renvoie une liste de noms avec éventuellement des doublons :
+<code sql>
+SELECT nom from ARTISTE;
+</code>
+Si nous n'étions intéressé que par le nombre de lignes de cette liste -- ce qui revient à compter le nombre d'artistes -- on peut utiliser le mot clef ''COUNT'' :
+<code sql>
+SELECT COUNT(nom) from ARTISTE;
+</code>
-### Jointure
+Cette requête est différente puisqu'elle ne renvoie pas une liste de valeurs, elle ne renvoie que le résultat du compte.
+<WRAP tip>On compte tous les noms apparaissant, même s'ils viennent en plusieurs exemplaires. La fonction ''COUNT'' ignorera les cas ''NULL'', c'est à dire les cases vides (en admettant que l'on ait autorisé qu'un artiste n'ait pas de nom renseigné).</WRAP>
+<WRAP info>Pour aller plus loin, on pourrait préciser que l'on ne veut pas compter plusieurs fois un même nom. On ajoute alors le mot-clé ''DISCTINCT'' comme ceci : ''SELECT COUNT(DISTINCT nom) from ARTISTE''.
+Plus loin encore : on pourrait produire une liste avec chaque nom associé avec le nombre d'artiste portant ce nom : ''SELECT nom, COUNT(idArtiste) FROM ARTISTE GROUP BY nom''.  Le mot-clé ''GROUP BY'' indique que l'on veut regrouper tous les artistes de même nom et la fonction ''COUNT'' se charge de compter les différents artistes groupés sous ce nom.</WRAP>
+==== Jointure ====
 Si je veux afficher les films
-```sql
+<code sql linenums>
 SELECT * FROM FILM;
-```
+</code>
 On n'est pas très satisfait car on ne voit pas le nom du réalisateur, seulement son id.
@@ Ligne 250: / Ligne 322: @@
 On réalise pour cela une **jointure**.
-```sql
+<code sql linenums>
 SELECT * FROM FILM JOIN ARTISTE ON FILM.idReal = ARTISTE.idArtiste;
-```
+</code>
 Et voilà !
@@ Ligne 258: / Ligne 330: @@
 On peut bien sûr limiter les colonnes, filtrer avec WHERE, trier, tout cela en même temps :
-```sql
+<code sql linenums>
 SELECT titreVO, année, nom, prénom FROM FILM JOIN ARTISTE ON FILM.idReal = ARTISTE.idArtiste WHERE année > 2000 ORDER BY naissance;
-```
+</code>
-*Remarque : ORDER BY doit être après WHERE*
-## Des requêtes de séléction pour s'exercer
-On utilise la base précédente.
-### Applications directes, sans jointure
-. Lister tous les noms, prénoms, naissances d'artistes nés avant 1970
-. Lister tous les titreVO de films dont le réalisateur à l'idArtiste 15
-. Lister tous les rôles joués par l'artiste d'idArtiste 1
-### Avec une jointure
-. Lister tous les titreVO, année des films de Tarantino
-. Lister tous les rôles de Brad Pitt
-. Lister tous les titreVO, année des films dans lequel a joué l'artiste avec l'idArtiste 1
-. Lister les noms et prénoms de tous les réalisateurs (*c'est à dire des artistes qui sont réalisateurd d'un film*)
-### Avec deux jointures
-Pour lier un artiste à un film en tant qu'acteur, il faut passer par JOUEDANS ce qui suppose deux jointures sous la forme
-```sql
-... FROM JOUEDANS
-  JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-  JOIN ARTISTE ON ARTISTE.idArtiste = JOUEDANS.idArtiste
-```
-. Trouver tous les titreVO, année des films dans lesquels joue un artiste nommé Willis
-. Trouver tous les titreVO, année des films dont un acteur est né après 1970
-*Remarque : La requête 8. correspond à la requête 6. mais nécessite une jointure supplémentaire. En situation réelle, on sera plutôt dans la situation du 6. car on connaîtra l'id de Bruce Willis*
-### Avec trois jointures...
-*Ça commence à devenir plus compliqué et on ne vous demande pas d'aller si loin.*
-Si pour une paire acteur - film, on veut en plus avoir le réalisateur du film, il faut en plus joindre FILM à ARTISTE selon la clé idRéal. Cette fois c'est plus difficile car ceci ne fonctionne pas :
-```sql
-... FROM JOUEDANS
-  JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-  JOIN ARTISTE ON ARTISTE.idArtiste = JOUEDANS.idArtiste
-  JOIN ARTISTE ON ARTISTE.idArtiste = FILM.idReal
-```
-Car ARTISTE apparaît deux fois pour des raisons différentes. Il est possible de se sortir d'embarras en donnant un alias à chaque occurence de ARTISTE. Par exemple on utilisera `acteur` pour la première apparition de ARTISTE et `réalisateur` pour la deuxième :
-```sql
-... FROM JOUEDANS
-  JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-  JOIN ARTISTE acteur ON acteur.idArtiste = JOUEDANS.idArtiste
-  JOIN ARTISTE réalisateur ON réalisateur.idArtiste = FILM.idReal
-```
-L'ajout de `acteur` et `réalisateur` juste à côté de ARTISTE suffit.
-Supposons que l'on veuille visualiser le nom d'acteur et le nom du réalisateur, le titreVO. On ne peut pas se contenter de
-```sql
-SELECT nom, nom, titreVO FROM JOUEDANS
-  JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-  JOIN ARTISTE acteur ON acteur.idArtiste = JOUEDANS.idArtiste
-  JOIN ARTISTE réalisateur ON réalisateur.idArtiste = FILM.idReal
-```
-car les deux occurences de nom sont ambigues : est-ce nom pour la première occurence de ARTISTE (acteur) ou la deuxième (réalisateur) ? Il faudra préciser :
-```sql
-SELECT acteur.nom, réalisateur.nom, titreVO FROM JOUEDANS
-  JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-  JOIN ARTISTE acteur ON acteur.idArtiste = JOUEDANS.idArtiste
-  JOIN ARTISTE réalisateur ON réalisateur.idArtiste = FILM.idReal
-```
-. Trouver tous les noms et prénoms, rôle et titreVO pour des acteurs jouant dans un film de Tarantino
-. Trouver tous les noms, prénoms de réalisateurs d'un film dont dont un des acteurs est né après 1970
-## Les réponses
-. Lister tous les noms, prénoms, naissances d'artistes nés avant 1970
-   ```sql
-   SELECT nom, prénom, naissance FROM ARTISTE WHERE naissance < '1970-01-01';
-   ```
-. Lister tous les films dont le réalisateur à l'idArtiste 15
-   ```sql
-   SELECT titreVO FROM FILM WHERE idReal = 15;
-   ```
-. Lister tous les rôles joués par l'artiste d'idArtiste 1
-   ```sql
-   SELECT rôle FROM JOUEDANS WHERE idArtiste = 1;
-   ```
-. Lister tous les titreVO, année des films de Tarantino
-   ```sqlite
-   SELECT titreVO, année FROM ARTISTE
-     JOIN FILM ON FILM.idReal = ARTISTE.idArtiste
-     WHERE nom = 'Tarantino';
-   ```
-. Lister tous les rôles de Brad Pitt
-   ```sqlite
-   SELECT rôle, année FROM JOUEDANS
-     JOIN ARTISTE ON JOUEDANS.idArtiste = ARTISTE.idArtiste
-     WHERE nom = 'Pitt' AND prénom = 'Brad';
-   ```
-. Lister tous les titreVO, année des films dans lequel a joué l'artiste avec l'idArtiste 1
-   ```sqlite
-   SELECT titreVO, année FROM FILM
-     JOIN JOUEDANS ON FILM.idFilm = JOUEDANS.idFilm
-     WHERE idArtiste = 1;
-   ```
-. Lister les noms et prénoms de tous les réalisateurs (*c'est à dire des artistes qui sont réalisateurd d'un film*)
-   ```sqlite
-   SELECT DISTINCT nom, prénom FROM ARTISTE
-     JOIN FILM ON FILM.idReal = ARTISTE.idArtiste;
-   ```
-   *Seuls apparaîtront les artistes pour lesquels la jointure est possible*
-. Trouver tous les titreVO, année des films dans lesquels joue un artiste nommé Willis
-   ```sql
-   SELECT titreVO, année FROM JOUEDANS
-     JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-     JOIN ARTISTE ON ARTISTE.idArtiste = JOUEDANS.idArtiste
-     WHERE nom = 'Willis' AND prénom = 'Bruce';
-   ```
-. Trouver tous les titreVO, année des films dont un acteur est né après 1970
-   ```sql
+<wrap important>ORDER BY doit être après WHERE</wrap>
-   SELECT titreVO, année FROM JOUEDANS
-     JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-     JOIN ARTISTE ON ARTISTE.idArtiste = JOUEDANS.idArtiste
-     WHERE naissance > '1970-01-01';
-   ```
-. Trouver tous les noms et prénoms, rôle et titreVO pour des acteurs jouant dans un film de Tarantino
+<WRAP tip>**Autre façon de faire :** Si on écrit
+<code sql linenums>
+SELECT * FROM FILM, ARTISTE;
+</code>
+On obtient tous les couples ''(FILM, ARTISTE)'' même s'ils n'ont rien à voir l'un avec l'autre. Si on ne veut que les paires où l'artiste est le réalisateur du film, on peut préciser :
+<code sql linenums>
+SELECT * FROM FILM, ARTISTE WHERE FILM.idReal = ARTISTE.idArtiste;
+</code>
+Ce qui revient à peu près au même que la  jointure.
-    ```sql
+//Dans tous les cas, inutile de vous remplir la tête de code SQL. On souhaite surtout que vous sachiez écrire des requêtes simples et que vous arriviez à comprendre. La requête précédente, même si elle n'est pas facile de la trouver tout seul, ne devrait pas être trop difficile à comprendre.//
-    SELECT acteur.nom, acteur.prénom, rôle, titreVO FROM JOUEDANS
+</WRAP>
-      JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-      JOIN ARTISTE acteur ON acteur.idArtiste = JOUEDANS.idArtiste
-      JOIN ARTISTE réalisateur ON réalisateur.idArtiste = FILM.idReal
-      WHERE réalisateur.nom = 'Tarantino';
-    ```
-. Trouver tous les noms, prénoms de réalisateurs d'un film dont dont un des acteurs est né après 1970
-    ```sql
-    SELECT DISTINCT réalisateur.nom, réalisateur.prénom FROM JOUEDANS
-      JOIN FILM ON FILM.idFilm = JOUEDANS.idFilm
-      JOIN ARTISTE acteur ON acteur.idArtiste = JOUEDANS.idArtiste
-      JOIN ARTISTE réalisateur ON réalisateur.idArtiste = FILM.idReal
-      WHERE acteur.naissance > '1970-01-01';
-    ```
-</markdown>