SQL-gegevenstypen: essentiële gids voor beginners

Als je net begint met SQL, is het verleidelijk om gegevenstypen te zien als simpele labels. Een kolom slaat óf getallen, óf tekst, óf datums, óf speciale typen op. Maar een gegevenstype is meer dan een label. Het is een set regels die bepaalt wat een waarde in de ogen van de database is.

In de praktijk bepalen gegevenstypen hoe SQL de informatie in je database “begrijpt”. Het is een set instructies die SQL de context geeft om je data correct te lezen, vergelijken en verwerken.

In deze tutorial bekijken we de belangrijkste categorieën van SQL-gegevenstypen en hoe ze zich gedragen in verschillende databasebeheersystemen. Ik moedig je aan om de voorbeelden mee te volgen.

Als je nog niet veel met databasetabellen hebt gewerkt, geeft onze SQL Fundamentals-cursus je een heldere, toegankelijke basis om te begrijpen hoe dit soort datasets zijn opgebouwd.

Wat zijn SQL-gegevenstypen?

Een gegevenstype beschrijft het formaat van je data: welke waarden een kolom kan bevatten, hoe die waarden intern worden opgeslagen en welke bewerkingen er logisch op zijn. 

Je keuze van gegevenstype beïnvloedt dus meer dan alleen het tabelontwerp. Het kan invloed hebben op opslagbehoefte, queryprestaties, sorteergedrag, rekenkundige bewerkingen en zelfs hoe verschillende systemen dezelfde waarde interpreteren.

Hier is een eenvoudige tabel die meerdere typen tegelijk gebruikt:

CREATE TABLE employees (
    id INT,
    name VARCHAR(50),
    start_date DATE,
    active BOOLEAN,
    salary DECIMAL(10, 2)
);Mogelijk gemaakt door

Elke kolom in deze tabel bepaalt welk type data die kan bevatten.

• De kolom id slaat gehele getallen op en geeft elke medewerker een uniek ID.

• De kolom name kan tot 50 tekens tekst bevatten, dus geschikt voor korte namen.

• De kolom start_date is voor kalenderdatums.

• De kolom active slaat true/false-waarden op, zodat je eenvoudig ziet welke medewerkers momenteel actief zijn.

• Tot slot slaat de kolom salary geldbedragen op met een precisie van 10 cijfers, waarvan twee na de decimale punt voor centen.

Samen vormen deze kolommen een gestructureerde tabel die regels afdwingt over welke waarden in elk veld zijn toegestaan. Dat maakt de data voorspelbaarder en makkelijker om mee te werken. 

Laten we hier voorbeelddata aan toevoegen en kijken hoe de resulterende tabel eruit kan zien in PostgreSQL.

INSERT INTO employees (id, name, start_date, active, salary)
VALUES
    (1, 'Alice Johnson', '2025-01-15', TRUE, 55000.00),
    (2, 'Bob Smith', '2024-06-01', FALSE, 62000.50);
    
SELECT *
FROM employees;Mogelijk gemaakt door

Verschillende databasesystemen volgen dezelfde principes, maar verschillen in naamgeving en features. Zo gebruikt SQL Server BIT in plaats van BOOLEAN, en behandelt MySQL BOOLEAN als een klein geheel getal.

Categorieën van SQL-gegevenstypen

Er zijn vier hoofdcategorieën: numeriek, tekenreeks, datum/tijd en speciaal. Laten we ze stuk voor stuk bekijken.

Numerieke gegevenstypen

Numerieke typen slaan gehele getallen of decimalen op. Het specifieke type bepaalt het bereik, de precisie en de opslaggrootte van de waarden. De meest gebruikte typen zijn:

• gehele getallen, zoals INT, SMALLINT en BIGINT, voor integers,

• decimalen, zoals DECIMAL(p, s) en NUMERIC(p, s), voor exacte decimale waarden,

• en floats, zoals FLOAT en DOUBLE, voor benaderende waarden die kleine afrondingsverschillen kunnen introduceren

Laten we een voorbeeldtabel maken om verschillende numerieke typen te demonstreren:

CREATE TABLE products (
    product_id INT,
    price DECIMAL(8, 2),
    measurement FLOAT
);

INSERT INTO products VALUES 
    (1, 19.99, 3.1415),
    (2, 250.56, 2.71828);

SELECT * FROM products;Mogelijk gemaakt door

Zo ziet de uitvoer er uit in tabelvorm:

