Prestandaoptimering och frågeoptimering i PostgreSQL · Lektion

TOAST-interna detaljer och lagring av stora värden

Förstå hur PostgreSQL lagrar för stora kolumner och finjustera trösklarna för komprimering och extern lagring.

Lektion 4 av 413 steg

TOAST-interna detaljer och lagring av stora värden är en gratis lektion i Prestandaoptimering och frågeoptimering i PostgreSQL på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Prestandaoptimering och frågeoptimering i PostgreSQL, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Prestandaoptimering och frågeoptimering i PostgreSQL innehåller totalt 4 lektioner.

Varför TOAST finns

PostgreSQL lagrar rader på sidor med fast storlek, 8 KB. En enskild rad kan inte sträcka sig över flera sidor, så ett stort värde (en lång text, stor jsonb eller bytea) skulle annars inte få plats.

TOAST (The Oversized-Attribute Storage Technique) löser detta genom att komprimera för stora kolumner och, om de fortfarande är för stora, dela upp dem i delar som lagras i en separat sidotabell.

Håller huvudraden i heapen liten och cachevänlig.
Gör att ett logiskt värde kan vara mycket större än 8 KB (upp till cirka 1 GB).
Sker automatiskt och transparent för era frågor.

TOAST-tröskeln

TOAST aktiveras när en rads totala storlek skulle överstiga TOAST_TUPLE_THRESHOLD, som som standard är 2 KB (en fjärdedel av sidan på 8 KB).

När gränsen överskrids komprimerar PostgreSQL de största TOAST-hanterbara attributen och/eller flyttar dem utanför raden tills raden ryms under TOAST_TUPLE_TARGET (också cirka 2 KB).

Endast kolumner med variabel längd (text, varchar, jsonb, bytea, arrayer med mera) kan hanteras av TOAST. Typer med fast bredd, som integer eller timestamptz, TOAST-hanteras aldrig.

Hitta TOAST-tabellen

Varje tabell med minst en TOAST-hanterbar kolumn får en tillhörande TOAST-tabell med namnet pg_toast.pg_toast_<oid>. Ni kan hitta den i katalogen.

Kolumnen reltoastrelid kopplar en heap-relation till dess TOAST-relation; värdet 0 betyder att ingen TOAST-tabell har skapats.

SELECT c.relname,
       c.reltoastrelid,
       t.relname AS toast_table
FROM pg_class c
LEFT JOIN pg_class t ON t.oid = c.reltoastrelid
WHERE c.relname = 'documents';

De fyra lagringsstrategierna

Varje kolumn har en lagringsstrategi som styr om den kan komprimeras och/eller flyttas utanför raden:

PLAIN — ingen komprimering och ingen lagring utanför raden; giltig endast för typer som inte kan hanteras av TOAST.
EXTENDED — tillåter både komprimering och lagring utanför raden (standard för de flesta varlena-typer).
EXTERNAL — tillåter lagring utanför raden men ingen komprimering (snabbare åtkomst till delsträngar).
MAIN — tillåter komprimering men behåller värdet i huvudtabellen om det inte är absolut nödvändigt att flytta det.

Granska lagring per kolumn

Fråga pg_attribute.attstorage för att se strategin för varje kolumn. Koderna motsvarar: p=PLAIN, e=EXTERNAL, m=MAIN, x=EXTENDED.

SELECT attname,
       atttypid::regtype AS type,
       CASE attstorage
         WHEN 'p' THEN 'plain'
         WHEN 'e' THEN 'external'
         WHEN 'm' THEN 'main'
         WHEN 'x' THEN 'extended'
       END AS storage
FROM pg_attribute
WHERE attrelid = 'documents'::regclass
  AND attnum > 0
  AND NOT attisdropped;

Ändra en kolumns strategi

Använd ALTER TABLE ... SET STORAGE för att åsidosätta standardvärdet. En vanlig optimering är att byta till EXTERNAL om ni ofta läser slumpmässiga delsträngar ur en stor bytea (till exempel intervalläsningar ur ett blobvärde), så att värdena lagras okomprimerade och delar kan hämtas utan att hela värdet behöver packas upp.

Den nya strategin gäller endast rader som skrivs efter ändringen; befintliga data skrivs inte om förrän de uppdateras.

ALTER TABLE documents
  ALTER COLUMN payload SET STORAGE EXTERNAL;

-- Force a rewrite to apply it to existing rows:
VACUUM FULL documents;

Komprimeringsalgoritmer: pglz jämfört med lz4

PostgreSQL komprimerar TOAST-värden innan lagring utanför raden övervägs. Två algoritmer är tillgängliga:

pglz — den historiska inbyggda algoritmen, med god komprimeringsgrad men lägre hastighet.
lz4 — tillgänglig sedan PostgreSQL 14, med mycket snabbare komprimering och uppackning men något sämre komprimeringsgrad. Kräver att servern har byggts med stöd för lz4.

Standardvärdet för hela klustret anges med default_toast_compression.

SHOW default_toast_compression;

-- Set lz4 cluster-wide (postgresql.conf or per session):
SET default_toast_compression = 'lz4';

Komprimering per kolumn

