{"canonical_url":"https://engineer.company/nb/glossary/query/","content_markdown":"# Spørring\n\n## Hva det er\n\nEn spørring er en forespørsel om data, skrevet i et språk databasen forstår, som\nkommer tilbake med et resultat: som regel et sett rader, noen ganger ett enkelt\ntall. Håndboken til PostgreSQL definerer ordet på én linje: å hente data fra en\ndatabase, eller kommandoen som henter dem, kalles en spørring (query), og i SQL\ner den kommandoen SELECT. I dagligtale strekkes ordet lenger, og utviklere\nkaller nesten hver setning de sender til en database, for en spørring, også de\nsom endrer data og sender noe tilbake. Begge betydningene brukes nedenfor, og\nflertallet, spørringer, betyr gjerne all trafikken en applikasjon sender.\n\nÅ spørre hvilke fakturaer som har ventet lengst på betaling, leses nesten slik\nspørsmålet ville blitt stilt høyt:\n\n```sql\nSELECT i.number, c.name, i.amount, i.due_on\nFROM invoices AS i\nJOIN customers AS c ON c.id = i.customer_id\nWHERE i.paid_on IS NULL\n  AND i.due_on \u003c current_date\nORDER BY i.due_on\nLIMIT 20;\n```\n\nTeksten sier hva den vil ha, og lar metoden stå åpen. Fra teksten mottas\ntil første rad returneres, lister planleggeren i PostgreSQL opp måtene den kan\nfinne svaret på, f.eks. å lese hele fakturatabellen eller å gå gjennom en indeks\npå `due_on`, anslår en kostnad for hver og kjører den billigste. Kostnadene er i\nvilkårlige enheter, som etter konvensjon er forankret i å lese én side fra\ndisk. To spørringer som ser like ut på skjermen, kan derfor skille seg med en\nfaktor tusen når dataene under dem vokser, og planen er det eneste stedet den\nforskjellen synes.\n\nLeddene kjøres i en annen rekkefølge enn de er skrevet i. Håndboken beskriver\nbehandlingen av SELECT med WITH først, så FROM, WHERE, gruppering og HAVING,\nderetter SELECT-listen, og først etter det ORDER BY og LIMIT. Den rekkefølgen\nforklarer en regel som overrasker de fleste én gang: et navn som gis til en\nkolonne i SELECT-listen, virker i ORDER BY og GROUP BY, mens WHERE kjøres før\nnavnet finnes, så der må uttrykket skrives ut på nytt. Resultatet av hver\nspørring er selv en tabell, og derfor kan spørringer nøstes, med en\nunderspørring eller et WITH-ledd som mater radene sine inn i en større spørring.\n\n## Hvorfor det er viktig\n\nI en applikasjon med en relasjonsdatabase bak avgjør spørringene mye av hvor\nrask en side føles, og hvor mye maskinvare systemet trenger. Hvilke spørringer\nsom betyr noe, er regning og ikke magefølelse: det en spørring koster systemet,\ner varigheten ganget med hvor ofte den kjøres. Et oppslag på 2 ms som kjøres en\nmillion ganger i timen, blir til mer enn en halvtime databasetid hver time, mens\nen rapport som tar to sekunder og kjøres to ganger om dagen, knapt synes.\n\nPostgreSQL fører det regnskapet i utvidelsen pg_stat_statements. Den slår sammen\nsetninger som bare skiller seg i konstantene de inneholder, til én oppføring, og\nregistrerer hvor mange ganger hver ble kjørt, og hvor lang tid de brukte til\nsammen. Å sortere etter total i stedet for gjennomsnitt er vanen som lønner seg\nførst i arbeid med spørringer, fordi den peker på setningen som er verdt å rette,\nog ikke på den som bare ser treg ut.\n\nHver spørring koster også en rundtur. Applikasjonen sender tekst, serveren\nparser, planlegger og kjører den, og radene reiser tilbake. For et raskt oppslag\ni en indeks kan rundturen veie mer enn selve arbeidet. Formen på samtalen betyr\nderfor like mye som hver enkelt setning: én UPDATE som rører hundre rader, er én\nrundtur, og en løkke som leser hundre rader og oppdaterer dem én etter én, er\nhundre og én.\n\nSå er det spørsmålet om hvem som skriver spørringene. En ORM eller en\nspørringsbygger genererer dem fra applikasjonskoden, noe som går raskt for enkel\nlesing og skriving og holder koden i ett språk. Men det skjuler også hvor mange\nsetninger en forespørsel sender, og hvordan de ser ut, helt til en side blir\ntreg. Håndskrevet SQL viser begge deler, mot at noen eier den som all annen\nkode. En deling som fungerer, lar ORM-en ta seg av rutinepostene, skriver de\nytelseskritiske kodestiene for hånd og leser den genererte SQL-en for alt som klatrer til\ntoppen av totalene.\n\n## Slik ser det ut i praksis\n\nMetoden for en treg database i\n[Optimaliser databasen før du sharder den](/nb/notes/optimise-before-you-shard/)\nbegynner med spørringene, før noen priser flere maskiner. Første steg spør\nPostgreSQL hvilke setninger som koster mest totalt, med pg_stat_statements\nsortert etter samlet kjøretid. Andre steg kjører EXPLAIN (ANALYZE, BUFFERS) på\nsetningen øverst for å se planen databasen valgte, radene hvert steg faktisk\nreturnerte mot radene planleggeren ventet, og hvor mange sider den leste.\nTommelfingerregelen i notatet er at en skanning av en million rader for å\nreturnere ti, eller et estimat som bommer med en faktor hundre, som regel\nforklarer tregheten alene. Notatet teller rundturer også, og trekker den samme\ngrensen som denne artikkelen trekker over: det som må se dataene, flytter inn i\ndatabasen, og forretningsregler blir i applikasjonen.\n\nEn spørring kan også gjøre jobben til en lås. I\n[Å selge den siste billetten nøyaktig én gang](/nb/notes/selling-limited-stock-without-overselling/)\ngår et lynsalg galt på én av to måter. Å lese lagerbeholdningen, avgjøre i\napplikasjonen og skrive det nye tallet tilbake lar to kjøpere ta den siste\nenheten begge to; å holde en radlås over den applikasjonslogikken får hver\nkjøper til å vente bak den. Løsningen samler sjekken og nedtellingen i én\nbetinget UPDATE som trekker fra antallet bare der det er nok igjen på lager, og\nreturnerer det nye nivået. Én rad tilbake betyr at enheten er reservert, og null\nrader betyr utsolgt. På READ COMMITTED, standardnivået for isolasjon i\nPostgreSQL, venter en annen kjøper som når raden mens den første holder den, og\nevaluerer så WHERE-leddet på nytt mot den committede raden, så den siste\nenheten går til nøyaktig én av dem. En CHECK-skranke som holder beholdningen på\nnull eller over, står bak spørringen.\n\n## Hvor det går galt\n\n**En billig spørring som dominerer lasten.** Databasen er hardt belastet, men\nloggen over trege spørringer er stille, fordi hvert kall er ferdig på noen få\nmillisekunder. Årsaken er hyppighet: én rask spørring som kalles ved hver\nforespørsel, ofte fra en løkke eller fra en komponent som finnes på hver side.\nRanger setningene etter samlet kjøretid i pg_stat_statements, og bruk så caching\npå resultatet, samle kallene i batcher, eller gjør spørringen billigere med en\nindeks som passer filteret.\n\n**En side som sender hundrevis av spørringer.** Hver spørring i sporingen tar et\nmillisekund, og siden bruker likevel sekunder. En ORM som laster relaterte\nposter etter behov (lazy loading), med én spørring per foreldrerad, er den\nvanlige årsaken, kjent som N+1-mønsteret. Last de relaterte radene i én\nspørring, med en join eller med `WHERE id = ANY($1)` og en matrise med nøkler,\nog følg med på antallet setninger per forespørsel like nøye som varigheten til\nhver enkelt.\n\n**Den siste enheten solgt to ganger.** To forespørsler leser den samme\nlagerbeholdningen, begge avgjør at det er nok, og begge skriver. Lesing og\nskriving i separate setninger lar det stå en åpning mellom sjekken og\nhandlingen, og samtidig trafikk finner den. Lukk åpningen inne i spørringen,\nmed en betinget UPDATE og RETURNING som over, eller med SELECT ... FOR UPDATE\nholdt så kort som mulig og uten noe nettverkskall mellom låsen og commiten.\n\n**En diagnose som endret dataene.** Noen kjører EXPLAIN ANALYZE på en treg\nDELETE for å se planen, og radene er borte. ANALYZE utfører setningen på\nordentlig og kaster bare utdataene, så hver sideeffekt skjer. Pakk enhver\nsetning som endrer data, inn i BEGIN og ROLLBACK før du analyserer den, eller\nbruk vanlig EXPLAIN, som planlegger uten å kjøre, når estimatene holder.\n\n## Les mer\n\n- [SELECT](https://www.postgresql.org/docs/current/sql-select.html) — hele\n  syntaksen for en spørring i PostgreSQL, med rekkefølgen leddene behandles i.\n- [7.1. Overview](https://www.postgresql.org/docs/current/queries-overview.html)\n  — starten på kapittelet om spørringer i håndboken, med definisjonen av ordet.\n- [51.1. The Path of a Query](https://www.postgresql.org/docs/current/query-path.html)\n  — veien fra klientens tekst gjennom parser, omskriver og planlegger til\n  utføreren.\n- [14.1. Using EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html)\n  — hvordan du leser en plan, hva kostnadsenhetene betyr, og hvorfor ANALYZE\n  kjører setningen.\n- [F.32. pg_stat_statements — track statistics of SQL planning and execution](https://www.postgresql.org/docs/current/pgstatstatements.html)\n  — utvidelsen som rangerer spørringer etter hva de koster totalt.\n- [13.2. Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — hva en annen skrivende transaksjon ser under READ COMMITTED, og hvorfor WHERE-leddet\n  sjekkes på nytt.\n\n\u003chttps://engineer.company/nb/glossary/query/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hva en spørring er, hvordan databasen gjør den om til en plan, hvorfor hyppigheten teller mer enn tregheten, og feilene som koster mest.","formats":{"gemtext":"https://engineer.company/nb/glossary/query/index.gmi","gopher":"https://engineer.company/nb/glossary/query/gophermap","html":"https://engineer.company/nb/glossary/query/","json":"https://engineer.company/nb/glossary/query/index.json","markdown":"https://engineer.company/nb/glossary/query/index.md","pdf":"https://engineer.company/nb/glossary/query/index.pdf"},"kind":"page","language":"nb","title":"Hva er en spørring?","url":"https://engineer.company/nb/glossary/query/","version":1}