SQL Joins (nog uitgebreider)

Opmerking:
De gemelde schematische weergaven zoals bij een groot deel van de typen Joins staat aangegeven worden nog aan de tutorial toegevoegd.

Er wordt voor het ontwikkelen op internet steeds meer gebruik gemaakt van een database, waarin de informatie die op je website wordt getoond wordt opgeslagen. Bezoekers van de website merken hier (bij een goede opbouw) verder helemaal niets van en krijgen gewoon een website voorgeschoteld. Wanneer de database verkeerd is opgebouwd, kan het wel zijn dat het systeem nogal traag wordt en dat een bezoeker dit kan merken. (ook bij een niet goede foutafhandeling kan het merkbaar zijn voor de bezoeker) Meestal bestaat een database uit meerdere tabellen waaruit informatie kan worden opgevraagd. Maar hoe doe je dit nu op een handige manier?

Maar wat nou als je een groot systeem hebt gemaakt, hebt genormaliseerd (zie voor de link, de informatie aan het einde van de inleiding) en je dus meerdere tabellen hebt waar je gegevens uit moet halen? Wanneer dit het geval is moet je joins gaan gebruiken. De naam zegt het eigenlijk een beetje: to join Betekend iets als aansluiten, meedoen. Met een JOIN koppel je gegevens uit verschillende tabellen welke aan elkaar gekoppeld zijn ook in de query aan elkaar. Je kan er met een join voor zorgen dat je query gekoppelde gegevens in één keer terug geeft.

Gedurende deze tutorial zal ik een aantal mogelijkheden noemen van het werken met joins in SQL. Aan de hand van die voorbeelden zal het langzaamaan duidelijk worden wat een join nou precies inhoud en op welke verschillende manieren je hem kan gebruiken. In eerste instantie zal ik alle vormen van JOINS doorlopen, met "slechts" 2 tabellen in die JOIN. Ik zal aan het einde nog een voorbeeld geven van een JOIN waarbij je 3 tabellen gebruikt, zodat je kan zien dat het bouwen van een grotere JOIN eigenlijk helemaal niet zo lastig is en je weet hoe je in zo’n situatie de query op moet bouwen.

Door een plaatje in een forumpost van Jan Koehoorn (kan de post niet terugvinden, maar het heeft me wel gestimuleerd deze tutorial op deze manier te herschrijven) zag ik dat je een Join heel mooi kan weergeven met cirkels. Ik zal deze cirkels (elke cirkel stelt een tabel voor) ook steeds gebruiken door de tutorial heen, om zo een schematisch beeld te geven van wat de JOIN uit het voorbeeld doet.

Opmerkingen vooraf
Normaliseer je database
Het is voor het goed functioneren van deze mogelijkheid in SQL heel belangrijk dat je database op een goede manier is opgebouwd. Normalisatie is voor het goed opbouwen van een database een goede methode. Daarom wil ik via hier nog even op deze tutorial wijzen: http://phphulp.nl/php/tutorials/3/150/

Andere mogelijkheden
Met de JOIN kan je de referentiële integriteit van de database gebruiken, om gekoppelde gegevens uit meerdere tabellen op de juiste manier op te halen. Echter is het geen manier om de referentiële integriteit te waarborgen. Hiervoor kan je binnen SQL ook de zogeheten foreign keys aanmaken, om vanuit het SQL systeem te zorgen dat je ook de juiste gegevens in je database hebt.
Sommige providers bieden naast de standaard MySQL ook de mogelijkheid om PostgreSQL (een andere opensource variant) te gebruiken. Hierin zit een optie om sleutelvelden aan te geven en ook waaraan ze worden gekoppeld.
Wil je hier meer over weten kijk dan even bij deze 2 tutorials:
- http://www.phphulp.nl/php/tutorials/3/334/
- http://www.phphulp.nl/php/tutorials/3/371/

