Blind typen oefening: Programmeren in SQL taal

SQL leren en blind typen oefenen vullen elkaar goed aan. SQL-query's zitten vol met haakjes, komma's, operatoren en aanhalingstekens. Kleine fouten, zoals een verkeerd aanhalingsteken of een vergeten puntkomma, kunnen ervoor zorgen dat de hele query niet werkt. Bij het schrijven van SQL is het nuttig om te weten welke delen van de syntaxis gemeenschappelijk zijn voor verschillende databases en welke specifiek zijn. Dit artikel richt zich vooral op PostgreSQL, maar noemt ook MySQL, SQLite en SQL Server waar de syntaxis verschilt.

Wat is kenmerkend aan de SQL-syntaxis?

SQL (Structured Query Language) is een declaratieve taal. In plaats van stap voor stap te beschrijven hoe gegevens worden opgehaald, geef je aan welke gegevens je wilt. Bijna elke instructie begint met een sleutelwoord zoals SELECT, INSERT of UPDATE. De volgorde van de clausules ligt vast: SELECT ... FROM ... WHERE ... GROUP BY ... HAVING ... ORDER BY .... PostgreSQL en MySQL gebruiken dezelfde volgorde, dus als je het in de ene leert, kun je het ook in de andere toepassen.

SELECT id, name
FROM customers
WHERE active = true
ORDER BY created_at DESC;

Veelgebruikte speciale tekens

SQL bevat veel leestekens. Haakjes () worden gebruikt rond functies en voorwaarden. Komma's , scheiden kolommen. Een punt . wordt gebruikt voor schema's en tabelnamen, bijvoorbeeld public.users. Enkele aanhalingstekens '...' markeren tekstwaarden. PostgreSQL gebruikt dubbele aanhalingstekens "..." voor identifiers, terwijl MySQL backticks `...` gebruikt. In SQL Server zie je ook vierkante haken [...]. Oefenen met deze symbolen helpt bij het correct schrijven van query's.

-- Tekstwaarde
SELECT * FROM books WHERE title = 'War and Peace';

-- Identifiers met spaties (PostgreSQL)
SELECT "Order ID", "Customer Name" FROM orders;

Hoofdletters en kleine letters

Volgens conventie worden SQL-sleutelwoorden vaak in hoofdletters geschreven: SELECT, FROM, WHERE. Dit maakt ze beter herkenbaar, maar het is niet verplicht. In PostgreSQL worden niet-geciteerde identifiers automatisch naar kleine letters omgezet, dus MyTable en mytable zijn hetzelfde. In MySQL hangt het gedrag af van het besturingssysteem. Voor oefeningen is het gebruikelijk om sleutelwoorden in hoofdletters te schrijven om de structuur van de query te benadrukken.

Puntkomma en het einde van een instructie

In PostgreSQL eindigt elke instructie meestal met een puntkomma ;. Het vergeten hiervan kan de uitvoering in tools zoals psql blokkeren. MySQL en SQLite zijn soepeler in interactieve modus, maar een puntkomma blijft aanbevolen. Dit kleine teken is vaak de reden dat een query mislukt.

SELECT-query's en joins

Het schrijven van query's betekent vaak het schrijven van joins. PostgreSQL gebruikt INNER JOIN, LEFT JOIN en RIGHT JOIN. Elke join vereist het sleutelwoord ON gevolgd door een conditie. Een ontbrekende spatie of typfout in de conditie maakt de query ongeldig. Oefenen met joins helpt bij de precisie met symbolen zoals = en ..

SELECT c.id, c.name, o.amount
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id
WHERE o.amount > 100;

Functies en expressies

PostgreSQL heeft veel ingebouwde functies zoals COUNT(), SUM() en AVG(). Haakjes zijn altijd verplicht. Datum- en tijdfuncties zoals NOW() of DATE_TRUNC() zijn typisch voor PostgreSQL. MySQL heeft vergelijkbare functies zoals CURDATE() of DATE_FORMAT(). Correct typen vereist aandacht voor underscores, komma's en haakjes.

SELECT DATE_TRUNC('month', created_at) AS month,
       COUNT(*) AS orders
FROM orders
GROUP BY month
ORDER BY month;

INSERT, UPDATE, DELETE

Instructies die gegevens wijzigen bevatten veel leestekens. INSERT gebruikt haakjes en komma's om kolommen en waarden op te sommen. UPDATE gebruikt = gescheiden door komma's. DELETE combineert sleutelwoorden en voorwaarden. Deze structuren zijn bijna identiek in PostgreSQL, MySQL, SQLite en SQL Server, al verschillen de aanhalingstekens.

INSERT INTO users (id, name, email)
VALUES (1, 'Alice', 'a@example.com');

UPDATE users
SET name = 'Bob', email = 'bob@example.com'
WHERE id = 1;

DELETE FROM users WHERE id = 2;

Common Table Expressions (CTE)

PostgreSQL gebruikt vaak CTE's die beginnen met WITH. Ze bevatten veel haakjes en komma's, waardoor ze een goede typeoefening zijn. MySQL en SQLite ondersteunen ze in nieuwere versies, en SQL Server ook. Het correct plaatsen van haakjes is de meest voorkomende fout.

WITH recent_orders AS (
  SELECT * FROM orders WHERE created_at > NOW() - INTERVAL '30 days'
)
SELECT customer_id, COUNT(*) AS order_count
FROM recent_orders
GROUP BY customer_id;

Vensterfuncties

PostgreSQL staat bekend om zijn geavanceerde vensterfuncties. De typische syntaxis OVER (PARTITION BY ... ORDER BY ...) vereist nauwkeurige invoer van haakjes en sleutelwoorden. MySQL en SQL Server ondersteunen ze ook, maar PostgreSQL geldt vaak als referentie.

SELECT customer_id,
       SUM(amount) OVER (PARTITION BY customer_id ORDER BY created_at) AS running_total
FROM payments;

Parameters en placeholders

In applicaties verschillen de placeholders per database. PostgreSQL gebruikt $1, $2, MySQL en SQLite gebruiken ?, en SQL Server gebruikt @p1. Dit zijn kleine symbolen die makkelijk verkeerd worden getypt, maar essentieel zijn.

-- PostgreSQL
SELECT * FROM users WHERE id = $1;

-- MySQL
SELECT * FROM users WHERE id = ?;

Samenvatting

Volgens conventie worden SQL-sleutelwoorden in hoofdletters geschreven, terwijl identifiers klein blijven tenzij geciteerd. PostgreSQL gebruikt dubbele aanhalingstekens voor identifiers, placeholders $n, CTE's en vensterfuncties. MySQL gebruikt backticks en ?-placeholders. SQL Server introduceert vierkante haken en @-parameters. SQLite houdt de syntaxis eenvoudig, maar vereist precisie. Oefenen met SQL-query's verbetert de nauwkeurigheid bij leestekens, sleutelwoorden en symbolen, en focussen op PostgreSQL geeft ervaring met een van de meest gebruikte moderne databases.