{"canonical_url":"https://engineer.company/sv/glossary/database-index/","content_markdown":"# Databasindex\n\n## Vad det är\n\nEtt databasindex är en separat struktur, lagrad bredvid en tabell, som låter\ndatabasen gå direkt till de rader som uppfyller ett villkor i stället för att\nläsa tabellen från första till sista raden. I vardagligt tal, och i större delen\nav PostgreSQL-dokumentationen, heter det bara ett index. Dokumentationen jämför\ndet med registret längst bak i en bok: den som letar efter ett ämne slår upp det\ndär och bläddrar direkt till sidorna som anges, i stället för att läsa igenom\nhela boken.\n\nTa en tabell med ordrar och villkoret `WHERE customer_id = 42`. Utan ett index\npå `customer_id` har PostgreSQL bara ett sätt att svara: en sekventiell\nskanning, som läser varenda rad och behåller dem som matchar. Det kostar lika\nmycket oavsett om kunden har två ordrar eller tvåtusen, och kostnaden växer med\ntabellen. Med ett index på kolumnen går PostgreSQL ner några nivåer i ett\nsökträd till posterna för 42 och hämtar bara de raderna. Ett index skapas med en\nenda sats, `DROP INDEX` tar bort det igen, och båda kan göras när som helst.\n\nNär indexet väl finns håller PostgreSQL det i takt med tabellen vid varje\nskrivning, och planeraren avgör från fråga till fråga om det lönar sig att\nanvända det i stället för att skanna. Ingenting i SQL-koden namnger indexet, så\nsamma index kan snabba upp en `SELECT`, en `UPDATE` eller `DELETE` med ett\nsökvillkor och en join.\n\nPostgreSQL har flera sorter, var och en byggd för sin typ av fråga:\n\n- **B-tree** är standard och det som `CREATE INDEX` bygger om inget annat anges.\n  Det besvarar likhet och intervall (`\u003c`, `\u003c=`, `=`, `\u003e=`, `\u003e`), `BETWEEN`,\n  `IN`, `IS NULL` och en `LIKE` där mönstret är förankrat i början. Det håller\n  posterna sorterade och kan därför också leverera raderna i ordning.\n- **Hash** lagrar en 32-bitars hashkod för varje värde och besvarar bara likhet.\n- **GiST** och **SP-GiST** är ramverk för data som geometri, där frågan är\n  ”överlappar”, ”innehåller” eller ”närmast” snarare än ”är lika med”.\n- **GIN** är ett inverterat index för värden som består av många delar, till\n  exempel arrayer, och hittar de rader vars värde innehåller ett visst element.\n- **BRIN** lagrar bara en sammanfattning för varje intervall av tabellblock. Det\n  passar en kolumn där värdena följer radernas fysiska ordning, som en\n  tidsstämpel för insättningen ofta gör.\n\nUtöver typen kan ett index formas efter frågan. Ett unikt index avvisar\ndubbletter. Ett sammansatt index täcker flera kolumner, upp till 32. Ett\npartiellt index har en `WHERE`-klausul och innehåller bara de rader som\nuppfyller den. Ett uttrycksindex lagrar ett beräknat värde som `lower(email)`.\nOch en `INCLUDE`-lista tar med extra kolumner i indexet utan att söka på dem, så\natt en SQL-fråga kan besvaras från indexet ensamt.\n\n## Varför det spelar roll\n\nSkillnaden ett index gör växer med tabellen. På en liten tabell är en skanning\nbillig, och planeraren väljer ofta, med rätta, just den: att läsa en handfull\nsidor i ordning kostar mindre än att gå igenom ett träd för att nå dem. Med\ntiotals miljoner rader är skillnaden mellan en skanning och ett uppslag\nskillnaden mellan en sida som laddas och en som får timeout. En SQL-fråga som\nvar snabb vid lanseringen kan bli långsam ett år senare utan att en enda kodrad\nhar ändrats, bara för att tabellen den läser har vuxit.\n\nIndex är inte gratis, och notan kommer vid skrivning. Varje insättning lägger\ntill en post i varje index på tabellen. En uppdatering kan bara slippa undan som\nen heap-only tuple-uppdatering (HOT), där den nya radversionen stannar på samma\nsida och inte behöver några nya indexposter, och det tillåter PostgreSQL bara\nnär uppdateringen inte ändrar någon kolumn som tabellens index använder.\nBRIN-index räknas inte, eftersom de bara lagrar en sammanfattning. Varje index\ngör alltså den billiga vägen smalare, och därför råder dokumentationen till att\nta bort index som sällan eller aldrig används. En tabell med ett dussin index\nbetalar ett dussin gånger vid varje insättning.\n\nDet kostar också att bygga ett index. En vanlig `CREATE INDEX` låter andra\nsessioner läsa tabellen men blockerar skrivningar till den tills bygget är\nklart, och dokumentationen varnar för att det på en mycket stor tabell kan ta\nmånga timmar.\n\nTill sist är ett index bara så bra som planerarens beslut att använda det, och\nplaneraren arbetar utifrån statistik som `ANALYZE` har samlat in. Frågan att\nställa är inte ”finns det ett index?” utan ”används det av de SQL-frågor som\nspelar roll?”, och `EXPLAIN` är sättet att ta reda på det.\n\n## Så ser det ut i praktiken\n\nKontosidan i en webbutik visar en kunds tjugo senaste ordrar:\n\n```sql\nSELECT id, created_at, total\nFROM   orders\nWHERE  customer_id = 42\nORDER  BY created_at DESC\nLIMIT  20;\n```\n\nMed bara en primärnyckel på `id` måste PostgreSQL läsa hela `orders`, behålla\nkundens rader, sortera dem och kasta alla utom tjugo. `EXPLAIN` visar det: en\n`Seq Scan` på `orders` med villkoret som `Filter` och en sortering ovanpå.\n`EXPLAIN ANALYZE` kör dessutom frågan och skriver ut de faktiska radantalen och\ntiderna bredvid uppskattningarna.\n\nDet index som passar frågan har likhetskolumnen först och sorteringskolumnen\ndärefter:\n\n```sql\nCREATE INDEX CONCURRENTLY orders_customer_created_idx\nON orders (customer_id, created_at);\n```\n\nKör `EXPLAIN` igen så blir skanningen en indexskanning med\n`orders_customer_created_idx`, där `customer_id = 42` nu står som `Index Cond` i\nstället för som filter. Sorteringen försvinner också. Ett B-trädindex håller\nposterna för kund 42 ordnade efter `created_at`, PostgreSQL kan läsa dem\nbaklänges för att få de nyaste först, och med `LIMIT` slutar det efter tjugo\nposter utan att röra resten.\n\nKolumnernas ordning spelar roll. Samma index klarar en fråga på enbart\n`customer_id`, eftersom det är den första kolumnen, men en rapport över alla\ngårdagens ordrar som bara filtrerar på `created_at` får betydligt mindre ut av\ndet. I ett sammansatt B-trädindex är det likhet på de första kolumnerna plus ett\nintervall på nästa som avgränsar den del av indexet som läses. PostgreSQL 18 kan\ngöra skip scan och upprepa sökningen en gång för varje distinkt värde i den\nförsta kolumnen, men planeraren väljer vanligtvis det bara när den kolumnen har\nfå distinkta värden, och kund-id:n finns det många av. Spelar rapporten roll får\nden ett eget index på `created_at`. Omvänt, som `(created_at, customer_id)`,\nskulle kund 42:s ordrar hamna utspridda över hela indexet.\n\nAnteckningen om\n[att optimera databasen innan du shardar den](/sv/notes/optimise-before-you-shard/)\nsätter index först bland förbättringarna den rangordnar efter vad de ger för\ninsatsen, när planerna har pekat ut skanningarna som en prestandakritisk SQL-fråga kör.\nAnteckningens eget exempel är ett partiellt index, `units_unsold`, som bara\ninnehåller de enheter som fortfarande är till salu, så att det krymper medan en\nrea pågår i stället för att växa. Anteckningen räknar också ut priset. På\ntabellen där var alla 2000 reservationer som satte `reserved`, `reserved_at` och\n`order_id` HOT-uppdateringar, medan ingen av 2000 uppdateringar som satte\n`sold`, en kolumn som det partiella indexet läser, var det. Rådet är att ta bort\nde index vars `idx_scan` i `pg_stat_user_indexes` blir stående på noll.\n\nFallstudien om [ett bättre val av\nnyckel](/sv/portfolio/quicker-answers-from-a-better-choice-of-key/) visar varför\nvärdena som hamnar i ett B-trädindex betyder lika mycket som kolumnerna.\nSlumpmässiga UUID:n sprider insättningarna över indexet, vilket kan orsaka\nfragmentering. Plattformen gjorde tidsordnade UUID v7 till standard för\nentiteternas primärnycklar, med en tidsstämpel i de inledande bitarna så att nya\nidentifierare får en tidsordning. Minskad fragmentering och snabbare\ndatabasfrågor var designmål; det dokumenterade resultatet är den konfigurerade\nnyckelkonventionen, och fallstudien ger inte belägg för ett prestandatest av en\narbetslast med mätningar före och efter.\n\n## Var det går fel\n\n**Ett nytt index stoppar skrivningarna till tabellen.** En vanlig `CREATE INDEX`\npå en upptagen tabell blockerar insättningar, uppdateringar och borttagningar\nunder hela bygget, och en rutinmässig driftsättning blir ett avbrott. Använd\n`CREATE INDEX CONCURRENTLY`: det skannar tabellen två gånger och väntar på\ntransaktioner som skulle kunna använda indexet, så det tar betydligt längre tid,\nmen skrivningarna fortsätter. Det kan inte köras inuti ett transaktionsblock, så\nett migreringsverktyg som lägger varje steg i ett sådant måste få veta att just\nden här satsen ska köras för sig. Bara ett samtidigt bygge kan köras på en\ntabell åt gången.\n\n**Ett samtidigt bygge misslyckas och lämnar ett ogiltigt index efter sig.** Ett\ndeadlock, eller ett dubblettvärde medan ett unikt index byggs, får\n`CREATE INDEX CONCURRENTLY` att misslyckas, men det påbörjade indexet ligger\nkvar i katalogen, markerat som ogiltigt. SQL-frågor ignorerar det, men varje\nskrivning betalar ändå för att underhålla det, och ett ogiltigt unikt index kan\nfortsätta att upprätthålla unikhet. `\\d` i psql visar det med `INVALID` efter\ndefinitionen. Ta bort det och kör det samtidiga bygget igen, eller bygg om det\nmed `REINDEX INDEX CONCURRENTLY`.\n\n**Frågan gömmer kolumnen inuti en funktion.** Ett index på `email` gör ingenting\nför `WHERE lower(email) = 'ana@example.com'`, eftersom indexet innehåller\n`email`, inte `lower(email)`. Indexera uttrycket som frågan använder:\n\n```sql\nCREATE INDEX users_lower_email_idx ON users (lower(email));\n```\n\nUttrycket beräknas vid varje insättning och varje uppdatering som inte är HOT,\noch därför rekommenderar dokumentationen uttrycksindex där snabba uppslag\nbetyder mer än snabba skrivningar.\n\n**Det samlas index som ingen använder.** Varje index som lagts till ”för\nsäkerhets skull” kostar vid varje skrivning och kan stänga vägen för\nHOT-uppdateringar. `pg_stat_user_indexes` räknar skanningarna som startats på\nvarje index i `idx_scan` och noterar tiden för den senaste i `last_idx_scan`:\n\n```sql\nSELECT relname, indexrelname, idx_scan, last_idx_scan\nFROM   pg_stat_user_indexes\nWHERE  idx_scan = 0\nORDER  BY relname;\n```\n\nTitta efter innan du tar bort något. Ett index bakom en primärnyckel eller en\nunik begränsning gör sitt jobb oavsett om en SQL-fråga någonsin läser det, och\nen nolla säger lite på en server som nyss har börjat ta emot trafik.\n\n**Planeraren förbiser ett bra index.** Efter en stor inläsning släpar\nstatistiken efter datan, uppskattningarna slår fel och en skanning vinner på\npapperet. Kör `ANALYZE`; dokumentationen kallar det lönlöst att bedöma\nindexanvändning utan det. Testa också på realistiska volymer: på hundra rader\nsom ryms på en enda disksida slår inget index att läsa den sidan. Vill du veta\nom ett index över huvud taget kan användas sätter du `enable_seqscan = off` i en\ntestsession och kör `EXPLAIN` igen. Skannar planen fortfarande matchar villkoret\ninte indexet.\n\n## Läs mer\n\n- [Indexes: Introduction](https://www.postgresql.org/docs/current/indexes-intro.html)\n  — vad ett index är till för, hur det skapas och tas bort, och vad det kostar\n  vid varje skrivning.\n- [Index Types](https://www.postgresql.org/docs/current/indexes-types.html) —\n  B-tree, Hash, GiST, SP-GiST, GIN och BRIN, och vilka operatorer var och en kan\n  besvara.\n- [Multicolumn Indexes](https://www.postgresql.org/docs/current/indexes-multicolumn.html)\n  — hur kolumnernas ordning avgör vad ett B-trädindex kan avgränsa, och när skip\n  scan kommer in.\n- [CREATE INDEX](https://www.postgresql.org/docs/current/sql-createindex.html) —\n  hela syntaxen, bland annat `CONCURRENTLY`, `INCLUDE`, partiella index och hur\n  man städar upp efter ett ogiltigt bygge.\n- [Using EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html) —\n  att läsa en plan: skanningstyper, uppskattade kostnader och de faktiska\n  siffrorna från `EXPLAIN ANALYZE`.\n- [Examining Index Usage](https://www.postgresql.org/docs/current/indexes-examine.html)\n  — varför `ANALYZE` och riktiga data kommer först, och hur man testar om ett\n  index kan användas.\n\n\u003chttps://engineer.company/sv/glossary/database-index/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur ett databasindex gör en skanning till ett uppslag: indextyperna i PostgreSQL, priset vid varje skrivning och hur du ser att det faktiskt används.","formats":{"gemtext":"https://engineer.company/sv/glossary/database-index/index.gmi","gopher":"https://engineer.company/sv/glossary/database-index/gophermap","html":"https://engineer.company/sv/glossary/database-index/","json":"https://engineer.company/sv/glossary/database-index/index.json","markdown":"https://engineer.company/sv/glossary/database-index/index.md","pdf":"https://engineer.company/sv/glossary/database-index/index.pdf"},"kind":"page","language":"sv","title":"Vad är ett databasindex?","url":"https://engineer.company/sv/glossary/database-index/","version":1}