Aanleiding:
De aanleiding voor het schrijven van deze tutorial kwam eigenlijk door een vraag van Elsy, waarin een JOIN was gebruikt (de INNER JOIN). De bedoeling van de query was dat deze zowel de Categoriën uit de ene tabel haalde en subcategorieën uit de andere. Nu kreeg ze door het verkeerde type JOIN alleen de categorieën waar wel een subcategorie onder viel.
Toen bedacht ik mij dat het wel heel handig zou zijn als daar een tutorial voor kwam, omdat de JOIN een nette en gemakkelijke manier is om gegevens te halen uit 2 gekoppelde tabellen.
Deze aanleiding was de originele aanleiding (die van de vorige tutorial), de uiteindelijke aanleiding om deze (verbeterde) tutorial te schrijven was een post van Jan Koehoorn, die een afbeelding liet zien van de verschillende Joins. Deze bevatte alle verschillende Joins in schematische weergave, op dezelfde manier als deze door de tutorial gebruikt worden.

Uitleg
De vet en cursief gedrukte woorden zijn de tabelnamen, daaronder staat in het onderlijnt welke kolom de primairy key is, en de onderstreepte en cursieve kolommen zijn foreign keys. Deze kolommen hebben een link met een kolom in één van de andere tabellen. (Dit wijst zich overigens vanzelf)

Achter de kolomnamen staat in het cursief, gescheiden door een komma, welke waarden er in die velden staan. (voorbeeld data) De data types heb ik er niet bij staan, ik neem aan dat je deze zelf wel kan bepalen en het is ook niet van groot belang voor de tutorial. (onderaan deze pagina staat nog wel een SQL dump van de database)


actors
id 1, 2, 3, 4
firstname Angel, Brador, John, Arno
lastname Jolige, Pittje, Depperd, Zwartebesje
birthdate 1977-10-05, 1979-05-16, 1957-09-24, 1959-04-03

movies
id 1, 2, 3
title Eduard Schaarhand, Tombe rijder, Zeven jaar in de bergen
subtitle Een sprookje van …, De wig des levens, Een tibetaans verhaaltje voor het slapengaan

movie_actors
id 1, 2, 3, 4, 5, 6
actor_id 4, 3, 2, 1, 1, 3
movie_id 2, 3, 3, 1, 2, 1


Deze opbouw wordt hier gebruikt in de tutorial om op een herkenbare manier te laten zien wat joins doen en hoe ze werken.

SQL dump

