PostgreSQL understøtter arraykolonner — en enkelt kolonne kan indeholde flere værdier af samme type. Dette er en særegen PostgreSQL-funktion, der er brugbar til at lagre lister (tags, roller, scores) uden en separat tabel, med operatorer og funktioner til forespørgsler.
posts (
id SERIAL ,
title TEXT,
tags TEXT[]
);
posts (title, tags)
(, [, ]),
(, );
Syntaksen type[] erklærer en arraykolonne. Du indsætter med ARRAY[...] eller '{...}' litteralsyntaks.
-- 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
Operatorer som ANY (indeholder en værdi), @> (indeholdenhed) og && (overlapning), plus funktioner som unnest (udvid til rækker) og array_agg (samling af rækker til et array), gør arrays forespørgselsbare.
-- 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.
Arraykodolonner er en særegen og brugbar PostgreSQL-funktion, og at forstå dem er værdifuldt både for at udnytte PostgreSQL's muligheder og for at træffe fornuftige designbeslutninger.
Arrays lader dig lagre flere værdier i en enkelt kolonne (tags, roller, lister) uden en separat tabel — bekvemt for simple lister, der er tæt forbundet med en række.
At forstå, hvordan du definerer, indsætter og især forespørger arrays (operatorer som ANY til medlemskab, @> til indeholdenhed, && til overlapning og funktioner som unnest til at udvide arrays til rækker) er nødvendigt for at bruge dem effektivt, og at vide, at GIN-indekser gør arrayforespørgsler effektive, er vigtig for ydeevne.
Ligeså vigtig er designdommeægtelsen om, hvornår man skal bruge arrays i forhold til en normaliseret relateret tabel: arrays er bekvemme for simple lister, du ikke behøver at forespørge, sammenfatte eller vedligeholde relationelt, men de kan overtræde normaliseringsprincipperne og blive vanskelige, når du har brug for at forespørge individuelle værdier, sammenkoble dem eller styre en kompleks/stor liste — i så fald er en separat relateret tabel det bedre, normaliserede valg.
At forstå denne afvejning (arrays for bekvemmelighed med simple koblede lister, separate tabeller for relationelt-styret data) afspejler fornuftig designdommeægtelse.
Da arrays er en brugbar, særegen PostgreSQL-funktion, der kan forenkle visse designs (undgå en joinforbindelsestabel for simple lister) men kan misbruges (denormalisering af data, der burde være relationelt), er det værdifuldt, praktisk relevant viden at forstå arraykolonner — hvordan man definerer, forespørger og indekserer dem, og afgørende hvornår de er passende i forhold til, hvornår en normaliseret tabel er bedre — for at designe PostgreSQL-skemaer, der bruger det rigtige udgangspunkt for hver slags multi-værdiert data.