JOIN: koppla ihop tabeller

En bra databas sparar varje sak på ett ställe. Byns namn står i tabellen village, inte i varje persons rad. Det gör att du kan byta namn på en by på ett enda ställe.

Men det betyder också att svaret på en enkel fråga, som “vilken by bor Anna i?”, ligger utspritt över två tabeller. JOIN sätter ihop bitarna igen.

Exemplen använder övningsdatan.

Två tabeller, en nyckel

person.village_id pekar på village.id. Det kallas en främmande nyckel (foreign key), och det är den som gör att tabellerna kan kopplas ihop.

Lägg märke till två saker, för de blir viktiga strax:

• David har NULL och bor ingenstans
• Morotsby har inga invånare

JOIN ... ON

SELECT person.name, village.name
FROM person
JOIN village ON person.village_id = village.id;

På svenska:

Ta varje person, leta upp den by vars id är samma som personens village_id, och sätt ihop dem till en rad.

ON säger hur raderna hör ihop. Eftersom båda tabellerna har en kolumn som heter name skriver du ut tabellnamnet framför: person.name och village.name.

💡 Vart tog David vägen?

Titta på resultatet igen. David är borta, och Morotsby också.

En vanlig JOIN (egentligen INNER JOIN, men INNER kan utelämnas) tar bara med rader som har en match i båda tabellerna. David har NULL och matchar ingen by. Morotsby har ingen som pekar på den.

En JOIN är alltså också ett filter.

Det här är en av de viktigaste sakerna att förstå om SQL. Tänk dig att du letar efter misstänkta och kopplar ihop tre tabeller: personer, körkort och bilar. Den som saknar körkort i registret försvinner tyst ur resultatet. Det är inte ditt WHERE som tog bort personen, det var din JOIN. Och det kan vara precis det du ville, eller precis det du inte ville.

LEFT JOIN: behåll alla till vänster

SELECT person.name, village.name
FROM person
LEFT JOIN village ON person.village_id = village.id;

Alla rader från tabellen till vänster (den som står i FROM) följer med. Saknas en match fylls kolumnerna från den högra tabellen i med NULL. Vill du visa något annat än NULL, t.ex. texten “ingen by”, använder du COALESCE.

Vill du i stället behålla alla byar, även de utan invånare, ställer du village till vänster:

SELECT village.name, person.name
FROM village
LEFT JOIN person ON person.village_id = village.id;

Nu är Morotsby med, med NULL som invånare. David är däremot borta, eftersom han inte matchar någon by.

LEFT JOIN är den du använder mest av de tre sista. En RIGHT JOIN kan alltid skrivas om till en LEFT JOIN genom att byta plats på tabellerna.

Alias

SELECT p.name, v.name AS village
FROM person AS p
JOIN village AS v ON p.village_id = v.id
WHERE v.name = 'Lökby';

p och v är smeknamn för tabellerna. Med två tabeller sparar det lite skrivande. Med fyra eller fem tabeller i samma fråga är det skillnaden mellan läsbart och oläsbart.

Ordet AS är frivilligt för tabellalias, så FROM person p fungerar också.

JOIN tillsammans med GROUP BY

SELECT v.name, COUNT(*) AS invanare, SUM(p.gold) AS guld
FROM person AS p
JOIN village AS v ON p.village_id = v.id
GROUP BY v.name;

Först kopplas tabellerna ihop, sedan läggs raderna i högar per by. Mer om högar på sidan GROUP BY.

Gammal stil och ny stil

Du kommer att stöta på två sätt att skriva samma JOIN.

Gammal stil:

-- Kommatecken i FROM, kopplingen i WHERE
SELECT person.name, village.name
FROM person, village
WHERE person.village_id = village.id;

Modern stil:

-- Kopplingen i ON, filtren i WHERE
SELECT person.name, village.name
FROM person
JOIN village ON person.village_id = village.id;

Båda ger exakt samma resultat. Den gamla stilen finns kvar i mycket äldre kod, så det är bra att kunna läsa den.

Den moderna stilen håller isär hur tabellerna hör ihop och vilka rader du vill ha. Glömmer du kopplingsvillkoret i den gamla stilen får du alla kombinationer av rader, en så kallad kartesisk produkt:

SELECT COUNT(*) FROM person, village;   -- 15

Fem personer gånger tre byar blir femton rader nonsens. Och det kommer inget felmeddelande.

Med den moderna stilen syns det direkt om ON saknas. SQL Server och PostgreSQL vägrar dessutom att köra en JOIN utan ON. SQLite och MySQL kör den, och ger samma femton rader.

Clean Code: JOIN

Så här skriver du JOIN som går att följa.

-- ❌ Kommatecken, inga alias och allt på en rad
select person.name, village.name from person, village where person.village_id = village.id and village.name = 'Lökby'

-- ✅ Varje JOIN på egen rad, och kopplingen skild från filtret
SELECT p.name,
       v.name AS village
FROM person AS p
JOIN village AS v ON p.village_id = v.id
WHERE v.name = 'Lökby';

• JOIN ... ON i stället för kommatecken
• En JOIN per rad, med kopplingen direkt efter
• Korta men begripliga alias: p för person är bra, t1 och t2 är det inte
• Prefixa alla kolumner när det finns mer än en tabell, även när namnet är unikt. Då ser läsaren direkt var varje kolumn kommer ifrån.
• Skriv LEFT JOIN med flit. Fråga dig: ska rader utan match vara med eller inte?

💬 Det här är hur jag brukar skriva JOIN. Har ditt team en annan stil som är lika läsbar? Kör på den.

Vanliga misstag

Sammanfattning

• JOIN ... ON kopplar ihop rader från två tabeller via en nyckel.
• En vanlig JOIN tar bara rader som matchar i båda, så den är också ett filter.
• LEFT JOIN behåller alla rader från tabellen till vänster och fyller i NULL där det saknas match.
• Alias gör långa frågor läsbara.
• Använd JOIN ... ON i stället för kommatecken i FROM.

Övningar

Använd övningsdatan.

🟢 Övning 1: Vem bor var?

Visa varje persons namn tillsammans med namnet på byn personen bor i.

SELECT p.name, v.name AS village
FROM person AS p
JOIN village AS v ON p.village_id = v.id;

🟢 Övning 2: Gurkby

Hur många personer bor i Gurkby? Använd byns namn, inte dess id.

SELECT COUNT(*)
FROM person AS p
JOIN village AS v ON p.village_id = v.id
WHERE v.name = 'Gurkby';

🟡 Övning 3: Spökbyn

Vilken by har ingen invånare alls?

Tips: vilken sorts JOIN behåller rader som saknar match?

SELECT v.name
FROM village AS v
LEFT JOIN person AS p ON p.village_id = v.id
WHERE p.id IS NULL;

🟡 Övning 4: Invånare per by

Visa varje by och hur många som bor där. Alla tre byar ska vara med, även den som saknar invånare.

SELECT v.name, COUNT(p.id) AS invanare
FROM village AS v
LEFT JOIN person AS p ON p.village_id = v.id
GROUP BY v.name;

🔴 Övning 5: Femton rader

Kör den här frågan:

SELECT p.name, v.name
FROM person AS p, village AS v;

Hur många rader blir det? Varför just så många? Skriv sedan om frågan i modern stil så att den bara visar personer tillsammans med byn de faktiskt bor i.

SELECT p.name, v.name
FROM person AS p
JOIN village AS v ON p.village_id = v.id;

Föregående: GROUP BY · Tillbaka till översikten · Nästa: Subquery