{"canonical_url":"https://engineer.company/sv/glossary/query/","content_markdown":"# Databasfråga\n\n## Vad det är\n\nEn databasfråga är en begäran om data, skriven i ett språk som databasen förstår, som kommer\ntillbaka med ett resultat: oftast en mängd rader, ibland ett enda tal. Handboken till PostgreSQL\ndefinierar den på en rad: att hämta data ur en databas, eller kommandot som gör hämtningen, kallas\nen query, och i SQL är det kommandot SELECT. I vardagligt tal tänjs ordet längre, och utvecklare\nkallar nästan varje sats de skickar till en databas för en SQL-fråga, även de som ändrar data och\nlämnar något tillbaka. Båda betydelserna förekommer nedan, och pluralformen, databasfrågor, betyder\noftast all trafik som en applikation skickar.\n\nEn SQL-fråga om vilka fakturor som har väntat längst på betalning läses nästan som man skulle säga\ndet högt:\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\nTexten anger vad den vill ha och lämnar metoden öppen. Mellan att PostgreSQL tar emot den och\nreturnerar den första raden listar planeraren de vägar som kan ge svaret, t.ex. att läsa hela\ntabellen invoices eller att gå igenom ett index på `due_on`, uppskattar en kostnad för varje väg och\nkör den billigaste. Kostnaderna anges i godtyckliga enheter som av konvention utgår från läsningen\nav en sida från disk. Två databasfrågor som ser likadana ut på skärmen kan därför skilja sig med en\nfaktor tusen när datan under dem växer, och planen är det enda ställe där skillnaden syns.\n\nSatsdelarna körs inte i den ordning de är skrivna. Handboken beskriver behandlingen av SELECT med\nWITH först, sedan FROM, WHERE, gruppering och HAVING, därefter listan med utdata och först efter det\nORDER BY och LIMIT. Den ordningen förklarar en regel som överraskar de flesta en gång: ett namn som\nges åt en kolumn i urvalslistan fungerar i ORDER BY och GROUP BY, medan WHERE körs innan namnet\nfinns, så där måste uttrycket skrivas ut igen. Resultatet av varje databasfråga är i sig en tabell,\noch därför går databasfrågor att nästla, med en inre SQL-fråga eller en WITH-sats som matar sina\nrader till en större.\n\n## Varför det spelar roll\n\nI en applikation som vilar på en relationsdatabas avgör databasfrågorna en stor del av hur snabb en\nsida känns och hur mycket hårdvara systemet behöver. Vilka databasfrågor som spelar roll är\naritmetik snarare än magkänsla: kostnaden för systemet är varaktigheten multiplicerad med hur ofta\nsatsen körs. Ett uppslag på 2 ms som körs en miljon gånger i timmen blir mer än en halvtimmes\ndatabastid varje timme, medan en rapport som tar två sekunder och körs två gånger om dagen knappt\nmärks.\n\nPostgreSQL för den bokföringen i tillägget pg_stat_statements. Det slår ihop satser som bara skiljer\nsig i sina litterala värden till en post och registrerar hur många gånger varje sats har körts och\nden totala tid den har tagit. Att sortera på totalen i stället för på medelvärdet är den vana som\nlönar sig först i arbetet med databasfrågor, eftersom den pekar ut den sats som är värd att rätta i\nstället för den som bara ser långsam ut.\n\nVarje databasfråga kostar också en tur och retur. Applikationen skickar text, servern tolkar,\nplanerar och kör den, och raderna färdas tillbaka. För ett snabbt uppslag i ett index kan resan väga\ntyngre än arbetet. Därför spelar samtalets form lika stor roll som varje enskild sats: en UPDATE som\nberör hundra rader gör en resa, och en loop som läser hundra rader och uppdaterar dem en i taget gör\n101 resor.\n\nSedan återstår frågan om vem som skriver databasfrågorna. En ORM eller ett bibliotek som bygger\nSQL-frågor genererar dem ur applikationskoden, vilket går fort för enkla läsningar och skrivningar\noch håller koden i ett enda språk. Det döljer också hur många satser en begäran skickar och hur de\nser ut, tills en sida blir långsam. Handskriven SQL visar båda, till priset att någon måste äga den\nsom all annan kod. En fungerande uppdelning låter ORM:en sköta rutinposterna, skriver de prestandakritiska\nkodvägarna för hand och läser den genererade SQL-koden för allt som klättrar till toppen av totalerna.\n\n## Så ser det ut i praktiken\n\nMetoden för en långsam databas i\n[Optimera databasen innan du shardar den](/sv/notes/optimise-before-you-shard/) börjar med\ndatabasfrågorna, innan någon räknar på fler maskiner. Det första steget frågar PostgreSQL vilka\nsatser som kostar mest totalt, med pg_stat_statements sorterat på total körtid. Det andra kör\nEXPLAIN (ANALYZE, BUFFERS) på satsen överst, för att se den plan som databasen valde, de rader varje\nsteg verkligen returnerade jämfört med de rader planeraren väntade sig och hur många sidor den\nläste. Anteckningens tumregel är att en skanning av en miljon rader för att returnera tio, eller en\nuppskattning som slår fel med en faktor hundra, för det mesta förklarar långsamheten på egen hand.\nDen räknar också turer och returer och drar samma gräns som den här artikeln drar ovan: det som\nmåste se datan flyttar in i databasen, och affärsreglerna stannar i applikationen.\n\nEn databasfråga kan också göra ett lås jobb. I\n[Att sälja den sista biljetten exakt en gång](/sv/notes/selling-limited-stock-without-overselling/)\ngår en blixtrea snett på ett av två sätt. Att läsa lagersaldot, besluta i applikationen och skriva\ntillbaka det nya talet låter två köpare båda ta den sista enheten. Att hålla ett radlås över den\napplikationslogiken får varje köpare att vänta på sin tur bakom det. Lösningen viker ihop kontrollen\noch minskningen till en enda villkorad UPDATE som drar av antalet bara där tillräckligt mycket finns\nkvar i lager och returnerar den nya nivån. En rad tillbaka betyder att enheten är reserverad, och\nnoll rader betyder slutsålt. Med READ COMMITTED, standardnivån för isolering i PostgreSQL, väntar en\nandra köpare som når raden medan den första håller den, och prövar sedan WHERE-villkoret igen mot\nden bekräftade raden, så att den sista enheten går till exakt en av dem. Ett CHECK-villkor som\nhåller saldot på noll eller mer står bakom databasfrågan.\n\n## Var det går fel\n\n**En billig databasfråga dominerar lasten.** Databasen går varm, men loggen för långsamma\ndatabasfrågor förblir tyst, eftersom varje anrop blir klart på några millisekunder. Orsaken är\nfrekvensen: en snabb SQL-fråga som anropas vid varje begäran, ofta från en loop eller från en\nkomponent som finns på varje sida. Rangordna satserna efter total körtid i pg_stat_statements och\ncacha sedan resultatet, samla anropen i omgångar eller gör databasfrågan billigare med ett index som\nmatchar dess filter.\n\n**En sida skickar hundratals databasfrågor.** Varje SQL-fråga i spåret tar en millisekund, och sidan\ntar ändå flera sekunder. En ORM som läser in relaterade poster vid behov, en SQL-fråga per föräldrarad,\när den vanliga orsaken, känd som N+1-mönstret. Läs in de relaterade raderna i en enda SQL-fråga, med\nen join eller med `WHERE id = ANY($1)` och en array med nycklar, och bevaka antalet satser per\nbegäran lika noga som varaktigheten för var och en.\n\n**Den sista enheten säljs två gånger.** Två begäranden läser samma lagersaldo, båda bedömer att det\nräcker och båda skriver. Att läsa och skriva i separata satser lämnar en lucka mellan kontrollen\noch handlingen, och samtidig trafik hittar den. Stäng luckan inne i databasfrågan, med en villkorad\nUPDATE och RETURNING som ovan, eller med SELECT ... FOR UPDATE som hålls så kort som möjligt och\nutan något nätverksanrop mellan låset och commit.\n\n**En diagnos som ändrade datan.** Någon kör EXPLAIN ANALYZE på en långsam DELETE för att titta på\nplanen, och raderna är borta. ANALYZE kör satsen på riktigt och kastar bara dess utdata, så varje\nsidoeffekt inträffar. Lägg varje sats som ändrar data inom BEGIN och ROLLBACK innan den analyseras,\neller använd vanlig EXPLAIN, som planerar utan att köra, när uppskattningarna räcker.\n\n## Läs mer\n\n- [SELECT](https://www.postgresql.org/docs/current/sql-select.html)\n  — den fullständiga syntaxen för en databasfråga i PostgreSQL, inklusive den ordning i vilken\n  satsdelarna behandlas.\n- [7.1. Overview](https://www.postgresql.org/docs/current/queries-overview.html)\n  — början på handbokens kapitel om databasfrågor, med definitionen av ordet.\n- [51.1. The Path of a Query](https://www.postgresql.org/docs/current/query-path.html)\n  — vägen från klientens text genom parser, omskrivare och planerare till exekveraren.\n- [14.1. Using EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html)\n  — hur man läser en plan, vad kostnadsenheterna betyder och varför ANALYZE kör satsen.\n- [F.32. pg_stat_statements — track statistics of SQL planning and execution](https://www.postgresql.org/docs/current/pgstatstatements.html)\n  — tillägget som rangordnar databasfrågor efter vad de kostar totalt.\n- [13.2. Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — vad en andra skrivande transaktion ser under READ COMMITTED och varför WHERE-villkoret prövas igen.\n\n\u003chttps://engineer.company/sv/glossary/query/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Databasfråga för dig som skriver SQL: hur PostgreSQL väljer en plan, varför antalet anrop väger tyngre än tiden per anrop och de misstag som kostar mest.","formats":{"gemtext":"https://engineer.company/sv/glossary/query/index.gmi","gopher":"https://engineer.company/sv/glossary/query/gophermap","html":"https://engineer.company/sv/glossary/query/","json":"https://engineer.company/sv/glossary/query/index.json","markdown":"https://engineer.company/sv/glossary/query/index.md","pdf":"https://engineer.company/sv/glossary/query/index.pdf"},"kind":"page","language":"sv","title":"Vad är en databasfråga?","url":"https://engineer.company/sv/glossary/query/","version":1}