Zoals je ziet, is de eerste kolom beperkt tot een geheel getal, de tweede tot een decimaal met twee cijfers na de komma en de derde is een drijvende komma met een onbepaald aantal cijfers.

Op het eerste gezicht lijken DECIMAL en FLOAT hetzelfde. Maar er is een belangrijk verschil: DECIMAL slaat een exact getal op met een gespecificeerd aantal decimalen, terwijl FLOAT een benaderende waarde bewaart die per systeem licht kan verschillen. 

Het is belangrijk om decimalen te gebruiken wanneer precisie nodig is en floats alleen te gebruiken als kleine afrondingsfouten acceptabel zijn.

Teken- en stringtypen

Teken(keten)typen slaan tekst op. Er zijn verschillende varianten die verschillen in prestaties en opslag­efficiëntie.

• CHAR(n) is voor tekst met vaste lengte. Handig voor data die altijd even lang is, zoals staatcodes of luchthavenafkortingen.

• VARCHAR(n) is voor tekst met variabele lengte. Handig voor namen, e-mailadressen en andere door gebruikers ingevoerde tekst.

• TEXT en vergelijkbare typen zijn bedoeld voor grote blokken ongestructureerde tekst, zoals blogposts of productbeschrijvingen.

Sommige systemen, zoals SQL Server, ondersteunen zelfs Unicode-tekentypen, zoals NCHAR en NVARCHAR, die nuttig zijn wanneer je data tekst in meerdere schriftsystemen bevat, zoals Latijns, Chinees of Cyrillisch.

Laten we kijken hoe dit eruitziet met een voorbeeldtabel die verschillende stringtypen demonstreert:

CREATE TABLE customers (
    id INT,
    country_code CHAR(2),
    name VARCHAR(100),
    notes TEXT
);

INSERT INTO customers VALUES
    (1, 'US', 'Alice Johnson', 'Preferred contact by email.'),
    (2, 'CA', 'Bob Smith', 'Requires invoice copy for each order.');
    
SELECT * FROM customers;Mogelijk gemaakt door

Zo zou deze tabel er uiteindelijk uitzien. Je ziet de lengteverschillen die in elk stringtype zijn vastgelegd.

Hier zie je dat CHAR(2) een consistente lengte afdwingt, terwijl VARCHAR en TEXT meer flexibiliteit bieden.

Datum- en tijdtypen

Datum- en tijdtypen maken het mogelijk om temporele informatie nauwkeurig op te slaan en te bevragen. Beginners denken soms dat je dit ook met numerieke of stringtypen kunt coderen. Maar dat kan later problemen veroorzaken bij data-analyse. Met specifieke kalendertypen verloopt alles soepeler.

De drie meest gebruikte typen zijn:

• DATE, dat jaar, maand en dag codeert,

• TIME, dat uur, minuut en seconde opslaat,

• en DATETIME of TIMESTAMP, die datum en tijd combineren.

Moderne databases ondersteunen zelfs fracties van seconden of tijdzone-bewuste typen, zoals TIMESTAMPTZ in PostgreSQL, dat tijdstempels in UTC opslaat en ze bij het ophalen automatisch converteert naar de tijdzone van je sessie.

Laten we een eenvoudige tabel maken om deze temporele typen te demonstreren:

CREATE TABLE events (
    event_id INT,
    event_date DATE,
    start_time TIME,
    created_at DATETIME
);

INSERT INTO events VALUES
    (1, '2025-11-26', '09:30:00', '2025-11-20 14:15:00'),
    (2, '2025-12-01', '18:45:30', '2025-11-21 09:00:00');
    
SELECT * FROM events;Mogelijk gemaakt door

Zo zou de tabel eruitzien:

Je ziet hoe de keuze voor het juiste datum- of tijdstempeltype bepaalt welk soort gegevens je kunt opslaan.

Booleans en andere speciale typen

Niet alle data past netjes in een van de vorige categorieën. Daarvoor bevat SQL speciale typen voor specifieke use-cases. Veelvoorkomende voorbeelden zijn:

• Booleaanse waarden (BOOLEAN, BOOL of BIT, afhankelijk van het systeem) om true/false vast te leggen,

• Binaire data (BLOB) voor afbeeldingen, bestanden of geserialiseerde objecten,

• Grote tekst (CLOB) voor volledige documenten,

• JSON (in MySQL en PostgreSQL) voor schema­loze of geneste data

• ARRAY (alleen in PostgreSQL) voor lijsten

