<p>Bonjour à vous,<br/>
On se retrouve pour le deuxième tutoriel sur le SQL et aujourd’hui, on va s'intéresser au SELECT.<br/><br/>
Je vous invite vivement à lire le premier chapitre, qui constitue une petite introduction sur ce qu'est le SQL ici : <iframe data-embed-src="<base_url>/topic/1343-introduction-au-sql/?do=embed" data-embedcontent="" frameborder="0" src="//melinyel.net/applications/core/interface/js/spacer.png"></iframe><br/><br/>
Revenons à nos moutons, voici de quoi sera composé ce cours :</p>
<ul><li>Projection</li>
<li>Restriction/Sélection</li>
<li>Jointures</li>
</ul><p>De plus, pendant ce cours, il se peut que je fasse référence à l'algèbre relationnelle. Ce n'est pas obligatoire, je ne m'attarderai pas dessus, mais si vous connaissez, ça ne peut être qu'un plus pour vraiment bien visualiser ce que vous voulez récupérer comme données.<br/>
En ayant vu ça, nous aurons déjà fait pas mal le tour des possibilités offertes par le SELECT.<br/><br/><strong><u><span style="font-size:18px;">I - Cas général :</span></u></strong><br/><br/>
Le SELECT est donc une requête SQL. En faisant un SELECT, on réalise une projection des données de la base de données, en fonction de différents critères.<br/><br/>
On l'écrit de la forme suivante :<br/>
</p>
<pre class="ipsCode prettyprint">
SELECT <liste des attributs projetés>
FROM <liste des relations touchées par la projection>
[ WHERE <liste des critères de restriction>
GROUP BY <liste des attributs d'agrégation>
HAVING <liste des critères de restriction des agrégats>
ORDER BY <liste des attributs du tri du résultat> ]
</pre>
<p>Pour ceux qui connaissent l'algèbre relationnelle, il est facile d'établir une correspondance avec un SELECT dans les requêtes simples.<br/><br/>
Si vous n'avez pas compris grand chose de ce que je viens d'expliquer, pas de panique, il s'agit juste de la structure de la requête. Les éléments entre crochets sont facultatifs.<br/><br/>
Tout au long de ce tutoriel, j'utiliserai le schéma de base de données suivant :</p>
<ul><li>DEPT(<u>DEPTNO</u>, DNAME, LOC)</li>
<li>EMP(<u>EMPNO</u>, ENAME, JOB, #MGR, HIREDATE, SAL, COMM, #DEPTNO)</li>
</ul><p>Les tables soulignées sont des clés primaires, et celles avec un #devant sont des clés étrangères. Pour mieux comprendre, je vous invite à jeter un coup d'oeil par ici : <a href="http://openclassrooms.com/courses/administrez-vos-bases-de-donnees-avec-mysql/cles-primaires-et-etrangeres" rel="external nofollow">http://openclassrooms.com/courses/administrez-vos-bases-de-donnees-avec-mysql/cles-primaires-et-etrangeres</a><br/><br/><strong><u><span style="font-size:18px;">II - Projection :</span></u></strong><br/><br/>
On va sélectionner les données à l'aide de la commande SELECT.<br/>
Comme vu plus haut, dans un SELECT, il faut au minimum un FROM afin de dire dans quelle table on se situe. L'ordre s'écrit donc :</p>
<pre class="ipsCode prettyprint">
SELECT <liste des attributs>
FROM <nom des tables>
</pre>
<p>Pour prendre un exemple, mettons que je veuille récupérer toutes les entrées de la table DEPT, la requête sera la suivante :</p>
<pre class="ipsCode prettyprint">
SELECT *
FROM dept
</pre>
<p>J'utilise le joker <strong></strong> afin de dire que je veux tous les attributs de la table. Cependant, il est préférable de ne garder que ce dont on a vraiment besoin lorsque l'on effectue la requête, c'est une question d'optimisation.<br/>
</p>
<pre class="ipsCode prettyprint">
SELECT deptno, dname
FROM dept
</pre>
<p>Ici, je sélectionne uniquement les attributs <em>deptno</em> et <em>dname</em> de la table dept.<br/><br/>
Ce qui nous embête ici, et contrairement à l'algèbre relationnelle, C'est que cette requête n'élimine pas les doublons. On va donc ajouter un mot-clé juste après le SELECT, il s'agit de DISTINCT.<br/><br/>
On obtient donc ;</p>
<pre class="ipsCode prettyprint">
SELECT DISTINCT job
FROM emp
</pre>
<p>Voila la différence :<br/>
Sans DISTINCT :<br/></p><p></p><blockquote class="ipsStyle_spoiler" data-ipsspoiler="">
<pre class="ipsCode prettyprint">
mysql> SELECT job FROM emp;
+-----------+
| job |
+-----------+
| EMPLOYE |
| VENDEUR |
| VENDEUR |
| MANAGER |
| EMPLOYE |
| PRESIDENT |
+-----------+
6 rows in set
</pre>
<p></p></blockquote><p><br/><br/>
Avec Distinct :<br/></p><p></p><blockquote class="ipsStyle_spoiler" data-ipsspoiler="">
<pre class="ipsCode prettyprint">
SELECT DISTINCT job FROM emp;
+-----------+
| job |
+-----------+
| EMPLOYE |
| VENDEUR |
| MANAGER |
| PRESIDENT |
+-----------+
4 rows in set
</pre>
<p></p></blockquote><p><br/><br/></p><hr/><br/><br/>
Intéressons nous maintenant au FROM, l'utilisation est très simple, mais on va voir comment créer un alias de table.<br/>
Concrètement, on va renommer la table <strong>provisoirement</strong> (le temps de la requête). C'est pour plus de lisibilité et plus de simplicité.<br/><br/>
Comment on fait ? Il suffit d'écrire ça :
<pre class="ipsCode prettyprint">
FROM nomdelatable alias
</pre>
<p>Ainsi, nous pourrons écrire des requêtes qui ressemblent à ça :<br/>
</p>
<pre class="ipsCode prettyprint">
SELECT d.deptno
FROM dept d
</pre>
<p>Le "d.deptno" peut se traduire par "la colonne deptno de la table d".<br/>
Simple non ?<br/>
Aller, au suivant !<br/><br/></p><hr/><br/><br/>
Maintenant qu'on a renommé une table, on va chercher comment renommer une colonne, toujours provisoirement ! C'est un peu plus subtil, mais rien de bien compliqué.<br/>
Ca va se passer comme ça :
<pre class="ipsCode prettyprint">
SELECT deptno AS Service, dname AS "Nom Service"
FROM dept;
</pre>
<p>On fait suivre le nom de la table par le mot clé "AS" et ensuite, si c'est un seul mot, pas de guillemets, sinon, on en met.<br/>
Note : Le AS est optionnel, on peut uniquement séparer le nom de table de l'alias par un espace.<br/><br/>
Regardons le résultat :</p>
<pre class="ipsCode prettyprint">
mysql> SELECT deptno AS Service, dname AS "Nom Service"
FROM dept;
+---------+--------------+
| Service | Nom Service |
+---------+--------------+
| 1 | Juridique |
| 2 | Recherche |
| 3 | Comptabilité |
| 4 | Support |
+---------+--------------+
4 rows in set
</pre>
<p>On a bien les colonnes qui sont renommées dans le résultat.<br/><br/></p><hr/><br/><br/>
On peut aussi faire des opérations directement dans un SELECT. Attention, on ne modifie pas le contenu de la table, on affiche juste des valeurs !<br/><br/>
On retrouve les 4 opérateurs bien connus :
<ul><li>+ : Addition</li>
<li>- : Soustraction</li>
<li> : Multiplication</li>
<li>/ : Division</li>
</ul><p>Ces opérateurs sont utilisables pour tout <strong>attribut numérique</strong> ! N'essayez pas de jouer avec les chaînes de caractères.<br/><br/>
Exemple :</p>
<pre class="ipsCode prettyprint">
mysql> SELECT (sal1.1)+comm FROM emp;
+----------------+
| (sal1.1)+comm |
+----------------+
| 880 |
| 2060 |
| 2200 |
| 3372.5 |
| 1430 |
| 16000 |
+----------------+
6 rows in set
</pre>
<p></p><hr/><br/><br/>
On va maintenant s'intéresser à comment trier les résultats d'une requête, avec la clause ORDER BY :
<ul><li>Le classement par défaut est ascendant (ASC). Pour inverser, on rajoutera DESC (comme descendant).</li>
<li><strong>Une seule</strong> clause ORDER BY et <strong>TOUJOURS</strong> à la fin du SELECT</li>
<li>Les éléments de tri ne figurent pas forcément dans le SELECT</li>
<li>Les valeurs NULL se trouvent à la fin si on a un tri ASC, où au début en cas de tri DESC</li>
<li>Les éléments de tri peuvent être le nom des colonnes, le numéro des colonnes ou même une expression.</li>
</ul><p>Quelques exemples :<br/></p><p></p><blockquote class="ipsStyle_spoiler" data-ipsspoiler=""><br/>
Premier exemple, on trie les résultats par numéro de département, puis par salaire.
<pre class="ipsCode prettyprint">
mysql> SELECT ename, sal, deptno FROM emp ORDER BY deptno, sal;
+---------+-------+--------+
| ename | sal | deptno |
+---------+-------+--------+
| JONES | 2975 | 2 |
| FORD | 1300 | 3 |
| SMITH | 800 | 4 |
| ALLEN | 1600 | 4 |
| RICARDO | 2000 | 6 |
| KING | 10000 | 6 |
+---------+-------+--------+
6 rows in set
</pre>
<p></p></blockquote><p><br/><br/></p><p></p><blockquote class="ipsStyle_spoiler" data-ipsspoiler=""><br/>
Deuxième exemple, on trie par salaire (du plus petit au plus grand).
<pre class="ipsCode prettyprint">
mysql> SELECT ename, sal, deptno FROM emp ORDER BY 2;
+---------+-------+--------+
| ename | sal | deptno |
+---------+-------+--------+
| SMITH | 800 | 4 |
| FORD | 1300 | 3 |
| ALLEN | 1600 | 4 |
| RICARDO | 2000 | 6 |
| JONES | 2975 | 2 |
| KING | 10000 | 6 |
+---------+-------+--------+
6 rows in set
</pre>
<p>2 est le numéro de colonne de sal dans le SELECT (il est a la seconde position)<br/></p></blockquote><p><br/><br/><strong><u><span style="font-size:18px;">III - Restriction/sélection :</span></u></strong><br/><br/>
On commence directement par la clause WHERE. Avec le WHERE, on va réduire le nombre de lignes concernées par la recherche.<br/>
Par exemple, on sélectionne tous les employés du service 1 :</p>
<pre class="ipsCode prettyprint">
SELECT ename, sal
FROM emp
WHERE deptno = 10
</pre>
<p>Les conditions de recherche sont des expressions logiques vraies ou fausses, en fonction des enregistrements de la table. Une condition peut aussi être appelée prédicat.<br/>
Une condition est toujours composée de 3 membres : deux expressions encadrant un opérateur de comparaison.<br/>
On peut comparer un attribut avec une valeur constante (comme dans l'exemple), mais aussi deux attributs entre eux.<br/><br/>
On retrouve les opérateurs de comparaison usuels à savoir :</p>
<ul><li>Comparaison : =, !=, <>, >, >=, <, <=</li>
<li>Intervalles : BETWEEN</li>
<li>Concordance de caractères : LIKE avec les jokers _ et %</li>
<li>Gestion des colonnes "NULL" : IS NULL</li>
<li>Enumération : IN</li>
<li>Négation : NOT IN, NOT LIKE, NOT BETWEEN, IS NOT NULL</li>
</ul><p></p><hr/><br/><br/>
Intéressons-nous aux opérateurs de comparaison suivants : <, >, <= et >=<br/>
On peut les utiliser avec les types suivants :
<ul><li>numérique</li>
<li>Alphabétique</li>
<li>Chronologique (avec les dates)</li>
</ul><p>Exemple avec les dates :</p>
<pre class="ipsCode prettyprint">
SELECT ename, hiredate
FROM emp
WHERE hiredate < '1981-01-01'
-- Le format de la date depend du SGBD
</pre>
<p>Pour les comparaisons de chaînes de caractères, les lettres majuscules et minuscules sont supérieures aux nombres et la casse peut importer, tout dépend de comment le SGBD est réglé.<br/><br/>
Exemple avec les chaînes :</p>
<pre class="ipsCode prettyprint">
SELECT ename
FROM emp
WHERE ename > 'MARTIN'
</pre>
<p></p><hr/><br/><br/>
Passons au LIKE :<br/>
Il est très utilisé, notamment pour tout ce qui est scripts de recherche, le tout est de bien savoir l'utiliser !<br/>
Comme vous l'avez vu un peu plus haut, on utilise deux jokers :
<ul><li>_ qui remplace une lettre</li>
<li>% qui remplace tout chaîne de caractère</li>
</ul><p>Peu compréhensible n'est-ce pas ?<br/>
Regardons un exemple pour mieux comprendre :</p>
<pre class="ipsCode prettyprint">
SELECT ename
FROM emp
WHERE ename LIKE ('_AR%')
</pre>
<p>Que demande cette requête ? On cherche les noms d'employés qui ont pour deuxième lettre A et troisième lettre R dans leur nom de famille. soit :</p>
<pre class="ipsCode prettyprint">
SELECT ename
FROM emp
WHERE ename LIKE ('_AR%');
+--------+
| ename |
+--------+
| WARD |
| MARTIN |
+--------+
2 rows in set
</pre>
<p>Déjà un peu plus compréhensible non ? C'est en jouant avec ces deux jokers qu'on arrive à trouver ce qu'on veut.<br/><br/></p><hr/><br/><br/>
On va maintenant s'intéresser au IN :<br/>
Il s'agit en fait d'une énumération. Seulement, on peut l'utiliser avec différents types.<br/>
Par exemple, on sélectionne les employés travaillant dans les services 3 et 4 :<br/><p></p><blockquote class="ipsStyle_spoiler" data-ipsspoiler="">
<pre class="ipsCode prettyprint">
SELECT ename, deptno
FROM emp
WHERE deptno IN (3,4);
+--------+--------+
| ename | deptno |
+--------+--------+
| SMITH | 4 |
| ALLEN | 4 |
| FORD | 3 |
| WARD | 3 |
| MARTIN | 3 |
+--------+--------+
5 rows in set
</pre>
<p></p></blockquote><p><br/>
Les membres sont entre parenthèses et séparés par une virgule, on peut mettre autant de termes qu'on veut.<br/>
Le fonctionnement pour le NOT IN est le même. Seulement, on ne prendra que les données dont la valeur du champ n'est pas dans les parenthèses.<br/>
<br/></p><hr/><br/>
<br/><strong>BETWEEN</strong> et <strong>NOT BETWEEN</strong><br/>
<br/>
On recherche un champ dont la valeur est entre deux valeurs. Il faut savoir que les bornes du BETWEEN sont inclues dans la recherche.<br/>
<br/><strong>Exemple :</strong> On recherche les employés qui ont un salaire compris entre 1600 et 3000 :<br/><p></p><blockquote class="ipsStyle_spoiler" data-ipsspoiler="">
<pre class="ipsCode prettyprint">
SELECT ename, sal
FROM emp
WHERE sal BETWEEN 1600 AND 3000;
+---------+------+
| ename | sal |
+---------+------+
| ALLEN | 1600 |
| RICARDO | 2000 |
| JONES | 2975 |
| MARTIN | 1650 |
+---------+------+
4 rows in set
</pre>
<p></p></blockquote><p><br/><br/></p><hr/><br/>
<br/>
On passe maintenant à l'opérateur de comparaison <strong>IS NULL</strong><br/>
Il faut savoir quelques petites choses avant de commencer :
<ul><li>Une valeur NULL est une valeur inconnue
<ul><li>NULL <> 0</li>
<li>NULL = valeur non renseignée</li>
<li>On teste par IS NULL et non = NULL</li>
</ul></li></ul><p>Exemple : Les employés et leur département qui ont une commission NULL<br/></p><p></p><blockquote class="ipsStyle_spoiler" data-ipsspoiler="">
<pre class="ipsCode prettyprint">
SELECT ename, deptno FROM emp WHERE comm IS NULL;
+--------+--------+
| ename | deptno |
+--------+--------+
| WARD | 3 |
| MARTIN | 3 |
+--------+--------+
2 rows in set
</pre>
<p> </p></blockquote><p><br/>
Seulement, une colonne NULL n'est pas très pratique pour faire des calculs. C'est pourquoi chaque SGBD permet de remplacer NULL par une autre valeur. Seulement, cette fonction dépend des SGBD :</p>
<ul><li>Pour Oracle : NVL()</li>
<li>Pour SQL Server : ISNULL()</li>
<li>Pour PostgreSQL : COALESCE()</li>
<li>Pour MySQL : IFNULL()</li>
</ul><p>Dans ce tutoriel, j'utilise MySQL donc je prendrai pour exemple IFNULL().<br/>
Regardons :</p>
<pre class="ipsCode prettyprint">
SELECT ename, sal, comm, sal + comm, sal + IFNULL(comm,0) FROM emp;
+---------+-------+------+------------+----------------------+
| ename | sal | comm | sal + comm | sal + IFNULL(comm,0) |
+---------+-------+------+------------+----------------------+
| SMITH | 800 | NULL | NULL | 800 |
| ALLEN | 1600 | 300 | 1900 | 1900 |
| RICARDO | 2000 | NULL | NULL | 2000 |
| JONES | 2975 | 100 | 3075 | 3075 |
| FORD | 1300 | NULL | NULL | 1300 |
| KING | 10000 | 5000 | 15000 | 15000 |
| WARD | 1500 | NULL | NULL | 1500 |
| MARTIN | 1650 | NULL | NULL | 1650 |
+---------+-------+------+------------+----------------------+
8 rows in set
</pre>
<p>Pratique non ?<br/>
Passons à la suite !<br/>
<br/></p><hr/><br/>
<br/><strong>Les opérateurs logiques</strong><br/>
Dans une requête SQL, on pourra utiliser des opérateurs logiques afin de lier deux prédicats. Cela permet d'avoir un résultat plus précis avec des conditions simples.<br/>
Les principaux opérateurs logiques sont (par ordre d'évaluation) :
<ul><li>NOT</li>
<li>AND</li>
<li>OR</li>
</ul><p>Ils s'utilisent comme cela :</p>
<pre class="ipsCode prettyprint">
SELECT * FROM emp WHERE deptno = 1 AND sal > 1000;
</pre>
<p>Il est plus que conseillé d'utiliser des parenthèses pour "imposer" l'ordre d'exécution des opérateur logiques.<br/>
<br/></p><hr/><br/>
<br/>
On arrive à la fin de ce chapitre sur la restriction et la sélection des données. Le prochain chapitre sur les jointures sera plus pointu, et plus complet. N'hésitez pas à relire plusieurs fois certains points, quitte à demander un éclaircissement sur quelque chose que vous n'auriez pas compris.<br/>
<br/>
Avant de passer au prochain chapitre, je vais ajouter un dernier point :<br/>
Le résultat d'un SELECT est en fait une relation. On pourra donc utiliser le résultat d'un SELECT dans plusieurs cas :
<ul><li>Sous requête</li>
<li>Jointures</li>
<li>UNION (et opérations ensemblistes)</li>
</ul><p>Voila, le chapitre est terminé, on passe à la suite !<br/>
<br/><strong><u><span style="font-size:18px;">IV - Jointures</span></u></strong><br/>
<br/>
Passons au point le plus marrant de ce tutoriel, et ce sera le dernier. Écoutez bien, les jointures sont des notions importantes pour bien manipuler une base de données !</p>
<p>En effet, les jointures vont nous permettre de mettre en corrélation plusieurs tables au sein d'une même requête, donc en économisant (si c'est bien fait) des ressources système et sans avoir besoin de traitement dans un autre langage (tel que PHP, par exemple).</p>
<p> </p>
<p>Il existe trois "grandes familles" de jointures :</p>
<ul><li>Le produit cartésien</li>
<li>Les jointures naturelles</li>
<li>Les théta-jointures (ou équi-jointures)</li>
</ul><p>Je vais tous vous les présenter, mais celui qui nous intéresse est bien évidemment le dernier.</p>
<p> </p>
<ul><li><strong>Le produit cartésien : </strong>Il s'agit d'une opération entre les relations qui combine toutes les occurrences. C'est à dire que le nombre de lignes du résultat est égal au produit du nombre de lignes de chacune des relations. Autrement dit, si on a une table qui contient 3 entrées, et qu'on fait un produit cartésien avec une autre table qui en contient 4, le résultat fera 12 lignes.</li>
</ul><p style="margin-left:40px;">Exemple :</p>
<pre class="ipsCode prettyprint">
mysql> SELECT *
-> FROM lettre,chiffre;
+--------+---------+
| lettre | chiffre |
+--------+---------+
| a | 1 |
| b | 1 |
| c | 1 |
| a | 2 |
| b | 2 |
| c | 2 |
| a | 3 |
| b | 3 |
| c | 3 |
| a | 4 |
| b | 4 |
| c | 4 |
+--------+---------+
12 rows in set
</pre>
<p style="margin-left:40px;">Vous avouerez que, quand on manipule de grandes bases de données, cette méthode est très gourmande en ressources et en plus, il est très probable que nous n'utilisions pas tous les résultats.</p>
<ul><li><strong>La jointure naturelle : </strong>En fait, ce que nous allons appeler jointure peut s'apparenter à un produit cartésien suivi d'une restriction, puis d'une projection. On va combiner des relations ayant des valeurs en commun. Dès maintenant, nous allons beaucoup utiliser les alias afin de simplifier un petit peu nos requêtes. Ne soyez donc pas étonnés lorsque j'en utilise, c'est devenu une habitude.</li>
</ul><p style="margin-left:40px;">Dès maintenant, nous utiliserons aussi la syntaxe SQL 2 qui introduit justement ces différents types de jointures. Avant, les jointures n'étaient en fait que des produits cartésiens.</p>
<p style="margin-left:40px;">Trêve de papotages futiles, voici comment s'écrit une jointure naturelle :</p>
<pre class="ipsCode prettyprint">
SELECT deptno, ename
FROM dept
NATURAL JOIN emp
-- Fonctionne sous MySQL, Oracle et PostgreSQL mais pas sous MS SQL Server
</pre>
<p style="margin-left:40px;">En fait, une jointure naturelle cherche des champs avec le même nom afin de les mettre en commun. C'est dangereux à utiliser si des colonnes portant le même nom ne se réfèrent pas aux mêmes données. Je vous déconseille de l'utiliser, sauf si vous êtes surs de la base de données que vous utilisez et qu'elle est bien modélisée.</p>
<p style="margin-left:40px;"> </p>
<ul><li><strong>La thêta-jointure :</strong> C'est le type de jointure le plus souvent utilisé. Nous sommes vraiment maîtres de ce que l'on recherche. La syntaxe est simple à comprendre :</li>
</ul><pre class="ipsCode prettyprint">
-- Nom et salaire des employés gagnant plus que l'employé 7566
SELECT e1.ename, e1.sal
FROM emp e1
JOIN emp e2 ON e1.sal > e2.sal -- On fait la jointure avec la condition
WHERE e2.empno = 7566
</pre>
<p style="margin-left:40px;">Plutôt simple non ? </p>
<p style="margin-left:40px;">Pour l'équi-jointure, c'est le même principe, juste la condition change !</p>
<pre class="ipsCode prettyprint">
-- On cherche le nom de chaque employé avec le nom de son département
SELECT e.ename, d.dname
FROM emp e
JOIN dept d ON e.deptno=d.deptno
</pre>
<p style="margin-left:40px;">Alors, convaincus ? Ne vous inquiétez pas, j'ai bientôt fini ! Je vous présente juste une dernière notion</p>
<ul><li><strong>Left/right join : </strong>En fait,<strong> </strong>une jointure élimine par défaut les résultats ou il n'y a pas de correspondance (exemple, si un employé n'a pas de département, il ne sera pas affiché). Pour pallier ce problème, il faut dire à SQL de garder les champs à gauche, même si il n'y a pas de correspondance.</li>
</ul><p style="margin-left:40px;">Exemple :</p>
<pre class="ipsCode prettyprint">
mysql> SELECT ename, e.deptno, dname
-> FROM emp e
-> LEFT JOIN dept d ON e.deptno=d.deptno;
+---------+--------+--------------+
| ename | deptno | dname |
+---------+--------+--------------+
| JONES | 2 | Recherche |
| FORD | 3 | Comptabilité |
| WARD | 3 | Comptabilité |
| MARTIN | 3 | Comptabilité |
| SMITH | 4 | Support |
| ALLEN | 4 | Support |
| KING | 6 | HeadOffice |
| RICARDO | NULL | NULL |
+---------+--------+--------------+
8 rows in set
</pre>
<p style="margin-left:40px;">Ici, on a dit : "Même si il n'y a pas de correspondance, tu gardes les membres étant à gauche (LEFT) de la jointure" et Ricardo est apparu. C'est exactement le même principe pour RIGHT, tout dépend de comment vous construisez vos requêtes.</p>
<p style="margin-left:40px;"> </p>
<p></p><p>Voilà, je pense avoir fait le tour pour ce tutoriel. N'hésitez pas à réagir, contester, demander des éclaircissements...</p>
<p>Bon courage dans vos requêtes SQL <br/><br/>
Merci d'avoir lu,<br/>
Pirkoa</p>
