{"canonical_url":"https://engineer.company/sv/glossary/cte/","content_markdown":"# CTE\n\n## Vad det är\n\nEn CTE är en fråga som får ett namn i en WITH-klausul överst i en SQL-sats, så\natt resten av satsen kan läsa dess rader som om de kom från en tabell.\nFörkortningen står för common table expression, på svenska ibland gemensamt\ntabelluttryck, och PostgreSQL:s manual kallar konstruktionen WITH-frågor. En\nsats kan definiera flera CTE:er, där var och en kan läsa dem som namngavs före\nden, och den sista frågan längst ned fogar ihop dem. Manualen beskriver dem som\ntillfälliga tabeller som bara finns för en enda fråga, och det är rätt bild med\nett förbehåll: ingenting lagras under namnet, och nästa sats kan inte se det.\nVarje CTE kan vara en SELECT, eller i PostgreSQL en INSERT, UPDATE, DELETE eller\nMERGE, och den sats som WITH-klausulen hör till kan också vara vilken som helst\nav dem.\n\nEn fråga som ”vilka mätare förbrukade någon dag under de senaste 30 dagarna mer än tre gånger sin egen normala mängd” delar naturligt upp sig i steg:\n\n```sql\nWITH daily AS (\n  SELECT meter_id, read_at::date AS day, sum(kwh) AS kwh\n  FROM readings\n  WHERE read_at \u003e= current_date - 30\n  GROUP BY meter_id, read_at::date\n),\ntypical AS (\n  SELECT meter_id, avg(kwh) AS avg_kwh\n  FROM daily\n  GROUP BY meter_id\n)\nSELECT d.meter_id, d.day, d.kwh, t.avg_kwh\nFROM daily AS d\nJOIN typical AS t USING (meter_id)\nWHERE d.kwh \u003e 3 * t.avg_kwh\nORDER BY d.day, d.meter_id;\n```\n\nDet första steget summerar varje mätares avläsningar per dag, det andra räknar\nut medelvärdet av de summorna per mätare, och det sista jämför varje dag med den\negna mätarens medelvärde. Samma svar kan skrivas med nästlade underfrågor, men\ndå skulle de dagliga summorna stå två gånger i texten, den ena inuti den andra,\noch en läsare skulle få arbeta sig inifrån och ut. Med WITH läses logiken\nuppifrån och ned, och varje steg kan köras för sig medan det kontrolleras.\n\nMed RECURSIVE kan en CTE läsa sitt eget resultat, och det är den del som vanlig\nSQL inte har något annat sätt att uttrycka. En rekursiv CTE har en startfråga,\nsedan UNION eller UNION ALL, sedan en fråga som hänvisar tillbaka till CTE:n.\nPostgreSQL kör startfrågan, håller dess rader i en arbetstabell och kör sedan\nden andra frågan mot de senaste raderna, om och om igen, tills en omgång inte\nlägger till några. Så går en sats igenom ett träd av okänt djup, t.ex.\nkategorierna under en rubrik:\n\n```sql\nWITH RECURSIVE subtree AS (\n  SELECT id, parent_id, name, 1 AS depth\n  FROM categories\n  WHERE id = 42\n  UNION ALL\n  SELECT c.id, c.parent_id, c.name, s.depth + 1\n  FROM categories AS c\n  JOIN subtree AS s ON c.parent_id = s.id\n)\nSELECT id, name, depth FROM subtree ORDER BY depth, name;\n```\n\n## Varför det spelar roll\n\nDet första skälet är läsbarhet. En analytisk fråga på hundra rader som är\nnästlad fyra nivåer djupt är svår att granska och ännu svårare att ändra. Samma\nlogik som en kedja av namngivna steg ger granskaren en mening per steg, ger\nförfattaren en plats för en kommentar och låter vem som helst köra ett steg\nensamt för att se om dess rader ser rimliga ut innan nästa steg får förtroende.\n\nDet andra skälet är hur databasen utvärderar stegen, och här har detaljerna\nändrats över tid. PostgreSQL utvärderar normalt en WITH-fråga en gång per\nkörning av satsen, även när satsen hänvisar till den mer än en gång, så en dyr\nberäkning som behövs på två ställen görs en gång. Priset för den garantin är att\nplaneraren inte kan flytta in ett filter från den yttre frågan i en CTE som det\nhänvisas till flera gånger, eftersom filtret bara ska gälla en av\nanvändningarna. CTE:n beräknas i sin helhet, och raderna kastas efteråt.\n\nFram till PostgreSQL 12 gällde det varje CTE: var och en utvärderades före\nresten av frågan och slogs aldrig ihop med den. Version 12 ändrade\nstandardbeteendet. En CTE som inte är rekursiv, saknar sidoeffekter och bara\nanvänds en gång bakas nu in i den yttre frågan, så att planeraren optimerar båda\nnivåerna tillsammans och kan föra ned det yttre filtret till ett index på\nbastabellen. MATERIALIZED tvingar fram det gamla beteendet, och NOT MATERIALIZED\ntvingar fram inbakning även för en CTE som används mer än en gång, med risk för\natt dess arbete görs två gånger. SQLite godtar samma två nyckelord som\nicke-bindande tips och säger att idén är lånad från PostgreSQL. Andra motorer\navgör själva, och det är i planen man ser vad som blev av frågan.\n\nDet tredje skälet är att en CTE kan ändra data. En DELETE med RETURNING i en\nWITH-klausul kan mata en INSERT i huvudsatsen, vilket flyttar rader från en\ntabell till en annan i en enda sats som antingen genomförs helt eller inte alls.\nDatamodifierande CTE:er körs exakt en gång och alltid till slut, oavsett om\nnågot läser deras resultat, och det gör dem till ett verktyg för att göra flera\nskrivningar tillsammans snarare än ett sätt att beskriva ett resultat.\n\n## Så ser det ut i praktiken\n\nArbetet bakom\n[en PostgreSQL-databas som gjordes 10 gånger snabbare](/sv/portfolio/accelerated-postgresql-performance-by-10x/)\ngällde en databas för användarkonton, tenants, platser och dagliga mätvärden för\nelförbrukning, som blev långsammare i takt med att datamängden växte. Åtgärden\nbestod av tre delar: riktade index och GiST-index, tidsbaserad partitionering av\ntabellen med eldata och omskrivna frågor. Omskrivningarna använde CTE:er och\nmaterialiserade vyer för data som användes ofta, för att undvika fullständiga\ntabellskanningar, och `EXPLAIN ANALYZE` pekade ut de joins och underfrågor som\nvar värda att strukturera om. Den tiofaldiga förbättringen av svarstiderna och\nden 40 % lägre resursanvändningen kom från de tre delarna tillsammans, inte från\nCTE:er ensamma. Kombinationen är värd att notera, eftersom de två gör olika\njobb: en CTE ger ett mellanresultat ett namn under en enda sats, medan en\nmaterialiserad vy lagrar ett resultat som många satser kan läsa tills vyn\nuppdateras.\n\nDen andra sidan av CTE:er, läsbarheten, bar\n[de 500 rapporterna med analyser av el- och GIS-data](/sv/portfolio/released-500-electricity-and-gis-data-reports/).\nVarje rapport skrevs i ren SQL mot PostgreSQL och BigQuery, över data från\nsmarta elmätare med koordinater, mätar-ID:n och tidsstämplad förbrukning, och\nskripten använde CTE:er tillsammans med fönsterfunktioner, underfrågor och\ngeospatiala joins. Varje rapport levererades med kommenterad SQL så att kollegor\nkunde reproducera och granska analysen, plus anteckningar om vanliga\ndatakvalitetsproblem som saknade GPS-koordinater och korrupta mätvärden. SQL som\nläses steg för steg är lätt att dela och använda vidare. Rapporterna blev ett\nstandardunderlag på flera avdelningar och bidrog till att den operativa\nplaneringen blev 10–15 % effektivare. Det\när namngivna steg som över huvud taget gör sådan SQL möjlig att kommentera: en\nanteckning kan stå ovanför varje steg och säga vad steget tar bort eller\nförutsätter.\n\n## Var det går fel\n\n**Filtret tillämpas först när allt arbete är gjort.** En CTE som det hänvisas\ntill två gånger, eller som är märkt MATERIALIZED, beräknas i sin helhet innan\nden yttre frågan filtrerar den, och kopian den ger har inga index. En fråga som\nborde röra några få rader läser en hel tabell. Läs planen: när CTE:n syns som\nett eget steg, med radantal långt över vad frågan returnerar, pröva NOT\nMATERIALIZED eller skriv om frågan så att det bara hänvisas till CTE:n en gång.\nBehåll den materialiserade formen där CTE:n anropar en dyr funktion, så att\nfunktionen körs en gång per rad och inte en gång per hänvisning.\n\n**En rekursiv fråga fortsätter varv efter varv.** Data med en cykel, t.ex. två\nkategorier som var och en står som den andras förälder, skickar en rekursiv CTE\nmed UNION ALL runt slingan så länge servern tillåter det. UNION hjälper bara när\nhela rader upprepas, vilket sällan stämmer när en kolumn för djup har lagts\ntill. Håll reda på vägen av besökta nycklar i en array och stanna när en nyckel\ndyker upp igen, eller använd CYCLE-klausulen som kom i PostgreSQL 14. En LIMIT\npå den yttre frågan fungerar som ett knep vid testning, och manualen avråder\nfrån att förlita sig på den i produktion. SQL Server begränsar rekursionen till\n100 nivåer som standard och avbryter satsen bortom det, så samma bugg stannar i\nstället för att fortsätta.\n\n**Ändringar som resten av satsen inte ser.** En datamodifierande CTE och\nhuvudfrågan körs samtidigt mot samma ögonblicksbild, så en huvudfråga som läser\nmåltabellen direkt ser raderna som de var före ändringen. Den enda kanalen\nmellan dem är RETURNING. Två delar av samma sats som ändrar samma rad är värre:\nbara en av ändringarna får effekt, och vilken är svårt att förutsäga. Läs\nändrade rader ur CTE:ns RETURNING-utdata, och låt varje rad ha en enda skrivare\nper sats.\n\n**En plan som flyttade sig vid en uppgradering.** Kod som skrevs för PostgreSQL\n11 eller tidigare förlitade sig ibland på att en CTE utvärderades först, som en\navsiktlig spärr mot en plan som författaren inte ville ha. Efter en uppgradering\ntill 12 eller senare bakas samma CTE in i den yttre frågan och planeraren väljer\nnågot nytt, oftast snabbare och ibland mycket långsammare. Jämför utdata från\nEXPLAIN för de långsamma satserna före och efter uppgraderingen, och lägg till\nMATERIALIZED där spärren var avsiktlig.\n\n## Läs mer\n\n- [7.8. WITH Queries (Common Table Expressions)](https://www.postgresql.org/docs/current/queries-with.html)\n  — manualens kapitel om CTE:er: rekursion, upptäckt av cykler, materialisering\n  och datamodifierande satser.\n- [E.23. Release 12](https://www.postgresql.org/docs/12/release-12.html) —\n  versionen som började baka in CTE:er som används en gång i den yttre frågan.\n- [E.25. Release 14](https://www.postgresql.org/docs/14/release-14.html) —\n  versionen som lade till klausulerna SEARCH och CYCLE ur SQL-standarden.\n- [The WITH Clause](https://www.sqlite.org/lang_with.html) — SQLites variant,\n  med dess tips om materialisering och varifrån de är lånade.\n- [WITH common_table_expression (Transact-SQL)](https://learn.microsoft.com/en-us/sql/t-sql/queries/with-common-table-expression-transact-sql)\n  — SQL Servers regler för CTE:er, bl.a. gränsen MAXRECURSION för rekursion.\n\n\u003chttps://engineer.company/sv/glossary/cte/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur WITH delar upp en lång SQL-fråga i namngivna steg, vad PostgreSQL 12 ändrade i hur stegen planeras och hur en rekursiv fråga går igenom ett träd.","formats":{"gemtext":"https://engineer.company/sv/glossary/cte/index.gmi","gopher":"https://engineer.company/sv/glossary/cte/gophermap","html":"https://engineer.company/sv/glossary/cte/","json":"https://engineer.company/sv/glossary/cte/index.json","markdown":"https://engineer.company/sv/glossary/cte/index.md","pdf":"https://engineer.company/sv/glossary/cte/index.pdf"},"kind":"page","language":"sv","title":"Vad är CTE?","url":"https://engineer.company/sv/glossary/cte/","version":1}