Cursus
Gegevens manipuleren in SQL
4 uur
336.7K
SQL Server is een relationeel databasemanagementsysteem. Een van de kernprincipes van een relationele database is dat data over meerdere tabellen wordt opgeslagen.
We moeten tabellen kunnen samenvoegen om de data te halen die we nodig hebben. We gebruiken primary- en foreign-keys om tabellen te joinen.
Primary Key
Een primary key is een kolom die wordt gebruikt om elke rij in een tabel uniek te identificeren. Deze uniciteit kan worden bereikt met een oplopend geheel getal als identity-kolom. Soms bevatten bestaande kolommen van nature al unieke waarden en kunnen die worden gebruikt.
In het onderstaande voorbeeld zie je de eerste paar rijen uit de tabel artist. Die heeft twee kolommen, artist_id en name. De kolom artist_id fungeert als primary key voor deze tabel; het is een integerkolom en elke waarde is anders.
+-----------+-------------------+
| artist_id | name |
|-----------+-------------------|
| 1 | AC/DC |
| 2 | Accept |
| 3 | Aerosmith |
| 4 | Alanis Morissette |
| 5 | Alice In Chains |
+-----------+-------------------+
Nu bekijken we de tabel album. Kun je de primary key aanwijzen? Ja, dat is de kolom album_id. Het is gebruikelijk dat de primary key wordt genoemd als "tabelnaam underscore id". Maar je zal ook hebben gezien dat er een kolom artist_id is. Die bestaat ook uit gehele getallen en heeft dezelfde naam als de kolom artist_id in de tabel artist. Wat betekent dit?
+----------+-------------------------+-----------+
| album_id | title | artist_id |
|----------+-------------------------+-----------|
| 1 | For Those About To Rock | 1 |
| 2 | Balls to the Wall | 2 |
| 3 | Restless and Wild | 2 |
| 4 | Let There Be Rock | 1 |
| 5 | Big Ones | 3 |
+----------+-------------------------+-----------+
Foreign Keys
Uit de vorige output is duidelijk dat de artist_id in de tabel artist fungeert als een Foreign_key naar de tabel album. De FOREIGN KEY-constraint wordt gebruikt om acties te voorkomen die koppelingen tussen tabellen zouden verbreken.
artist-tabel
+-----------+-------------------+
| artist_id | name |
|-----------+-------------------|
| 1 | AC/DC |
| 2 | Accept |
| 3 | Aerosmith |
| 4 | Alanis Morissette |
| 5 | Alice In Chains |
+-----------+-------------------+
album-tabel
+----------+-------------------------+-----------+
| album_id | title | artist_id |
|----------+-------------------------+-----------|
| 1 | For Those About To Rock | 1 |
| 2 | Balls to the Wall | 2 |
| 3 | Restless and Wild | 2 |
| 4 | Let There Be Rock | 1 |
| 5 | Big Ones | 3 |
+----------+-------------------------+-----------+
Dit betekent dat wanneer de artist_id in de tabel album overeenkomt met de artist_id in de tabel artist, die rijen kunnen worden gekoppeld met een JOIN.
Album en Artist joinen
Rijen 1 en 4 van de tabel artist hebben een artist_id van 1. De artist_id 1 in de tabel artist is AC/DC. Dus wanneer we de twee tabellen samenvoegen, krijgen we de albumdetails uit de tabel album en de bijbehorende artiestdetails uit de tabel artist - gekoppeld via het veld artist_id, dat in beide tabellen voorkomt.
Dit staat bekend als een inner join.
SELECT
album_id,
title,
album.artist_id,
name AS artist_name
FROM album
INNER JOIN artist ON artist.artist_id = album.artist_id
WHERE album.artist_id = 1;
+----------+-------------------------+-----------+-------------+
| album_id | title | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1 | For Those About To Rock | 1 | AC/DC |
| 4 | Let There Be Rock | 1 | AC/DC |
+----------+-------------------------+-----------+-------------|
We hebben de tabellen album en artist gejoint door de artist_id uit de tabel artist te matchen met de artist_id in de tabel album.
Als je kolommen met dezelfde naam uit verschillende tabellen selecteert, moet je de kolomnaam volledig kwalificeren. Anders weet SQL Server niet uit welke tabel de kolom moet worden SELECT.
Om een kolom volledig te kwalificeren, voorzie je deze van de relevante tabelnaam, gevolgd door een punt.
Syntax van een inner join
Hier is een generiek voorbeeld om je aan de syntax te herinneren. We selecteren de relevante kolommen uit de hoofdtafel, in dit geval table_A, en vervolgens selecteren we elke extra kolom die we willen joinen, in dit geval uit table_B. Daarna specificeren we de join met de keywords INNER JOIN en ON, met daarbij de benodigde sleutelkolommen uit beide tabellen.
SELECT
table_A.columnX,
table_A.columnY,
table_B.columnZ,
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key;
Geen WHERE-clause gebruiken
In dit voorbeeld specificeren we geen WHERE-clause, dus we krijgen ALLE combinaties van ALLE matches tussen de tabellen artist en album terug, opnieuw gebaseerd op de kolom artist_id, die in beide voorkomt.
SELECT
album_id,
title,
album.artist_id,
name AS artist_name
FROM album
INNER JOIN artist on artist.artist_id = album.artist_id;
+----------+---------------------------------------+-----------+
| album_id | title | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1 | For Those About To Rock | 1 | AC/DC |
| 4 | Let There Be Rock | 1 | AC/DC |
| 2 | Balls To The Wall | 2 | Accept |
| 3 | Restless and Wild | 2 | Accept |
+----------+---------------------------------------+-----------+
Meerdere inner joins
Je kunt ook meer dan twee tabellen joinen met INNER JOINS. Je voegt simpelweg een extra INNER JOIN toe voor elke combinatie van tabellen. In onze code hieronder joinen we tabellen A en B, en ook B en C.
SELECT
table_A.columnX,
table_A.columnY,
table_B.columnZ table_C columnW
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key
INNER JOIN table_C ON table_C.foreign_key = table_B.primary_key;
Wil je meer leren over het joinen van tabellen? Bekijk dan deze video uit onze cursus Introduction to SQL Server.
Deze content is afkomstig uit DataCamp’s cursus Introduction to SQL Server van John MacKintosh.
Onderwerpen