Från och med PostgreSQL 14 kan ni ange komprimeringsmetod för enskilda kolumner med SET COMPRESSION. Detta är oberoende av lagringsstrategin.

Välj lz4 för ofta använda, stora kolumner där processorbelastningen vid läsning och skrivning är viktig; behåll pglz eller använd EXTERNAL när komprimeringsgrad eller åtkomst till delsträngar är viktigast.

ALTER TABLE documents
  ALTER COLUMN body SET COMPRESSION lz4;

-- Inspect chosen method per column:
SELECT attname, attcompression
FROM pg_attribute
WHERE attrelid = 'documents'::regclass
  AND attnum > 0;

Optimera målet för lagring utanför raden

Reloptionen toast_tuple_target styr hur aggressivt PostgreSQL flyttar attribut utanför raden: den anger vilken storlek huvudtuplen ska krympas mot (giltigt intervall från 128 byte till cirka 8160).

Om värdet sänks flyttas fler värden till TOAST tidigare, vilket håller huvudheapen tätare och förbättrar genomsökningsprestandan när de stora kolumnerna sällan läses. Om värdet höjs behålls mer data inline.

ALTER TABLE documents
  SET (toast_tuple_target = 512);

-- Verify current reloptions:
SELECT reloptions
FROM pg_class
WHERE relname = 'documents';

Mät TOAST-avtrycket

Använd storleksfunktionerna för att skilja byte i huvudtabellen från byte i TOAST. Då ser ni om svällningen finns i heapen eller i de för stora värdena.

pg_table_size — heap + TOAST + deras TOAST-index, exklusive vanliga index.
pg_relation_size(rel, 'main') — endast huvudforken.

SELECT
  pg_size_pretty(pg_relation_size('documents'))        AS heap,
  pg_size_pretty(
    pg_total_relation_size(reltoastrelid)
  )                                                     AS toast,
  pg_size_pretty(pg_total_relation_size('documents'))  AS total
FROM pg_class
WHERE relname = 'documents';

Praktiska prestandakonsekvenser

TOAST märks inte — förrän det gör det. Kom ihåg följande effekter:

Om en TOAST-hanterad kolumn läses krävs extra indexuppslag i TOAST-tabellen och eventuell uppackning — undvik SELECT * när ni bara behöver små kolumner.
Värden förblir TOAST-hanterade vid UPDATE som inte berör dem, så orelaterade uppdateringar är billiga.
EXTERNAL möjliggör effektiva substr()- och intervalläsningar av stora, okomprimerade blobvärden.
Att byta från pglz till lz4 kan minska processorbelastningen vid skrivning kraftigt för arbetsbelastningar med många infogningar av stora värden.

Snabb kontroll

Ni har en tabell vars stora bytea-kolumn oftast läses med substr() över små byteintervall, och läsningarna är långsamma eftersom varje åtkomst packar upp hela värdet. Vilken enskild ändring löser detta bäst?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er hur PostgreSQL hanterar för stora värden:

TOAST aktiveras när en rad skulle överstiga tröskeln på cirka 2 KB, genom att först komprimera och sedan flytta stora varlena-kolumner till pg_toast.*-tabeller.
De fyra strategierna — PLAIN, MAIN, EXTENDED (standard) och EXTERNAL — styr komprimering och placering utanför raden och anges med ALTER TABLE ... SET STORAGE.
lz4 (PG14+) erbjuder snabbare komprimering än pglz; välj per kolumn med SET COMPRESSION eller för hela klustret med default_toast_compression.
toast_tuple_target styr hur ivrigt värden lämnar heapen; storleksfunktionerna visar hur mycket lagring som finns i TOAST.
Välj EXTERNAL för delsträngs- och intervalläsningar, lz4 för stora värden i skrivintensiva arbetsbelastningar och undvik SELECT * för att slippa onödig detoasting.

Gratis att börja

Lär dig SQL med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 22
Lektioner: 88

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”TOAST-interna detaljer och lagring av stora värden” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Prestandaoptimering och frågeoptimering i PostgreSQL, inklusive ”TOAST-interna detaljer och lagring av stora värden”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Prestandaoptimering och frågeoptimering i PostgreSQL innehåller totalt 4 lektioner.

Vad lär jag mig i ”TOAST-interna detaljer och lagring av stora värden”?

Förstå hur PostgreSQL lagrar för stora kolumner och finjustera trösklarna för komprimering och extern lagring. Ni övar på Prestandaoptimering och frågeoptimering i PostgreSQL med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Prestandaoptimering och frågeoptimering i PostgreSQL?

Du behöver inga förkunskaper. Utbildningen i Prestandaoptimering och frågeoptimering i PostgreSQL på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”TOAST-interna detaljer och lagring av stora värden”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Prestandaoptimering och frågeoptimering i PostgreSQL-lektionen?

Ja. Varje Prestandaoptimering och frågeoptimering i PostgreSQL-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Mäta tabell- och indexbloat korrekt
Återvinna utrymme med pg_repack
Finjustera fillfactor för uppdateringstunga tabeller
TOAST-interna detaljer och lagring av stora värden

← Tillbaka till Prestandaoptimering och frågeoptimering i PostgreSQL