{"canonical_url":"https://engineer.company/da/glossary/query/","content_markdown":"# Databaseforespørgsel\n\n## Hvad det er\n\nEn databaseforespørgsel, i daglig tale bare en forespørgsel, er en anmodning om\ndata, skrevet i et sprog databasen forstår, som kommer tilbage med et resultat:\nsom regel et sæt rækker, af og til et enkelt tal. PostgreSQL's manual definerer\nbegrebet på én linje: Det at hente data fra en database, eller den kommando der\nhenter dem, kaldes en query, og i SQL er den kommando SELECT. Mange danske\nudviklere bruger det engelske ord direkte, og i daglig tale glider betydningen,\nså næsten enhver sætning, der sendes til en database, kaldes en forespørgsel,\nogså dem der ændrer data og sender noget retur. Begge betydninger bruges\nnedenfor: forespørgslen er den enkelte sætning, og forespørgsler i flertal er\nsom regel al den trafik, en applikation sender.\n\nSpørger man, hvilke fakturaer der har ventet længst på betaling, ligger\nforespørgslen tæt på, hvordan man ville sige det højt:\n\n```sql\nSELECT f.nummer, k.navn, f.total, f.forfald\nFROM fakturaer AS f\nJOIN kunder AS k ON k.id = f.kunde_id\nWHERE f.betalt_den IS NULL\n  AND f.forfald \u003c current_date\nORDER BY f.forfald\nLIMIT 20;\n```\n\nTeksten siger, hvad den vil have, og lader metoden være åben. Mellem at modtage\nden og returnere den første række opregner PostgreSQL's planlægger de måder,\nden kan finde svaret på – for eksempel at læse hele fakturatabellen eller at gå\ngennem et indeks på `forfald` – anslår en omkostning for hver og kører den\nbilligste. Omkostningerne er i vilkårlige enheder, traditionelt sat i forhold\ntil at læse én side fra disken. To forespørgsler, der ligner hinanden på\nskærmen, kan derfor variere med en faktor tusind, når data under dem vokser,\nog planen er det eneste sted, forskellen kan ses.\n\nKlausulerne udføres i en anden rækkefølge, end de er skrevet i. Manualen\nbeskriver behandlingen af SELECT sådan: først WITH, så FROM, WHERE, gruppering\nog HAVING, derefter outputlisten og først til sidst ORDER BY og LIMIT. Den\nrækkefølge forklarer en regel, de fleste bliver overraskede over én gang: Et\nnavn, man giver en kolonne i select-listen, virker i ORDER BY og GROUP BY, men\nWHERE kører, før navnet findes, så dér må udtrykket skrives ud igen. Resultatet\naf enhver forespørgsel er selv en tabel, og derfor kan forespørgsler indlejres,\nså en delforespørgsel eller en WITH-klausul fodrer en større med sine rækker.\n\n## Hvorfor det betyder noget\n\nI en applikation bygget på en relationel database afgør forespørgslerne meget\naf, hvor hurtig en side føles, og hvor meget hardware systemet kræver. Hvilke\nforespørgsler der tæller, er et regnestykke snarere end en fornemmelse: En\nforespørgsels pris for systemet er dens varighed ganget med, hvor ofte den\nkører. Et opslag på 2 ms, der kører en million gange i timen, bliver til over\nen halv times databasetid hver time, mens en rapport på to sekunder, der kører\nto gange om dagen, knap kan ses.\n\nPostgreSQL fører det regnskab i udvidelsen pg_stat_statements. Den samler\nsætninger, der kun adskiller sig i deres konkrete værdier, i én post og\nnoterer, hvor mange gange hver kørte, og hvor lang tid den brugte i alt. At\nsortere efter total i stedet for gennemsnit er den vane, der betaler sig først\ni arbejdet med forespørgsler, fordi den peger på den sætning, der er værd at\nrette, frem for den, der bare ser langsom ud.\n\nHver forespørgsel koster også en rundtur. Applikationen sender tekst, serveren\nparser, planlægger og kører den, og rækkerne rejser retur. For et hurtigt\nopslag i et indeks kan rundturen veje tungere end selve arbejdet. Derfor\nbetyder samtalens form lige så meget som den enkelte sætning: Én UPDATE, der\nrører hundrede rækker, er én rundtur, mens en løkke, der læser hundrede rækker\nog opdaterer dem én ad gangen, er hundrede og én.\n\nSå er der spørgsmålet om, hvem der skriver forespørgslerne. En ORM eller en\nquery builder genererer dem ud fra applikationskoden, hvilket går hurtigt for\nenkle læsninger og skrivninger og holder koden i ét sprog. Den skjuler også,\nhvor mange sætninger et kald sender, og hvordan de ser ud, indtil en side\nbliver langsom. Håndskrevet SQL viser begge dele, til gengæld skal nogen eje\nden som al anden kode. En brugbar fordeling lader ORM'en klare de rutinemæssige\nposter, skriver de ydelseskritiske kodestier i hånden og læser den genererede SQL for alt,\nder kravler op i toppen af totalerne.\n\n## Sådan ser det ud i praksis\n\nMetoden for en langsom database i\n[Optimér databasen, før du sharder den](/da/notes/optimise-before-you-shard/)\nbegynder med forespørgslerne, før nogen prissætter flere maskiner. Første\nskridt spørger PostgreSQL, hvilke sætninger der koster mest i alt, med\npg_stat_statements sorteret efter samlet køretid. Andet skridt kører EXPLAIN\n(ANALYZE, BUFFERS) på sætningen øverst for at se den plan, databasen valgte, de\nrækker hvert trin faktisk returnerede over for dem, planlæggeren forventede, og\nhvor mange sider den læste. Notens tommelfingerregel er, at en scanning af en\nmillion rækker for at returnere ti, eller et estimat, der rammer hundrede gange\nved siden af, som regel forklarer langsomheden alene. Den tæller også rundture\nog trækker samme grænse som ovenfor: Det, der skal se data, flytter ind i\ndatabasen, og forretningsreglerne bliver i applikationen.\n\nEn forespørgsel kan også gøre en låses arbejde. I\n[At sælge den sidste billet præcis én gang](/da/notes/selling-limited-stock-without-overselling/)\nkan et flash-salg gå galt på to måder. Læser applikationen lageret, beslutter og\nskriver det nye tal tilbage, kan to købere begge tage den sidste enhed; holder\nden en rækkelås hen over den logik, må alle købere vente på den. Løsningen\nsamler kontrollen og nedskrivningen i én betinget UPDATE, der kun trækker\nantallet fra, hvis der er nok på lager, og returnerer det nye antal. Én række\ntilbage betyder, at enheden er reserveret, og nul rækker betyder udsolgt. Ved\nREAD COMMITTED, PostgreSQL's standardisolationsniveau, venter en anden køber,\nder når rækken, mens den første holder den, og evaluerer derefter\nWHERE-klausulen igen mod den committede række, så den sidste enhed går til\npræcis én af dem. En CHECK-begrænsning, der holder lageret på nul eller derover,\nstår bag forespørgslen.\n\n## Hvor det går galt\n\n**En billig forespørgsel, der dominerer belastningen.** Databasen kører varm,\nmen loggen over langsomme forespørgsler forbliver stille, fordi hvert kald er\nfærdigt på få millisekunder. Årsagen er hyppighed: én hurtig forespørgsel, der\nkører ved hvert kald til serveren, ofte fra en løkke eller fra en komponent, der\nstår på hver side. Sorter sætningerne efter samlet køretid i\npg_stat_statements, og cache så resultatet, saml kaldene, eller gør\nforespørgslen billigere med et indeks, der passer til dens filter.\n\n**En side, der sender hundredvis af forespørgsler.** Hver forespørgsel i sporet\ntager et millisekund, og siden tager stadig sekunder. En ORM, der indlæser\nrelaterede poster efter behov, én forespørgsel pr. overordnet række, er den\nsædvanlige årsag, kendt som N+1-mønstret. Hent de relaterede rækker i én\nforespørgsel, med et join eller med `WHERE id = ANY($1)` og et array af\nnøgler, og hold lige så godt øje med antallet af sætninger pr. kald som med\nvarigheden af hver enkelt.\n\n**Den sidste enhed solgt to gange.** To kald læser det samme lager, begge\nkonkluderer, at der er nok, og begge skriver. Når læsning og skrivning sker i\nhver sin sætning, opstår der et hul mellem kontrollen og handlingen, og\nsamtidig trafik finder det. Luk hullet inde i forespørgslen, med en betinget\nUPDATE og RETURNING som ovenfor eller med SELECT ... FOR UPDATE holdt så kort\nsom muligt og uden netværkskald mellem låsen og committet.\n\n**En diagnose, der ændrede data.** Nogen kører EXPLAIN ANALYZE på en langsom\nDELETE for at se planen, og rækkerne er væk. ANALYZE udfører sætningen for\nalvor og kasserer kun dens output, så alle bivirkninger sker. Pak enhver\ndataændrende sætning ind i BEGIN og ROLLBACK, før man analyserer den, eller\nbrug almindelig EXPLAIN, der planlægger uden at udføre, når estimaterne er nok.\n\n## Læs mere\n\n- [SELECT](https://www.postgresql.org/docs/current/sql-select.html)\n  — den fulde syntaks for en forespørgsel i PostgreSQL, inklusive den\n  rækkefølge, klausulerne behandles i.\n- [7.1. Overview](https://www.postgresql.org/docs/current/queries-overview.html)\n  — begyndelsen på manualens kapitel om forespørgsler, med definitionen af\n  ordet.\n- [51.1. The Path of a Query](https://www.postgresql.org/docs/current/query-path.html)\n  — vejen fra klientens tekst gennem parser, omskrivning og planlægger til\n  executor.\n- [14.1. Using EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html)\n  — hvordan man læser en plan, hvad omkostningsenhederne betyder, og hvorfor\n  ANALYZE kører sætningen.\n- [F.32. pg_stat_statements — track statistics of SQL planning and execution](https://www.postgresql.org/docs/current/pgstatstatements.html)\n  — udvidelsen, der rangerer forespørgsler efter, hvad de koster i alt.\n- [13.2. Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — hvad en anden skrivende transaktion ser under READ COMMITTED, og hvorfor WHERE-klausulen\n  tjekkes igen.\n\n\u003chttps://engineer.company/da/glossary/query/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad en forespørgsel er, hvordan databasen gør den til en plan, hvorfor hyppighed vejer tungere end hastighed, og de fejl der koster mest.","formats":{"gemtext":"https://engineer.company/da/glossary/query/index.gmi","gopher":"https://engineer.company/da/glossary/query/gophermap","html":"https://engineer.company/da/glossary/query/","json":"https://engineer.company/da/glossary/query/index.json","markdown":"https://engineer.company/da/glossary/query/index.md","pdf":"https://engineer.company/da/glossary/query/index.pdf"},"kind":"page","language":"da","title":"Hvad er en databaseforespørgsel?","url":"https://engineer.company/da/glossary/query/","version":1}