Planknooppunten interpreteren
Leer veelvoorkomende planknooppunten te ontcijferen, zoals sequential scans, index scans, jointypen en sorteringen.
Planknooppunten interpreteren is een gratis Prestaties en queryoptimalisatie in PostgreSQL-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Prestaties en queryoptimalisatie in PostgreSQL. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Prestaties en queryoptimalisatie in PostgreSQL bevat in totaal 4 lessen.
Queryplannen ontcijferen
Welkom terug! In de vorige les hebt u geleerd hoe u EXPLAIN gebruikt om het uitvoeringsplan van een query te bekijken. Nu gaan we dieper in op het interpreteren van de verschillende 'knooppunten' in deze plannen.
Elk knooppunt staat voor een specifieke bewerking die PostgreSQL uitvoert. Als u deze begrijpt, kunt u prestatieknelpunten identificeren.
Wat zijn planknooppunten?
Zie een queryplan als een boom, waarbij elke tak en elk blad een 'knooppunt' is. Deze knooppunten vertellen u:
- Welke bewerking wordt uitgevoerd (bijvoorbeeld scannen, sorteren of koppelen).
- Hoe deze wordt uitgevoerd (bijvoorbeeld sequentieel of met een index).
- Kostenschattingen: hoeveel tijd en resources PostgreSQL naar verwachting voor de bewerking nodig heeft.
We bekijken de meest voorkomende en belangrijkste typen knooppunten.
Sequential Scan: de volledige tabel lezen
Een Sequential Scan (vaak een 'Seq Scan' genoemd) betekent dat PostgreSQL elke rij in een tabel van begin tot eind leest om de benodigde gegevens te vinden.
- Wanneer dit gebeurt: bij kleine tabellen of wanneer u een groot deel van een tabel opvraagt zonder geschikte index.
- Prestatie-impact: dit kan traag zijn voor grote tabellen, vooral als er maar een paar rijen nodig zijn.
Het is alsof u elke pagina van een boek doorzoekt om één zin te vinden.
Voorbeeld van een Seq Scan
Laten we een sequentiële scan in actie bekijken. We maken een eenvoudige tabel en voeren er vervolgens een query op uit zonder index.
CREATE TABLE products (
product_id SERIAL PRIMARY KEY,
name VARCHAR(100),
price DECIMAL(10, 2)
);
INSERT INTO products (name, price) VALUES
('Laptop', 1200.00),
('Mouse', 25.00),
('Keyboard', 75.00),
('Monitor', 300.00);
EXPLAIN SELECT * FROM products WHERE price > 100;Index Scan: gericht zoeken
Een Index Scan is veel efficiënter. PostgreSQL gebruikt een index om snel de specifieke benodigde rijen te vinden, net zoals u de index van een boek gebruikt.
- Wanneer dit gebeurt: wanneer een query een
WHERE-clausule gebruikt op een geïndexeerde kolom en de index selectief genoeg is. - Prestatie-impact: doorgaans veel sneller dan een sequentiële scan voor selectieve queries op grote tabellen.
Hierdoor kan PostgreSQL rechtstreeks naar de relevante gegevenspagina's springen.
Voorbeeld van een Index Scan
Nu voegen we een index toe aan onze tabel products en bekijken we de verandering in het queryplan.
CREATE INDEX idx_products_price ON products (price);
EXPLAIN SELECT * FROM products WHERE price > 100;Sort-knooppunt: gegevens ordenen
Het knooppunt Sort verschijnt wanneer PostgreSQL gegevens moet ordenen, meestal voor een ORDER BY- of GROUP BY-clausule, en er geen index is die de gegevens in de vereiste volgorde kan leveren.
- Wanneer dit gebeurt: bij een expliciete
ORDER BYof impliciet bij bepaalde bewerkingen, zoalsGROUP BYof unieke beperkingen. - Prestatie-impact: sorteren kan veel CPU en I/O gebruiken, vooral voor grote gegevensverzamelingen.
Als het sorteren 'op schijf' gebeurt (omdat het niet in het geheugen past), wordt het nog trager.
Voorbeeld van een Sort-knooppunt
Hier ziet u een voorbeeld waarin PostgreSQL de resultaten moet sorteren omdat er geen index voor de sorteerkolom bestaat.
EXPLAIN SELECT name, price FROM products ORDER BY name DESC;Join-knooppunten: tabellen combineren
Wanneer u twee of meer tabellen koppelt, gebruikt PostgreSQL specifieke Join-knooppunten om de gegevens te combineren. Er zijn drie hoofdtypen:
- Nested Loop Join: vaak geschikt voor kleine innerlijke tabellen of wanneer er een index beschikbaar is.
- Hash Join: efficiënt voor grotere tabellen wanneer er geen bruikbare index op de koppelingssleutel aanwezig is.
- Merge Join: vereist dat beide invoerwaarden op de koppelingssleutel zijn gesorteerd en voegt ze vervolgens samen.
De keuze hangt af van de tabelgrootte, beschikbare indexen en gegevensverdeling.
Voorbeeld van een Nested Loop Join
Laten we nog een tabel maken en deze vervolgens koppelen aan products om een Nested Loop Join te bekijken. Dit gebeurt vaak wanneer een kant van de koppeling klein is.
CREATE TABLE orders (
order_id SERIAL PRIMARY KEY,
product_id INT,
quantity INT
);
INSERT INTO orders (product_id, quantity) VALUES
(1, 1),
(2, 2),
(1, 3);
EXPLAIN SELECT p.name, o.quantity
FROM products p JOIN orders o ON p.product_id = o.product_id
WHERE o.order_id = 2;Het scantype identificeren
Bekijk de volgende query en het fragment van het uitvoeringsplan. Welk type scan wordt waarschijnlijk uitgevoerd op de tabel customers?
EXPLAIN SELECT * FROM customers WHERE age > 30;
Gedeeltelijke planuitvoer (ga ervan uit dat er geen index op age staat):
-> Seq Scan on customers (cost=0.00..10.50 rows=3 width=...)Samenvatting: planknooppunten ontcijferen
U hebt een grote stap gezet in het begrijpen van de prestaties van PostgreSQL door te leren hoe u belangrijke planknooppunten interpreteert.
- Sequential Scan: volledige tabel lezen; kan traag zijn voor grote tabellen.
- Index Scan: gebruikt een index voor gerichte toegang tot rijen; sneller voor selectieve queries.
- Sort: treedt op wanneer gegevens moeten worden geordend en er geen geschikte index bestaat.
- Join-knooppunten: (Nested Loop, Hash, Merge) combineren gegevens uit meerdere tabellen; de keuze is gebaseerd op gegevensgrootte en indexen.
In de volgende les gebruiken we deze kennis om echte prestatieknelpunten te identificeren.
Leer SQL met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 22
- Lessen
- 88
Veelgestelde vragen
Is de les “Planknooppunten interpreteren” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Prestaties en queryoptimalisatie in PostgreSQL, waaronder “Planknooppunten interpreteren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Prestaties en queryoptimalisatie in PostgreSQL bevat in totaal 4 lessen.
Wat leer ik in “Planknooppunten interpreteren”?
Leer veelvoorkomende planknooppunten te ontcijferen, zoals sequential scans, index scans, jointypen en sorteringen. Je oefent met Prestaties en queryoptimalisatie in PostgreSQL door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Prestaties en queryoptimalisatie in PostgreSQL te beginnen?
Ervaring vooraf is niet nodig. Prestaties en queryoptimalisatie in PostgreSQL op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Planknooppunten interpreteren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Prestaties en queryoptimalisatie in PostgreSQL?
Ja. Elke les over Prestaties en queryoptimalisatie in PostgreSQL bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Inleiding tot EXPLAIN en ANALYZE
- Planknooppunten interpreteren
- Prestatieknelpunten identificeren
- EXPLAIN-kostenramingen en aantallen rijen lezen