• UUID voor unieke ID’s die niet op numerieke reeksen steunen, zoals een sessietoken of globale trackingcode.

Speciale typen laten je rijkere of flexibelere data opslaan wanneer traditionele tabellen de structuur niet volledig vangen.

SQL-gegevenstypen in verschillende systemen

Databasebeheersystemen verschillen in details van hoe ze deze typen gebruiken. Hoewel de brede categorieën gelijk blijven, variëren de exacte namen en eigenschappen per systeem.

Elk systeem ontwerpt zijn gegevenstypen met eigen prioriteiten, wat hun gedrag verklaart. Soms zijn de verschillen klein, zoals het gebruikte trefwoord. Andere keren verandert het gedrag merkbaar, zoals limieten op tekstlengte, hoe booleans worden opgeslagen of of het systeem gespecialiseerde formaten ondersteunt.

MySQL benadrukt snelheid en eenvoud en gebruikt daarom praktische, lichte keuzes zoals TINYINT (technisch als getallen opgeslagen) voor booleans. Het geeft prioriteit aan prestaties en brede compatibiliteit boven strikte typesemantiek. 

PostgreSQL streeft naar standaardconformiteit en uitbreidbaarheid. Dat zie je terug in het gebruik van een echt BOOLEAN-type en een rijkere set opties, zoals ARRAY en JSONB om gestructureerde of geneste data direct in een kolom op te slaan. 

SQL Server is gericht op voorspelbare prestaties in enterprise-omgevingen en diepe integratie met Microsoft’s ecosysteem. Daarom biedt het sterk gedefinieerde typen zoals BIT voor booleans en VARCHAR(MAX) voor grote tekst. 

De onderstaande tabel geeft een vergelijking van hoe drie grote SQL-systemen veelvoorkomende concepten implementeren.

Wat dit in de praktijk betekent

De achterliggende ontwerpdoelen en de workloads waarvoor systemen zijn geoptimaliseerd, beïnvloeden direct hoe ze werken. 

Deze verschillen betekenen dat veel SQL-vaardigheden goed overdraagbaar zijn, maar details zoals maximale tekstgrootte, auto-increment-trefwoorden of ondersteuning voor complexe structuren kunnen variëren. 

Als je slechts één systeem gebruikt, word je al snel expert in de bijzonderheden ervan. Maar een nieuwe baan of afdeling kan vereisen dat je in een ander DBMS met andere regels duikt. 

Daarom is het bij het leren van SQL handig om de gedeelde concepten achter gegevenstypen te herkennen in plaats van alleen te vertrouwen op de details van één systeem.

Het juiste gegevenstype kiezen

Een gegevenstype kiezen is soms eenvoudig, maar soms vergt het wat denkwerk. Een goede keuze maakt je data makkelijker te bevragen, houdt de opslag compact en voorkomt bugs verderop. De hoofdcategorie wordt meestal bepaald door het soort data dat je hebt. 

Numerieke data

Stel dat je meetgegevens opslaat. Dan wil je uiteraard een numeriek type, geen kalender- of stringtype. Maar hoe precies wil je meten? Zijn gehele getallen oké, of heb je decimalen nodig? Wil je een vast aantal significante cijfers?

Denk vervolgens aan opslag en efficiëntie. Kies het kleinste integertype dat je data veilig kan bevatten om je tabellen efficiënt te houden. Kleinere typen gebruiken minder opslag en kunnen prestaties verbeteren, zeker bij grote tabellen. Meestal kies je een type dat groot genoeg is voor je verwachte bereik zonder ver daarboven te gaan.

Als een integer niet volstaat, kies je tussen DECIMAL en FLOAT. Floating-point-typen benaderen waarden in plaats van ze exact op te slaan, wat afrondingsfouten kan veroorzaken in financiële, wetenschappelijke of andere nauwkeurige toepassingen. 

DECIMAL en NUMERIC slaan exacte waarden op en zijn beter voor alles met prijzen of ratio’s. Wel hebben DECIMALs doorgaans meer opslag nodig dan FLOATs, afhankelijk van het aantal decimalen dat je bewaart.

Teken- en stringdata

Voor strings denk je na over hoe groot elke invoer mag zijn. 

Meestal geef je VARCHAR-velden een realistische lengte in plaats van standaard de maximumlengte. Te ruime limieten vergroten zelden de flexibiliteit en kunnen toekomstige ontwikkelaars misleiden over de verwachte grootte van de data. 

Denk aan je verwachte input—namen, e-mails, producttitels—en kies de kolomlengte dienovereenkomstig.

