{"canonical_url":"https://engineer.company/da/glossary/database-index/","content_markdown":"# Databaseindeks\n\n## Hvad det er\n\nEt databaseindeks er en separat struktur, gemt ved siden af en tabel, som lader\ndatabasen gå direkte til de rækker, der opfylder en betingelse, i stedet for at\nlæse tabellen fra første til sidste række. Til daglig, og i det meste af\nPostgreSQL-dokumentationen, hedder det bare et indeks. Dokumentationen\nsammenligner det med stikordsregistret bag i en bog: den, der leder efter ét\nemne, slår op dér og bladrer direkte til de sider, der står, i stedet for at\nlæse hele bogen igennem.\n\nTag en tabel med ordrer og betingelsen `WHERE customer_id = 42`. Uden et indeks\npå `customer_id` har PostgreSQL kun én måde at svare på: en sekventiel scanning,\nder læser hver eneste række og beholder dem, der passer. Det koster det samme,\nuanset om kunden har to ordrer eller to tusind, og prisen vokser med tabellen.\nMed et indeks på kolonnen går PostgreSQL et par niveauer ned gennem et søgetræ\ntil posterne for 42 og henter kun de rækker. Et indeks oprettes med én sætning,\n`DROP INDEX` fjerner det igen, og begge dele kan ske når som helst.\n\nNår indekset først findes, holder PostgreSQL det ajour med tabellen ved hver\nskrivning, og forespørgselsplanlæggeren afgør fra forespørgsel til forespørgsel,\nom det er billigere at bruge det end at scanne. Intet i SQL'en nævner indekset,\nså det samme indeks kan gøre en `SELECT` hurtigere, ligesom en `UPDATE` eller\n`DELETE` med en søgebetingelse og et join.\n\nPostgreSQL har flere slags, hver bygget til sin type spørgsmål:\n\n- **B-tree** er standarden og det, `CREATE INDEX` bygger, medmindre man beder om\n  andet. Det besvarer lighed og intervaller (`\u003c`, `\u003c=`, `=`, `\u003e=`, `\u003e`),\n  `BETWEEN`, `IN`, `IS NULL` og en `LIKE`, hvis mønster er forankret i starten.\n  Det holder sine poster sorteret og kan derfor også levere rækkerne i orden.\n- **Hash** gemmer en 32-bit hashkode for hver værdi og besvarer kun lighed.\n- **GiST** og **SP-GiST** er rammer for data som geometri, hvor spørgsmålet er\n  »overlapper«, »indeholder« eller »nærmest ved« snarere end »er lig med«.\n- **GIN** er et inverteret indeks til værdier, der består af mange dele, for\n  eksempel arrays, og finder de rækker, hvis værdi indeholder et bestemt\n  element.\n- **BRIN** gemmer kun et resumé for hvert interval af tabelblokke. Det passer\n  til en kolonne, hvis værdier følger rækkernes fysiske rækkefølge, sådan som et\n  indsættelsestidspunkt ofte gør.\n\nUd over typen kan et indeks formes efter spørgsmålet. Et unikt indeks afviser\ndubletter. Et sammensat indeks dækker flere kolonner, op til 32. Et partielt\nindeks har en `WHERE`-klausul og rummer kun de rækker, der opfylder den. Et\nudtryksindeks gemmer en beregnet værdi som `lower(email)`. Og en `INCLUDE`-liste\ntager ekstra kolonner med i indekset uden at søge på dem, så en forespørgsel kan\nbesvares fra indekset alene.\n\n## Hvorfor det betyder noget\n\nForskellen, et indeks gør, vokser med tabellen. På en lille tabel er en scanning\nbillig, og planlæggeren vælger ofte, med rette, netop den: at læse en håndfuld\nsider i rækkefølge koster mindre end at gå gennem et træ for at nå dem. Med\net tocifret antal millioner rækker er forskellen mellem en scanning og et opslag\nforskellen mellem et svar med det samme og en timeout. En forespørgsel, der var\nhurtig ved lanceringen, kan blive langsom et år senere, uden at en eneste\nkodelinje er ændret, blot fordi tabellen, den læser, er vokset.\n\nIndekser er ikke gratis, og regningen kommer ved skrivning. Hver insert tilføjer\nen post til hvert indeks på tabellen. En opdatering kan kun slippe for det som\nen heap-only tuple-opdatering (HOT), hvor den nye rækkeversion bliver på samme\nside og ikke kræver nye indeksposter, og det tillader PostgreSQL kun, når\nopdateringen ikke ændrer nogen kolonne, som tabellens indekser bruger.\nBRIN-indekser tæller ikke med, fordi de kun gemmer et resumé. Hvert indeks gør\naltså den billige vej smallere, og derfor råder dokumentationen til at fjerne\nindekser, der sjældent eller aldrig bliver brugt. En tabel med et dusin indekser\nbetaler et dusin gange ved hver insert.\n\nDet koster også at bygge et indeks. En almindelig `CREATE INDEX` lader andre\nsessioner læse tabellen, men blokerer dens skrivninger, indtil opbygningen er\nfærdig, og dokumentationen advarer om, at det på en meget stor tabel kan tage\nmange timer.\n\nEndelig er et indeks kun så godt som planlæggerens beslutning om at bruge det,\nog planlæggeren arbejder ud fra statistik, som `ANALYZE` har samlet. Spørgsmålet\ner ikke »findes der et indeks?«, men »bruger de forespørgsler, der betyder\nnoget, det?«, og `EXPLAIN` er måden at finde ud af det på.\n\n## Sådan ser det ud i praksis\n\nEn webshops kontoside viser en kundes tyve seneste 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 kun en primærnøgle på `id` må PostgreSQL læse hele `orders`, beholde kundens\nrækker, sortere dem og smide alle undtagen tyve væk. `EXPLAIN` viser det: en\n`Seq Scan` på `orders` med betingelsen som `Filter` og en sortering ovenover.\n`EXPLAIN ANALYZE` kører også forespørgslen og skriver de faktiske rækkeantal og\ntider ved siden af estimaterne.\n\nDet indeks, der passer til spørgsmålet, har lighedskolonnen først og\nsorteringskolonnen bagefter:\n\n```sql\nCREATE INDEX CONCURRENTLY orders_customer_created_idx\nON orders (customer_id, created_at);\n```\n\nKør `EXPLAIN` igen, og scanningen bliver en indeksscanning med\n`orders_customer_created_idx`, hvor `customer_id = 42` nu står som `Index Cond`\ni stedet for som filter. Sorteringen forsvinder også. Et B-tree holder posterne\nfor kunde 42 ordnet efter `created_at`, PostgreSQL kan læse dem baglæns for at\nfå de nyeste først, og med `LIMIT` stopper den efter tyve poster uden at røre\nresten.\n\nKolonnernes rækkefølge betyder noget. Det samme indeks dækker en forespørgsel på\n`customer_id` alene, fordi det er den forreste kolonne, men en rapport over alle\ngårsdagens ordrer, der kun filtrerer på `created_at`, får langt mindre ud af\ndet. I et sammensat B-tree er det lighed på de forreste kolonner plus et\ninterval på den næste, der indsnævrer den del af indekset, som bliver læst.\nPostgreSQL 18 kan lave skip scan og gentage søgningen én gang for hver\nforskellig værdi i den forreste kolonne, men planlæggeren vælger normalt kun\ndet, når der er få forskellige værdier, og kunde-id'er er der mange af. Betyder\nrapporten noget, får den sit eget indeks på `created_at`. Vendt om, som\n`(created_at, customer_id)`, ville indekset sprede kunde 42's ordrer ud over det\nhele.\n\nNoten om\n[at optimere databasen, før du sharder den](/da/notes/optimise-before-you-shard/)\nsætter indekser først blandt de forbedringer, den ordner efter udbytte, når\nplanerne har udpeget de scanninger, en ydelseskritisk forespørgsel kører. Dens eget\neksempel er et partielt indeks, `units_unsold`, der kun rummer de enheder, der\nstadig er til salg, så det skrumper, mens et salg skrider frem, i stedet for at\nvokse. Noten regner også prisen ud. På dens tabel var 2.000 reservationer, der\nsatte `reserved`, `reserved_at` og `order_id`, alle HOT-opdateringer, mens ingen\naf 2.000 opdateringer, der satte `sold`, en kolonne det partielle indeks læser,\nvar det. Dens råd er at fjerne de indekser, hvis `idx_scan` i\n`pg_stat_user_indexes` bliver ved med at stå på nul.\n\nCasen om\n[et bedre valg af nøgle](/da/portfolio/quicker-answers-from-a-better-choice-of-key/)\nviser, hvorfor de værdier, der havner i et B-tree, betyder lige så\nmeget som kolonnerne. Tilfældige UUID'er spreder inserts ud over\nindekset, hvilket kan skabe fragmentering. Platformen gjorde\ntidsordnede UUID v7 til standard for entiteternes primærnøgler,\nmed et tidsstempel i de forreste bits, så nye identifikatorer\nrummer en tidsmæssig rækkefølge. Mindre fragmentering og hurtigere\nforespørgsler var designmål; det dokumenterede resultat er den\nkonfigurerede nøglekonvention, og casen dokumenterer ikke et\nbenchmark, der måler ydelsen før og efter under en arbejdsbelastning.\n\n## Hvor det går galt\n\n**Et nyt indeks stopper tabellens skrivninger.** En almindelig `CREATE INDEX` på\nen travl tabel blokerer inserts, opdateringer og sletninger, så længe\nopbygningen varer, og en rutinemæssig udrulning bliver til et nedbrud. Brug\n`CREATE INDEX CONCURRENTLY`: den scanner tabellen to gange og venter på\ntransaktioner, der kunne bruge indekset, så den tager betydeligt længere tid,\nmen skrivningerne fortsætter. Den kan ikke køre inde i en transaktionsblok, så\net migreringsværktøj, der pakker hvert trin ind i én, skal have besked på at\nkøre netop den sætning for sig. Der kan kun køre én samtidig opbygning på en\ntabel ad gangen.\n\n**En samtidig opbygning fejler og efterlader et ugyldigt indeks.** Et deadlock\neller en dubletværdi under opbygningen af et unikt indeks får\n`CREATE INDEX CONCURRENTLY` til at fejle, men det påbegyndte indeks bliver\nliggende i kataloget, markeret som ugyldigt. Forespørgsler ignorerer det, men\nhver skrivning betaler stadig for at vedligeholde det, og et ugyldigt unikt\nindeks kan blive ved med at håndhæve unikhed. psql's `\\d` viser det med\n`INVALID` efter definitionen. Fjern det, og kør den samtidige opbygning igen,\neller genopbyg det med `REINDEX INDEX CONCURRENTLY`.\n\n**Forespørgslen gemmer kolonnen inde i en funktion.** Et indeks på `email` gør\nintet for `WHERE lower(email) = 'ana@example.com'`, fordi indekset rummer\n`email`, ikke `lower(email)`. Indeksér det udtryk, forespørgslen bruger:\n\n```sql\nCREATE INDEX users_lower_email_idx ON users (lower(email));\n```\n\nUdtrykket beregnes ved hver insert og hver opdatering, der ikke er HOT, og\nderfor anbefaler dokumentationen udtryksindekser dér, hvor hurtige opslag\nbetyder mere end hurtige skrivninger.\n\n**Der hober sig indekser op, som ingen bruger.** Hvert indeks, der er lagt på\n»for en sikkerheds skyld«, koster ved hver skrivning og kan spærre for\nHOT-opdateringer. `pg_stat_user_indexes` tæller de scanninger, der er startet på\nhvert indeks, i `idx_scan` og noterer tidspunktet for den seneste 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 efter, før du sletter. Et indeks bag en primærnøgle eller en unik constraint\ngør sit arbejde, uanset om en forespørgsel nogensinde læser det, og et nul siger\nikke meget på en server, der lige er begyndt at tage imod trafik.\n\n**Planlæggeren ignorerer et godt indeks.** Efter en stor indlæsning halter\nstatistikken efter dataene, estimaterne rammer forkert, og en scanning vinder på\npapiret. Kør `ANALYZE`; dokumentationen kalder det håbløst at vurdere indeksbrug\nuden. Test også på realistiske mængder: på hundrede rækker, der kan ligge på én\ndiskside, slår intet indeks det at læse den ene side. Vil du vide, om et indeks\noverhovedet kan bruges, så sæt `enable_seqscan = off` i en testsession, og kør\n`EXPLAIN` igen. Scanner planen stadig, passer betingelsen ikke til indekset.\n\n## Læs mere\n\n- [Indexes: Introduction](https://www.postgresql.org/docs/current/indexes-intro.html)\n  — hvad et indeks er til, hvordan det oprettes og fjernes, og hvad det koster\n  ved hver skrivning.\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 af dem kan\n  besvare.\n- [Multicolumn Indexes](https://www.postgresql.org/docs/current/indexes-multicolumn.html)\n  — hvordan kolonnernes rækkefølge afgør, hvad et B-tree kan indsnævre, og\n  hvornår skip scan kommer i spil.\n- [CREATE INDEX](https://www.postgresql.org/docs/current/sql-createindex.html) —\n  hele syntaksen, herunder `CONCURRENTLY`, `INCLUDE`, partielle indekser og\n  oprydning efter en ugyldig opbygning.\n- [Using EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html) —\n  at læse en plan: scanningstyper, estimerede omkostninger og de faktiske tal\n  fra `EXPLAIN ANALYZE`.\n- [Examining Index Usage](https://www.postgresql.org/docs/current/indexes-examine.html)\n  — hvorfor `ANALYZE` og rigtige data kommer først, og hvordan man tester, om et\n  indeks kan bruges.\n\n\u003chttps://engineer.company/da/glossary/database-index/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvordan et databaseindeks gør en scanning til et opslag: PostgreSQL's indekstyper, prisen ved hver skrivning, og hvordan du ser, om det bliver brugt.","formats":{"gemtext":"https://engineer.company/da/glossary/database-index/index.gmi","gopher":"https://engineer.company/da/glossary/database-index/gophermap","html":"https://engineer.company/da/glossary/database-index/","json":"https://engineer.company/da/glossary/database-index/index.json","markdown":"https://engineer.company/da/glossary/database-index/index.md","pdf":"https://engineer.company/da/glossary/database-index/index.pdf"},"kind":"page","language":"da","title":"Hvad er et databaseindeks?","url":"https://engineer.company/da/glossary/database-index/","version":1}