--
-- Tabel structuur voor tabel `actors`
--
CREATE TABLE IF NOT EXISTS `actors` (
  `id` int(8) unsigned NOT NULL AUTO_INCREMENT,
  `firstname` varchar(255) NOT NULL,
  `lastname` varchar(255) NOT NULL,
  `birthdate` date NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ;

--
-- Gegevens worden uitgevoerd voor tabel `actors`
--
INSERT INTO `actors` (`id`, `firstname`, `lastname`, `birthdate`) VALUES
(1, 'Angel', 'Jolige', '1977-10-05'),
(2, 'Brador', 'Pittje', '1979-05-16'),
(3, 'John', 'Depperd', '1957-09-24'),
(4, 'Arno', 'Zwartebesje', '1959-04-03');
--
-- Tabel structuur voor tabel `movies`
--
CREATE TABLE IF NOT EXISTS `movies` (
  `id` int(8) unsigned NOT NULL AUTO_INCREMENT,
  `title` varchar(255) NOT NULL,
  `subtitle` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 ROW_FORMAT=COMPACT AUTO_INCREMENT=4 ;
--
-- Gegevens worden uitgevoerd voor tabel `movies`
--
INSERT INTO `movies` (`id`, `title`, `subtitle`) VALUES
(1, 'Eduard Schaarhand', 'Een sprookje van ...'),
(2, 'Tombe rijder', 'De wig des levens'),
(3, 'Zeven jaar in de bergen', 'Een Tibetaans verhaaltje voor het slapengaan'),
(4, 'Caribische piraten', 'Een waargebeurd verhaal van Disney');
--
-- Tabel structuur voor tabel `movie_actors`
--
CREATE TABLE IF NOT EXISTS `movie_actors` (
  `id` int(8) unsigned NOT NULL AUTO_INCREMENT,
  `actor_id` int(8) unsigned NOT NULL,
  `movie_id` int(8) unsigned NOT NULL,
  PRIMARY KEY (`id`),
  KEY `actor_id` (`actor_id`),
  KEY `movie_id` (`movie_id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=7 ;

--
-- Gegevens worden uitgevoerd voor tabel `movie_actors`
--
INSERT INTO `movie_actors` (`id`, `actor_id`, `movie_id`) VALUES
(1, 4, 2),
(2, 3, 3),
(3, 2, 3),
(4, 1, 1),
(5, 1, 2),
(6, 3, 1);
--
-- Beperkingen voor tabel `movie_actors`
--
ALTER TABLE `movie_actors`
  ADD CONSTRAINT `movie_actors_ibfk_2` FOREIGN KEY (`movie_id`) REFERENCES `movies` (`id`),
  ADD CONSTRAINT `movie_actors_ibfk_1` FOREIGN KEY (`actor_id`) REFERENCES `actors` (`id`); 

De inner Join wordt gebruikt om deze gegevens uit een tabel te halen, welke in beide tabellen voorkomen. De tabellen worden aan elkaar gekoppeld op een bepaalde kolom. Alleen wanneer een waarde in de kolom in tabel a en in tabel b voorkomt, worden deze geselecteerd.

Aan de hand van de in hoofdstuk 2 behandelde tabelstructuur worden in onderstaande query alle films opgehaald aan welke ook een acteur is gekoppeld. Omdat voor het ophalen van een acteur bij een bepaalde film meer dan 1 tabel nodig is, worden hier alleen de films opgehaald die ook voorkomen in de movie_actor koppeltabel.

SELECT
   m.id,
   m.title
FROM
   movies AS m
INNER JOIN
   movie_actors AS ma
ON 
   m.id = ma.movie_id

Het resultaat is dan:

1	Eduard Schaarhand
1	Eduard Schaarhand
2	Tombe rijder
2	Tombe rijder
3	Zeven jaar in de bergen
3	Zeven jaar in de bergen

Zoals je ziet komt de film met id = 4 niet voor in de resultaten. Deze wordt niet weergegeven, omdat deze (door de koppeling die ook met de JOIN wordt gelegd) niet in beide tabellen voorkomt. Hieronder is schematisch aangegeven welke gegevens met de INNER JOIN worden geselecteerd.

De Left Join wordt gebruikt om deze gegevens uit een tabel te halen, welke in de linker (eerstgenoemde, dus in dit geval “movies”) tabel voorkomen en waar mogelijk gekoppeld aan de rechter tabel. Indien een waarde uit de linker tabel niet voorkomt in de rechtertabel wordt deze waarde uit de linker tabel weergegeven, en in plaats van de waarde uit de kolom uit de rechter tabel (“ma.actor_id”) wordt dan de waarde “NULL” geretourneerd.

SELECT
   m.id,
   m.title,
   ma.actor_id
FROM
   movies AS m
LEFT JOIN
   movie_actors AS ma
ON 
   m.id = ma.movie_id

Het resultaat is dan:

1	Eduard Schaarhand		1
1	Eduard Schaarhand		3
2	Tombe rijder			4
2	Tombe rijder			1
3	Zeven jaar in de bergen		3
3	Zeven jaar in de bergen		2
4	Caribische piraten		[i]NULL[/i]

Zoals je ziet komt de film met id = 4 nu wel voor in de resultaten. De waarde van de actor_id uit de movie_actor tabel wordt bij deze film weergegeven als NULL. Dit omdat de film niet voorkomt in de koppeltabel waarbij de film aan een acteur gekoppeld wordt. Zo krijg je toch alle films terug, en waar mogelijk ook de bijbehorende actor_id.
Hieronder is schematisch aangegeven welke gegevens met de “Gewone Left Join” worden geselecteerd.

Je zult wel denken (op de titel afgaande) wat hier nu weer mee bedoeld wordt. Nou, dat zal ik je uitleggen. In sommige situaties is het wenselijk om alleen de gegevens die nog niet zijn gekoppeld op te halen. Daarvoor gebruik je “WHERE tweede_tabel.key IS NULL”, wat er in SQL code zo uit ziet:

SELECT
   m.id,
   m.title,
   ma.actor_id
FROM
   movies AS m
LEFT JOIN
   movie_actors AS ma
ON 
   m.id = ma.movie_id
WHERE
   ma.actor_id IS NULL

Het resultaat is dan:

4	Caribische piraten		[i]NULL[/i]

Zoals je ziet wordt nu alleen de film opgehaald die nog niet voorkomt in de koppeltabel.
Hieronder is schematisch aangegeven welke gegevens met de “Left Join: IS NULL” worden geselecteerd.

De Right Join wordt gebruikt om deze gegevens uit een tabel te halen, welke in de rechter (tweedgenoemde, dus in dit geval “movies”) tabel voorkomen en waar mogelijk gekoppeld aan de linker tabel. Indien een waarde uit de rechter tabel niet voorkomt in de rechtertabel wordt deze waarde uit de rechter tabel weergegeven, en in plaats van de waarde uit de kolom uit de linker tabel wordt dan de waarde “NULL” geretourneerd.

De Right Join is eigenlijk de omgekeerde versie van de Left Join. In onderstaande voorbeeld heb ik de tabellen “movie_actors” en “movies” in de query omgewisseld van positie.

SELECT
   m.id,
   m.title,
   ma.actor_id
FROM
   movie_actors AS ma 
RIGHT JOIN
   movies AS m
ON 
   m.id = ma.movie_id

Het resultaat is dan:

1	Eduard Schaarhand		1
1	Eduard Schaarhand		3
2	Tombe rijder			4
2	Tombe rijder			1
3	Zeven jaar in de bergen		3
3	Zeven jaar in de bergen		2
4	Caribische piraten		[i]NULL[/i]

Zoals je ziet komt het resultaat overeen met de Left Join, die in hoofdstuk 4 aan bod kwam. Dit is alleen omdat de tabelnamen nu zijn omgewisseld in de query, zodat duidelijk is hoe een Right Join werkt. Normaal gesproken krijg je dus een heel ander resultaat, omdat je dan van de Left Join een Right Join maakt, zonder dat je de tabellen van positie wisselt.

Hieronder is schematisch aangegeven welke gegevens met de “Gewone Right Join” worden geselecteerd.

Wederom werkt dit type Join op dezelfde manier als de Left Join variant, maar precies omgekeerd. Waar bij de Left Join wordt uitgegaan van de gegevens in de linker (eerstgenoemde) tabel, wordt er hier uitgegaan van de gegevens in de rechter (tweedgenoemde) tabel.

SELECT
   m.id,
   m.title,
   ma.actor_id
FROM
   movie_actors AS ma
RIGHT JOIN
   movies AS m
ON 
   m.id = ma.movie_id
WHERE
   ma.actor_id IS NULL

Het resultaat is dan:

4	Caribische piraten		[i]NULL[/i]

Zoals je ziet wordt nu alleen de film opgehaald die nog niet voorkomt in de koppeltabel.

Hieronder is schematisch aangegeven welke gegevens met de “Right Join: IS NULL” worden geselecteerd.

De Full Outer Join (ook wel gewoon “Outer Join”) werkt helaast niet “gewoon” in MySQL. Normaal gesproken krijg je alle mogelijke resultaten terug die er zijn, waarbij de lege waarden (net als bij de Left en Right Join) worden ingevuld met “NULL”. De Outer Join is eigenlijk een combinatie van de Left en Right Join. Hij werkt namelijk beide kanten op.

De query ziet er dan uit als onderstaande (werkt dus niet in MySQL en het gaat te ver om de mogelijke workaround hiervoor in deze tutorial te behandelen)

SELECT
   m.id,
   m.title,
   ma.actor_id
FROM
   movie_actors AS ma 
FULL OUTER JOIN
   movies AS m
ON 
   m.id = ma.movie_id

Het resultaat is dan:

1	Eduard Schaarhand		1
1	Eduard Schaarhand		3
2	Tombe rijder			4
2	Tombe rijder			1
3	Zeven jaar in de bergen		3
3	Zeven jaar in de bergen		2
4	Caribische piraten		[i]NULL[/i]
NULL	NULL				5   		(fictief!!!)

Omdat het hier een koppeling met een koppeltabel betreft zal een filmtitel nooit “NULL” zijn. Ik denk dat je uit het resultaat (let op, de laatste rij is fictief) wel kan zien wat er precies gebeurt.

Hieronder is schematisch aangegeven welke gegevens met de “Outer Join” worden geselecteerd.

Net als met de Left en Right Join kan je ook met de Outer Join alleen de gegevens selecteren die niet in beide tabellen voorkomen. Het werkt op ongeveer dezelfde manier, alleen moet je in de WHERE niet 1 kolom uit een tabel controleren, maar kolommen uit beide tabellen.

SELECT
   m.id,
   m.title,
   ma.actor_id
FROM
   movie_actors AS ma 
FULL OUTER JOIN
   movies AS m
ON 
   m.id = ma.movie_id
WHERE
   m.id IS NULL
OR
   ma.movie_id IS NULL

Het resultaat is dan:

4	Caribische piraten		[i]NULL[/i]
NULL	NULL				5   		(fictief!!!)

Omdat het hier een koppeling met een koppeltabel betreft zal een filmtitel nooit “NULL” zijn. Ik denk dat je uit het resultaat (let op, de laatste rij is fictief) wel kan zien wat er precies gebeurt.

Hieronder is schematisch aangegeven welke gegevens met de “Outer Join: NOT NULL” worden geselecteerd.

Natuurlijk zijn de in de voorgaande “hoofdstukken” genoemde Joins niet compleet. Je krijgt nu bij een film alleen de actor_id te zien, maar je weet niet wie er in de film speelt. Hiervoor heb je een koppeling tussen alle 3 de tabellen nodig. Natuurlijk is de titel “Multiple Join” geen officiële benaming, maar het dekt wel de lading van wat ik jullie hier laat zien.

Deze “multiple join” schreef ik in de vorige tutorial anders uit dan hier. Ook ik leer natuurlijk bij en heb geleerd dat het noteren van een “Multiple Join” zonder de haakjes (ik zal beide voorbeelden hier laten zien) prima kan en minstens net zo gemakkelijk is. Sterker nog, hij is gemakkelijker te lezen (omdat het van boven naar beneden geld) dan de variant met haakjes. (daar ga je uit van de “laatste join” omdat die twee tabellen de basis vormen dan dan weer verder omhoog) In de variant zonder haakjes vormen de eerste twee tabellen de basis enzo verder tot aan de laatste Join.

Goed, om te laten zien hoe die multiple Join eruit kan komen te zien, hieronder eerst de variant met haakjes:

SELECT
   m.id AS id_movie,
   m.title,
   CONCAT(a.firstname,’ ‘,a.lastname)
FROM
   movies AS m
INNER JOIN
     (movie_actors AS ma
   INNER JOIN
      actors AS a
   ON
      a.id = ma.actor_id)
ON 
   m.id = ma.movie_id
 

Om bovenstaande code te “lezen” lees je eerst de Join die tussen haakjes staat. Er wordt in theorie (in praktijk weet ik niet hoe het aan de achterkant gaat, maar deze uitleg maakt het misschien wat begrijpelijker) een tabel gemaakt van de Join tussen movie_actors en actors, en vervolgens een Join op deze nieuwe tabel met de movies tabel.

Gemakkelijker vind ikzelf (dit is echter maar net wat je zelf prettiger vindt) de notatie zonder haakjes, omdat je zo gewoon van boven naar beneden kan lezen. (zie de voorbeeldcode hieronder)

SELECT
   m.id AS id_movie,
   m.title,
   CONCAT(a.firstname,’ ‘,a.lastname)
FROM
   movies AS m
INNER JOIN
   movie_actors AS ma
ON 
   m.id = ma.movie_id
INNER JOIN
   actors AS a
ON
   a.id = ma.actor_id
 

Hier wordt eerst een nieuwe tabel gemaakt van de join tussen movies en movie_actors om vervolgens deze nieuwe tabel te combineren met de actors tabel.

Beide query’s doen verder precies hetzelfde en hebben hetzelfde resultaat. De volgorde van de tabellen maakt niet heel veel uit in de Join, maar je moet er wel altijd rekening mee houden dat je eerst zorgt dat je in de tabel “tot dan toe” (je kan dit namelijk ook toepassen op nog meer tabellen dan de 3 uit het voorbeeld) de informatie beschikbaar hebt die je voor de Join nodig hebt. In het in deze tutorial gebruikte voorbeeld heb je om te beginnen dus altijd een Join nodig tussen één van de tabellen met tekstuele informatie (actors of movies) en de koppeltabel.

De informatie die je uit deze query krijgt ziet er als volgt uit:

1 	Eduard Schaarhand 		Angel Jolige 
2 	Tombe rijder 			Angel Jolige 
3 	Zeven jaar in de bergen 	Brador Pittje 
1 	Eduard Schaarhand 		John Depperd 
3	Zeven jaar in de bergen 	John Depperd 
2 	Tombe rijder 			Arno Zwartebesje

Hieronder is schematisch aangegeven welke gegevens met deze “Multiple Join” worden geselecteerd.

Op een paar kleine wijzigingen is dit hoofdstuk gekopieerd uit de vorige tutorial

In de voorgaande stukken van de tutorial hebben we telkens een koppeling gemaakt tussen items van 2 of meer verschillende tabellen. Het is echter ook mogelijk om een join te doen binnen eenzelfde tabel. Dit kan in sommige gevallen zeer handig zijn. Het voorbeeld hieronder heeft niets te maken met het voorbeeld van de coureurs en renstallen.

Stel je hebt een tabel, voor een menu. Daarin heb je een ParentId staan bij de verschillende menu items, om aan te geven dat een item onder een bepaald hoofditem valt. Om nu hier de juiste gegevens uit te krijgen kan je een subquery maken, waarmee je de gegevens aan elkaar koppelt, maar het kan ook gemakkelijker: Met een JOIN
Stel de tabel ziet er zo uit:
id (1,2,3,4,5,6,7,8)
naam -> niet opgegeven, is niet direct van belang
parent (NULL,NULL,NULL,3,3,2,1,2)

Dit kan je realiseren door een outer join toe te passen op 1 tabel. Het lijkt allemaal wat raar, omdat je het in eenzelfde tabel doet, maar zo krijg je een keurig overzicht van je menu:

SELECT
   hoofdmenu.id,
   submenu.parent
FROM
   menu AS hoofdmenu
RIGHT JOIN
   menu AS submenu
ON
   hoofdmenu.id = submenu.parent

De resultaten zien er dan zo uit:

1	NULL
2	NULL
3	NULL
4	3
5	3
6	2
7	1
8	2

Je krijgt nu keurig een lijstje met de gekoppelde waarden terug. Waarbij je alleen de submenu-items te zien krijgt. Door een JOIN toe te passen op 1 tabel kan je, mits je het juist doet keurig het menu op de juiste volgorde ophalen uit de tabel.

Ik hoop dat ik jullie aan de hand van deze wederom verbeterde (dit is versie 3 ondertussen) tutorial duidelijk(er) heb kunnen maken wat de SQL JOINS precies inhouden. Je hebt gezien dat de JOIN in sommige gevallen een prima oplossing bied om de juiste gegevens uit meerdere tabellen te halen.

Door het leren kennen van de JOIN heb je meer kennis van SQL, en zal waarschijnlijk weer meer SQL oplossingen gebruiken voor problemen die je anders met PHP en een 2e query op zou lossen. Natuurlijk zijn er wel altijd uitzonderingen, waarbij een JOIN geen uitkomst zal bieden, en waar je wel een tussenweg met PHP (of een andere scripttaal) zal moeten gebruiken.

Opmerkingen:

Normaliseer je database (staat ook in inleiding, maar dit is erg belangrijk!)
Het is voor het goed functioneren van deze mogelijkheid in SQL heel belangrijk dat je database op een goede manier is opgebouwd. Normalisatie is voor het goed opbouwen van een database een goede methode. Daarom wil ik via hier nog even op deze tutorial wijzen: http://phphulp.nl/php/tutorials/3/150/

Andere mogelijkheden (staat ook in inleiding, maar dit is erg belangrijk!)
Met de JOIN kan je de referentiële integriteit van de database gebruiken, om gekoppelde gegevens uit meerdere tabellen op de juiste manier op te halen. Echter is het geen manier om de referentiële integriteit te waarborgen.
Sommige providers bieden naast de standaard MySQL ook de mogelijkheid om PostgreSQL te gebruiken. Hierin zit een optie om sleutelvelden aan te geven en ook waaraan ze worden gekoppeld.
Wil je hier meer over weten kijk dan even bij deze 2 tutorials:
- http://www.phphulp.nl/php/tutorials/3/334/
- http://www.phphulp.nl/php/tutorials/3/371/

Rest van je query
De rest van de query kan je gewoon op de manier gebruiken zoals je bent gewend. Door een ORDER BY toe te voegen, of een WHERE clausule krijg je alleen de gegevens die je wilt hebben. Het maakt dus voor het vervolg van je query geen verschil of je een JOIN gebruikt of niet!