Datum- en tijddata

Wees precies over wat je bij kalenderdata opslaat. 

Als je alleen een datum of alleen een tijd nodig hebt, gebruik dan liever DATE of TIME dan DATETIME. Dat maakt je intenties duidelijker en verkleint de kans op verwarring later. Het geeft de database ook iets meer ruimte om date-only of time-only queries te optimaliseren.

Booleaanse data

Gebruik waar mogelijk domeinspecifieke typen zoals BOOLEAN in plaats van omwegen zoals integers of strings. Native typen bieden ingebouwde validatie, duidelijkere semantiek en ondersteuning door databasefuncties die specifieke datatypen verwachten.

Hieronder staat een samenvatting van veelvoorkomende opslagdoelen en de aanbevolen SQL-typen om die aan te pakken.

Voor lezers die hun kennis over groeperen en filteren willen opfrissen: de Intermediate SQL-cursus behandelt die kernvaardigheden.

Veelvoorkomende valkuilen en best practices

Zelfs een eenvoudig databaseschema kan problemen krijgen als gegevenstypen niet zorgvuldig zijn gekozen. 

Afkapping

Als je bijvoorbeeld een kolom voor namen hebt die slechts 5 tekens toelaat, eindig je met “Micha” in plaats van “Michael”. Dit is een veelvoorkomend probleem, bekend als afkapping (truncation).

Het duikt vaak op in velden zoals namen, adressen of opmerkingen, waar variatie in de echte wereld een te optimistische limiet overstijgt. Voorkom dit door tekstvelden te dimensioneren op basis van echte voorbeelden of kies iets ruimer.

Afrondingsfouten

Een andere valkuil is onverwachte afronding wanneer floating-pointwaarden worden gebruikt voor geld of andere precieze data. Omdat FLOATs benaderingen opslaan, kunnen kleine afwijkingen zich opstapelen en rapportages of berekeningen beïnvloeden. 

Kies voor alles met valuta of exacte decimalen DECIMAL. Zo blijven de getallen stabiel.

Type-mismatches

Type-mismatches kunnen ook trage queries veroorzaken, vooral bij joins of vergelijkingen.

Als een kolom als string is opgeslagen en een andere als integer (of elk een iets ander type gebruikt) en je probeert te joinen, moet de database mogelijk on-the-fly converteren. Dat kan fouten geven en onnodige overhead toevoegen. 

Door gerelateerde kolommen op elkaar af te stemmen qua type vermijd je deze verborgen conversies en lopen queries soepeler.

Datumopmaak

Kalenderdata heeft zijn eigen uitdagingen. 

Inconsistenties in datumopmaak zijn een belangrijke bron van verwarring wanneer systemen lokale conventies mixen of wanneer ontwikkelaars datums als strings opslaan in plaats van met echte datumtypen. Dat kan queries in de war brengen of onjuiste resultaten opleveren. 

De eenvoudige oplossing is om daadwerkelijke datumtypen te gebruiken en, wanneer je met tekst werkt, een consequente, eenduidige notatie aan te houden. Ik beveel onze Time Series Analysis in SQL Server-cursus aan om de meest voorkomende kalenderproblemen in je databases te vermijden.

Best practices

Enkele best practices om je databases soepel te laten draaien:

• Vul tabellen vroeg in het ontwerpproces met voorbeelddata om zwaktes in grootte- of typekeuzes te ontdekken.

• Documenteer het doel en het verwachte bereik van elke kolom, zodat toekomstige wijzigingen geen mismatches introduceren.

• Vermijd generieke typen als specifiekere typen de duidelijkheid vergroten.

Conclusie

Gegevenstypen bepalen hoe je database de waarden “begrijpt” die je opslaat. Ze beïnvloeden alles van opslag en prestaties tot duidelijkheid. Door te begrijpen hoe ze werken, maak je je databases betrouwbaarder en voorspelbaarder.

Voor verdere verdieping: bekijk de SQL Database Overview Tutorial en SQLite Data Types: A Close Look at Storage Classes. Ik raad ook de PostgreSQL Summary Stats and Window Functions-cursus aan, die laat zien hoe je voortschrijdende totalen en geordende statistieken berekent.

Een gegevenstype in SQL definieert welk soort data een kolom kan opslaan en hoe die data zich gedraagt bij bevragen of verwerken. Het beïnvloedt opslag, validatie, sorteren, vergelijken en rekenkundige bewerkingen.