{"canonical_url":"https://engineer.company/nb/glossary/database-index/","content_markdown":"# Databaseindeks\n\n## Hva det er\n\nEn databaseindeks er en egen struktur, lagret ved siden av en tabell, som lar\ndatabasen gå rett til radene som oppfyller en betingelse, i stedet for å lese\ntabellen fra første til siste rad. I dagligtale, og i det meste av\nPostgreSQL-dokumentasjonen, heter den bare en indeks. Dokumentasjonen\nsammenligner den med stikkordregisteret bakerst i en bok: den som leter etter\nett emne, slår opp der og blar rett til sidene som står oppført, i stedet for å\nlese gjennom hele boka.\n\nTa en tabell med ordrer og betingelsen `WHERE customer_id = 42`. Uten en indeks\npå `customer_id` har PostgreSQL bare én måte å svare på: en sekvensiell\nskanning, som leser hver eneste rad og beholder dem som passer. Det koster det\nsamme enten kunden har to ordrer eller to tusen, og prisen vokser med tabellen.\nMed en indeks på kolonnen går PostgreSQL noen nivåer ned i et søketre til\noppføringene for 42 og henter bare de radene. En indeks opprettes med én\nsetning, `DROP INDEX` fjerner den igjen, og begge deler kan gjøres når som\nhelst.\n\nNår indeksen først finnes, holder PostgreSQL den i takt med tabellen ved hver\nskriving, og spørringsplanleggeren avgjør fra spørring til spørring om det\nlønner seg å bruke den framfor å skanne. Ingenting i SQL-en navngir indeksen, så\nden samme indeksen kan gjøre en `SELECT` raskere, likeså en `UPDATE` eller\n`DELETE` med en søkebetingelse og en join.\n\nPostgreSQL har flere slags, hver laget for sin type spørsmål:\n\n- **B-tree** er standarden og det `CREATE INDEX` bygger med mindre man ber om\n  noe annet. Den besvarer likhet og intervaller (`\u003c`, `\u003c=`, `=`, `\u003e=`, `\u003e`),\n  `BETWEEN`, `IN`, `IS NULL` og en `LIKE` der mønsteret er forankret i starten.\n  Den holder oppføringene sortert og kan derfor også levere radene i rekkefølge.\n- **Hash** lagrer en 32-biters hashkode for hver verdi og besvarer bare likhet.\n- **GiST** og **SP-GiST** er rammeverk for data som geometri, der spørsmålet er\n  «overlapper», «inneholder» eller «nærmest» snarere enn «er lik».\n- **GIN** er en invertert indeks for verdier som består av mange deler, for\n  eksempel arrayer, og finner radene der verdien inneholder et bestemt element.\n- **BRIN** lagrer bare et sammendrag for hvert intervall av tabellblokker. Den\n  passer for en kolonne der verdiene følger radenes fysiske rekkefølge, slik et\n  innsettingstidspunkt ofte gjør.\n\nI tillegg til typen kan en indeks formes etter spørsmålet. En unik indeks\navviser duplikater. En sammensatt indeks dekker flere kolonner, opptil 32. En\npartiell indeks har en `WHERE`-klausul og inneholder bare radene som oppfyller\nden. En uttrykksindeks lagrer en beregnet verdi som `lower(email)`. Og en\n`INCLUDE`-liste tar med ekstra kolonner i indeksen uten å søke på dem, slik at\nen spørring kan besvares fra indeksen alene.\n\n## Hvorfor det er viktig\n\nForskjellen en indeks gjør, vokser med tabellen. På en liten tabell er en\nskanning billig, og planleggeren velger ofte, med rette, nettopp den: å lese en\nhåndfull sider i rekkefølge koster mindre enn å gå gjennom et tre for å nå dem.\nMed titalls millioner rader er forskjellen mellom en skanning og et oppslag\nforskjellen mellom en side som lastes, og en som får tidsavbrudd. En spørring\nsom var rask ved lansering, kan bli treg et år senere uten at en eneste\nkodelinje er endret, bare fordi tabellen den leser, har vokst.\n\nIndekser er ikke gratis, og regningen kommer ved skriving. Hver innsetting\nlegger til en oppføring i hver indeks på tabellen. En oppdatering kan bare\nslippe unna som en heap-only tuple-oppdatering (HOT), der den nye radversjonen\nblir liggende på samme side og ikke trenger nye indeksoppføringer, og det\ntillater PostgreSQL bare når oppdateringen ikke endrer noen kolonne som\ntabellens indekser bruker. BRIN-indekser regnes ikke med, siden de bare lagrer\net sammendrag. Hver indeks gjør altså den billige veien smalere, og derfor råder\ndokumentasjonen til å fjerne indekser som sjelden eller aldri blir brukt. En\ntabell med et dusin indekser betaler et dusin ganger ved hver innsetting.\n\nDet koster også å bygge en indeks. En vanlig `CREATE INDEX` lar andre økter lese\ntabellen, men blokkerer skriving til den til byggingen er ferdig, og\ndokumentasjonen advarer om at det på en svært stor tabell kan ta mange timer.\n\nTil slutt er en indeks bare så god som planleggerens beslutning om å bruke den,\nog planleggeren arbeider ut fra statistikk som `ANALYZE` har samlet inn.\nSpørsmålet er ikke «finnes det en indeks?», men «bruker spørringene som betyr\nnoe, den?», og `EXPLAIN` er måten å finne det ut på.\n\n## Slik ser det ut i praksis\n\nKontosiden i en nettbutikk viser en kundes tjue siste ordrer:\n\n```sql\nSELECT id, created_at, total\nFROM   orders\nWHERE  customer_id = 42\nORDER  BY created_at DESC\nLIMIT  20;\n```\n\nMed bare en primærnøkkel på `id` må PostgreSQL lese hele `orders`, beholde\nkundens rader, sortere dem og kaste alle unntatt tjue. `EXPLAIN` viser det: en\n`Seq Scan` på `orders` med betingelsen som `Filter` og en sortering over.\n`EXPLAIN ANALYZE` kjører også spørringen og skriver ut de faktiske radantallene\nog tidene ved siden av estimatene.\n\nIndeksen som passer til spørsmålet, har likhetskolonnen først og\nsorteringskolonnen etterpå:\n\n```sql\nCREATE INDEX CONCURRENTLY orders_customer_created_idx\nON orders (customer_id, created_at);\n```\n\nKjør `EXPLAIN` igjen, og skanningen blir en indeksskanning med\n`orders_customer_created_idx`, der `customer_id = 42` nå står som `Index Cond` i\nstedet for som filter. Sorteringen forsvinner også. En B-tree-indeks holder\noppføringene for kunde 42 ordnet etter `created_at`, PostgreSQL kan lese dem\nbaklengs for å få de nyeste først, og med `LIMIT` stopper den etter tjue\noppføringer uten å røre resten.\n\nRekkefølgen på kolonnene betyr noe. Den samme indeksen dekker en spørring på\n`customer_id` alene, fordi det er den første kolonnen, men en rapport over alle\ngårsdagens ordrer som bare filtrerer på `created_at`, får langt mindre ut av\nden. I en sammensatt B-tree-indeks er det likhet på de første kolonnene pluss et\nintervall på den neste som avgrenser den delen av indeksen som blir lest.\nPostgreSQL 18 kan gjøre skip scan og gjenta søket én gang for hver ulik verdi i\nden første kolonnen, men planleggeren velger vanligvis det bare når det er få\nulike verdier der, og kunde-ID-er finnes det mange av. Betyr rapporten noe, får\nden sin egen indeks på `created_at`. Snudd om, som `(created_at, customer_id)`,\nville indeksen spre ordrene til kunde 42 over hele seg.\n\nNotatet om\n[å optimalisere databasen før du sharder den](/nb/notes/optimise-before-you-shard/)\nsetter indekser først blant forbedringene det ordner etter gevinst, når planene\nhar navngitt skanningene en ytelseskritisk spørring kjører. Notatets eget eksempel er en\npartiell indeks, `units_unsold`, som bare inneholder enhetene som fortsatt er\ntil salgs, så den krymper etter hvert som et salg skrider frem, i stedet for å\nvokse. Notatet regner også ut prisen. På tabellen der var alle 2000\nreservasjoner som satte `reserved`, `reserved_at` og `order_id`,\nHOT-oppdateringer, mens ingen av 2000 oppdateringer som satte `sold`, en kolonne\nden partielle indeksen leser, var det. Rådet er å fjerne indeksene der\n`idx_scan` i `pg_stat_user_indexes` blir stående på null.\n\nProsjektgjennomgangen om [et bedre valg av nøkkel](/nb/portfolio/quicker-answers-from-a-better-choice-of-key/) viser hvorfor verdiene som havner i en B-tree-indeks, betyr like mye som kolonnene. Tilfeldige UUID-er sprer innsettinger utover indeksen, noe som kan føre til fragmentering. Plattformen gjorde tidsordnede UUID v7 til standard for primærnøklene til entitetene, med et tidsstempel i de første bitene slik at nye identifikatorer har en tidsrekkefølge. Redusert fragmentering og raskere spørringer var designmål; det dokumenterte resultatet er den konfigurerte nøkkelkonvensjonen, og prosjektgjennomgangen fastslår ingen sammenlignende ytelsesmåling av arbeidslasten før og etter endringen.\n\n## Hvor det går galt\n\n**En ny indeks stopper skrivingen til tabellen.** En vanlig `CREATE INDEX` på en\ntravel tabell blokkerer innsettinger, oppdateringer og slettinger så lenge\nbyggingen varer, og en rutinemessig utrulling blir til nedetid. Bruk\n`CREATE INDEX CONCURRENTLY`: den skanner tabellen to ganger og venter på\ntransaksjoner som kunne bruke indeksen, så den tar betydelig lengre tid, men\nskrivingen fortsetter. Den kan ikke kjøres inne i en transaksjonsblokk, så et\nmigreringsverktøy som pakker hvert steg inn i én, må få beskjed om å kjøre\nakkurat den setningen for seg. Bare én samtidig bygging kan kjøre på en tabell\nom gangen.\n\n**En samtidig bygging feiler og etterlater en ugyldig indeks.** En vranglås,\neller en duplikatverdi under byggingen av en unik indeks, får\n`CREATE INDEX CONCURRENTLY` til å feile, men den påbegynte indeksen blir\nliggende i katalogen, merket som ugyldig. Spørringer ignorerer den, men hver\nskriving betaler fortsatt for å vedlikeholde den, og en ugyldig unik indeks kan\nfortsette å håndheve unikhet. `\\d` i psql viser den med `INVALID` etter\ndefinisjonen. Fjern den og kjør den samtidige byggingen på nytt, eller bygg den\nom med `REINDEX INDEX CONCURRENTLY`.\n\n**Spørringen gjemmer kolonnen inne i en funksjon.** En indeks på `email` gjør\ningenting for `WHERE lower(email) = 'ana@example.com'`, fordi indeksen\ninneholder `email`, ikke `lower(email)`. Indekser uttrykket spørringen bruker:\n\n```sql\nCREATE INDEX users_lower_email_idx ON users (lower(email));\n```\n\nUttrykket beregnes ved hver innsetting og hver oppdatering som ikke er HOT, og\nderfor anbefaler dokumentasjonen uttrykksindekser der raske oppslag betyr mer\nenn rask skriving.\n\n**Det hoper seg opp indekser som ingen bruker.** Hver indeks som er lagt til\n«for sikkerhets skyld», koster ved hver skriving og kan stenge for\nHOT-oppdateringer. `pg_stat_user_indexes` teller skanningene som er startet på\nhver indeks, i `idx_scan` og noterer tidspunktet for den siste i\n`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\nSe nøye etter før du sletter. En indeks bak en primærnøkkel eller en unik\nbegrensning gjør jobben sin enten en spørring noen gang leser den eller ikke, og\nen null sier lite på en server som nettopp har begynt å ta imot trafikk.\n\n**Planleggeren overser en god indeks.** Etter en stor innlasting henger\nstatistikken etter dataene, estimatene bommer, og en skanning vinner på papiret.\nKjør `ANALYZE`; dokumentasjonen kaller det nytteløst å vurdere indeksbruk uten.\nTest også på realistiske mengder: på hundre rader som får plass på én diskside,\nslår ingen indeks det å lese den ene siden. Vil du vite om en indeks i det hele\ntatt kan brukes, setter du `enable_seqscan = off` i en testøkt og kjører\n`EXPLAIN` igjen. Skanner planen fortsatt, passer ikke betingelsen til indeksen.\n\n## Les mer\n\n- [Indexes: Introduction](https://www.postgresql.org/docs/current/indexes-intro.html)\n  — hva en indeks er til, hvordan den opprettes og fjernes, og hva den koster\n  ved hver skriving.\n- [Index Types](https://www.postgresql.org/docs/current/indexes-types.html) —\n  B-tree, Hash, GiST, SP-GiST, GIN og BRIN, og hvilke operatorer hver av dem kan\n  besvare.\n- [Multicolumn Indexes](https://www.postgresql.org/docs/current/indexes-multicolumn.html)\n  — hvordan rekkefølgen på kolonnene avgjør hva en B-tree-indeks kan avgrense,\n  og når skip scan kommer inn.\n- [CREATE INDEX](https://www.postgresql.org/docs/current/sql-createindex.html) —\n  hele syntaksen, blant annet `CONCURRENTLY`, `INCLUDE`, partielle indekser og\n  opprydding etter en ugyldig bygging.\n- [Using EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html) —\n  å lese en plan: skanningstyper, estimerte kostnader og de faktiske tallene fra\n  `EXPLAIN ANALYZE`.\n- [Examining Index Usage](https://www.postgresql.org/docs/current/indexes-examine.html)\n  — hvorfor `ANALYZE` og ekte data kommer først, og hvordan man tester om en\n  indeks kan brukes.\n\n\u003chttps://engineer.company/nb/glossary/database-index/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvordan en databaseindeks gjør en skanning om til et oppslag: indekstypene i PostgreSQL, prisen ved hver skriving og hvordan du ser at den blir brukt.","formats":{"gemtext":"https://engineer.company/nb/glossary/database-index/index.gmi","gopher":"https://engineer.company/nb/glossary/database-index/gophermap","html":"https://engineer.company/nb/glossary/database-index/","json":"https://engineer.company/nb/glossary/database-index/index.json","markdown":"https://engineer.company/nb/glossary/database-index/index.md","pdf":"https://engineer.company/nb/glossary/database-index/index.pdf"},"kind":"page","language":"nb","title":"Hva er en databaseindeks?","url":"https://engineer.company/nb/glossary/database-index/","version":1}