PostgreSQL ondersteunt arraykolommen — een enkele kolom kan meerdere waarden van hetzelfde type bevatten. Dit is een onderscheidend PostgreSQL-kenmerk dat nuttig is voor het opslaan van lijsten (tags, rollen, scores) zonder een aparte tabel, met operators en functies voor het opvragen.
posts (
id SERIAL ,
title TEXT,
tags TEXT[]
);
posts (title, tags)
(, [, ]),
(, );
De type[]-syntaxis declareert een arraykolom. Je voegt in met ARRAY[...] of '{...}'-literaalsyntaxis.
-- ANY — does the array contain a value?
SELECT * FROM posts WHERE 'ruby' = ANY(tags);
-- @> containment — does the array contain ALL of these?
SELECT * FROM posts WHERE tags @> ARRAY['ruby', 'web'];
-- && overlap — do the arrays share ANY element?
SELECT * FROM posts WHERE tags && ARRAY['tech', 'news'];
-- access by index (1-based!) and length
SELECT tags[1], array_length(tags, 1) FROM posts;
-- unnest — expand an array into rows
SELECT id, unnest(tags) AS tag FROM posts; -- one row per tag
Operators zoals ANY (bevat een waarde), @> (inbegrepen), en && (overlap), plus functies zoals unnest (uitbreiden naar rijen) en array_agg (rijen samenvoegen in een array), maken arrays opvraagbaar.
-- a GIN index makes array containment/membership queries fast
CREATE INDEX idx_posts_tags ON posts USING GIN (tags);
-- now WHERE tags @> ARRAY['ruby'] uses the index
✓ USE for: simple lists tightly coupled to the row (tags, roles, a few scores)
where you don't need to query/join the individual values much
✗ AVOID when: you need to query, join, or maintain the values relationally,
or the list is large/complex → a separate related table (normalized) is better
→ Arrays are convenient but can violate normalization; use them judiciously.
Arraykolommen zijn een onderscheidend en nuttig PostgreSQL-kenmerk, en het begrijpen ervan is waardevol zowel voor het benutten van PostgreSQL-mogelijkheden als voor het nemen van solide ontwerpbeslissingen.
Arrays stellen je in staat om meerdere waarden in een enkele kolom op te slaan (tags, rollen, lijsten) zonder een aparte tabel — handig voor eenvoudige lijsten die nauw aan een rij gekoppeld zijn.
Begrijpen hoe je arrays definiëert, invoegt, en vooral opvraagt (operators zoals ANY voor lidmaatschap, @> voor inbegrepen, && voor overlap, en functies zoals unnest om arrays in rijen uit te breiden) is noodzakelijk om ze effectief te gebruiken, en weten dat GIN-indexen arrayquery's efficiënt maken is belangrijk voor prestaties.
Evenals belangrijk is de ontwerpafweging van wanneer je arrays gebruikt versus een genormaliseerde gerelateerde tabel: arrays zijn handig voor eenvoudige lijsten die je niet hoeft op te vragen, samen te voegen, of relationeel te beheren, maar ze kunnen normaalbeginselen schenden en ongemakkelijk worden wanneer je afzonderlijke waarden moet opvragen, erop moet samenvoegen, of een complexe/grote lijst moet beheren — in dat geval is een aparte gerelateerde tabel de betere, genormaliseerde keuze.
Begrijpen van deze afweging (arrays voor gemak met eenvoudige gekoppelde lijsten, aparte tabellen voor relationeel beheerde gegevens) weerspiegelt gezond ontwerpinzicht.
Omdat arrays een nuttig, onderscheidend PostgreSQL-kenmerk zijn dat bepaalde ontwerpen kan vereenvoudigen (een jointabel voor eenvoudige lijsten vermijden) maar misbruikt kan worden (het denormaliseren van gegevens die relationeel zouden moeten zijn), is het begrijpen van arraykolommen — hoe je ze definiëert, opvraagt en indexeert, en cruciaal wanneer ze geschikt zijn versus wanneer een genormaliseerde tabel beter is — waardevol, praktisch-relevant kennis voor het ontwerpen van PostgreSQL-schema's die de juiste aanpak voor elk soort meerwaardig gegeven gebruiken.