{"canonical_url":"https://engineer.company/da/glossary/cte/","content_markdown":"# CTE\n\n## Hvad det er\n\nEn CTE, kort for common table expression, er en forespørgsel, der får et navn\ni en WITH-klausul øverst i en sætning, så resten af sætningen kan læse dens\nrækker, som om de kom fra en tabel. En sætning kan definere flere CTE'er, hver\naf dem kan læse dem, der er navngivet før den, og den sidste forespørgsel\nnederst sætter dem sammen. PostgreSQL's manual beskriver dem som midlertidige\ntabeller, der kun findes for én forespørgsel. Billedet holder med ét forbehold:\nDer gemmes ikke noget under navnet, og den næste sætning kan ikke se det. En\nCTE kan være en SELECT, eller i PostgreSQL også en INSERT, UPDATE, DELETE eller\nMERGE, og sætningen, som WITH-klausulen hænger på, kan være en hvilken som\nhelst af dem.\n\nEt spørgsmål som »hvilke målere brugte på en enkelt dag i de seneste 30 dage mere end tre gange deres eget normale forbrug« deler sig naturligt i trin:\n\n```sql\nWITH dagligt AS (\n  SELECT maaler_id, maalt_kl::date AS dag, sum(kwh) AS kwh\n  FROM forbrug\n  WHERE maalt_kl \u003e= current_date - 30\n  GROUP BY maaler_id, maalt_kl::date\n),\nnormalt AS (\n  SELECT maaler_id, avg(kwh) AS snit_kwh\n  FROM dagligt\n  GROUP BY maaler_id\n)\nSELECT d.maaler_id, d.dag, d.kwh, n.snit_kwh\nFROM dagligt AS d\nJOIN normalt AS n USING (maaler_id)\nWHERE d.kwh \u003e 3 * n.snit_kwh\nORDER BY d.dag, d.maaler_id;\n```\n\nFørste trin lægger hver målers aflæsninger sammen pr. dag, andet trin tager\ngennemsnittet af de dagstal pr. måler, og det sidste sammenligner hver dag med\nsin egen målers gennemsnit. Samme svar kan skrives med indlejrede\ndelforespørgsler, men så står dagstallene to gange i teksten, den ene inde i\nden anden, og læseren må arbejde sig indefra og ud. Med WITH læses logikken\noppefra og ned, og hvert trin kan køres for sig, mens man kontrollerer det.\n\nTilføjer man RECURSIVE, kan en CTE læse sit eget output, og det er den del,\nalmindelig SQL ellers ikke har nogen måde at udtrykke på. En rekursiv CTE har\nen startforespørgsel, derefter UNION eller UNION ALL og så en forespørgsel, der\nhenviser tilbage til CTE'en. PostgreSQL kører startforespørgslen, lægger dens\nrækker i en arbejdstabel og bliver ved med at køre den anden forespørgsel mod\nde nyeste rækker, indtil en runde ikke tilføjer flere. Sådan går en sætning\ngennem et træ af ukendt dybde, for eksempel kategorierne under én overskrift:\n\n```sql\nWITH RECURSIVE undertrae AS (\n  SELECT id, foraelder_id, navn, 1 AS dybde\n  FROM kategorier\n  WHERE id = 42\n  UNION ALL\n  SELECT k.id, k.foraelder_id, k.navn, u.dybde + 1\n  FROM kategorier AS k\n  JOIN undertrae AS u ON k.foraelder_id = u.id\n)\nSELECT id, navn, dybde FROM undertrae ORDER BY dybde, navn;\n```\n\n## Hvorfor det betyder noget\n\nDen første grund er læsbarhed. En analytisk forespørgsel på hundrede linjer,\nder er indlejret fire niveauer ned, er svær at gennemgå og sværere at ændre.\nDen samme logik som en kæde af navngivne trin giver den, der gennemgår koden,\nén sætning pr. trin, giver forfatteren et sted at skrive en kommentar og lader\nenhver køre ét trin alene for at se, om rækkerne ser rigtige ud, før man\nstoler på det næste.\n\nDen anden grund er, hvordan databasen evaluerer trinnene, og her har detaljerne\nændret sig over tid. PostgreSQL evaluerer normalt en WITH-forespørgsel én gang\npr. kørsel af sætningen, også når sætningen henviser til den flere gange, så\nen dyr beregning, der skal bruges to steder, kun kører én gang. Prisen for den\ngaranti er, at planlæggeren ikke kan skubbe et filter fra den ydre forespørgsel\nned i en CTE, der bruges flere steder, fordi filteret kun skal gælde én af\nbrugene. CTE'en beregnes fuldt ud, og rækkerne smides væk bagefter.\n\nIndtil PostgreSQL 12 gjaldt det for alle CTE'er: Hver blev evalueret før resten\naf forespørgslen og aldrig flettet ind i den. Version 12 ændrede standarden. En\nCTE, der ikke er rekursiv, ikke har sideeffekter og kun bruges én gang, foldes\nnu ind i den ydre forespørgsel, så planlæggeren optimerer de to niveauer samlet\nog kan bruge et indeks på det filter, den før ikke kunne se. MATERIALIZED\ntvinger den gamle opførsel frem, og NOT MATERIALIZED tvinger foldningen\nigennem, også for en CTE, der bruges flere gange, med risiko for at arbejdet\nkører to gange. SQLite accepterer de samme to nøgleord som uforpligtende hints\nog skriver selv, at idéen er lånt fra PostgreSQL. Andre motorer beslutter selv,\nog planen er stedet at kontrollere det.\n\nDen tredje grund er, at en CTE kan ændre data. En DELETE med RETURNING i en\nWITH-klausul kan fodre en INSERT i hovedsætningen, og så flyttes rækker fra én\ntabel til en anden i én sætning, der enten sker helt eller slet ikke.\nDataændrende CTE'er kører præcis én gang og altid til ende, uanset om noget\nlæser deres output. Det gør dem til et redskab til at udføre flere skrivninger\nsamlet, snarere end en måde at beskrive et resultat på.\n\n## Sådan ser det ud i praksis\n\nArbejdet bag\n[PostgreSQL-ydeevnen, der blev accelereret 10 gange](/da/portfolio/accelerated-postgresql-performance-by-10x/)\ngjaldt en database med brugerkonti, tenants, lokationer og daglige eldata,\nder blev langsom, efterhånden som datamængderne voksede. Løsningen havde tre\ndele: målrettede indeks, herunder GiST-indeks til de geospatiale data,\ntidsbaseret partitionering af eltabellen pr. dag eller måned, og omskrivning af\nforespørgsler. Komplekse forespørgsler blev skrevet om for at undgå full table\nscans, med CTE'er og materialized views, mens EXPLAIN ANALYZE pegede på de\nineffektive joins. Svartider, der blev 10 gange bedre, og et ressourceforbrug,\nder faldt med 40 %, kom fra de tre dele tilsammen og ikke fra CTE'er alene.\nKombinationen er værd at bemærke, fordi de to gør forskelligt arbejde: En CTE\nnavngiver et mellemresultat, så længe én sætning varer, mens et materialized\nview gemmer et resultat, som mange sætninger kan læse, indtil det opdateres.\n\nDen anden side af CTE'er, læsbarheden, bar\n[de 500 rapporter om el- og GIS-dataanalyse](/da/portfolio/released-500-electricity-and-gis-data-reports/).\nHver rapport blev skrevet i ren SQL direkte i PostgreSQL og BigQuery, over\ndata fra smart-målere med geolokationskoordinater, måler-ID'er og tidsstemplet\nforbrug, og scriptsene brugte CTE'er sammen med window functions,\ndelforespørgsler og geospatiale joins. Hver rapport kom med annoteret SQL-kode,\nså kolleger kunne reproducere og revidere analysen, og med noter om almindelige\ndatakvalitetsproblemer som manglende GPS-koordinater og beskadigede\nmålerværdier. Rapporterne blev en standardreference på tværs af afdelinger og\nbidrog til en forbedring af driftsplanlægningens effektivitet på 10–15 %.\nNavngivne trin er det, der overhovedet gør den slags SQL mulig at annotere: En\nnote kan stå over hvert trin og sige, hvad det fjerner, eller hvad det\nforudsætter.\n\n## Hvor det går galt\n\n**Et filter, der først rammer, når arbejdet er gjort.** En CTE, der bruges to\ngange eller er markeret MATERIALIZED, beregnes fuldt ud, før den ydre\nforespørgsel filtrerer den, og den kopi, den laver, har ingen indeks. En\nforespørgsel, der burde røre få rækker, læser en hel tabel. Læs planen: Står\nCTE'en som sit eget trin med rækkeantal langt over det, forespørgslen\nreturnerer, så prøv NOT MATERIALIZED, eller skriv forespørgslen om, så CTE'en\nbruges én gang. Behold den materialiserede form, hvor CTE'en kalder en dyr\nfunktion, så funktionen kører én gang pr. række og ikke én gang pr. henvisning.\n\n**En rekursiv forespørgsel, der bliver ved.** Data med en cyklus, for eksempel\nto kategorier, der hver står som den andens forælder, sender en rekursiv CTE\nmed UNION ALL rundt i løkken, så længe serveren tillader det. UNION hjælper kun,\nnår hele rækker gentager sig, og det holder sjældent, når der er en\ndybdekolonne med. Gem stien af besøgte nøgler i et array og stop, når en nøgle\ndukker op igen, eller brug CYCLE-klausulen, som PostgreSQL 14 tilføjede. En\nLIMIT på den ydre forespørgsel virker som et trick under test, og manualen\nfraråder at regne med det i produktion. SQL Server begrænser rekursion til 100\nniveauer som standard og afbryder sætningen derefter, så den samme fejl stopper\ni stedet for at køre videre.\n\n**Ændringer, som resten af sætningen ikke ser.** En dataændrende CTE og\nhovedforespørgslen kører samtidig på det samme snapshot, så en hovedforespørgsel,\nder læser måltabellen direkte, ser rækkerne, som de var før ændringen. Den\neneste kanal mellem dem er RETURNING. Værre er det, når to dele af én sætning\nændrer den samme række: Kun én af ændringerne slår igennem, og hvilken er svær\nat forudsige. Læs ændrede rækker fra CTE'ens RETURNING-output, og lad hver\nrække have én skriver pr. sætning.\n\n**En plan, der flyttede sig med en opgradering.** Kode skrevet til PostgreSQL 11\neller tidligere regnede nogle gange med, at en CTE blev evalueret først, som en\nbevidst barriere mod en plan, forfatteren ikke ville have. Efter en opgradering\ntil 12 eller nyere foldes den samme CTE ind i den ydre forespørgsel, og\nplanlæggeren vælger noget nyt, som regel hurtigere og en gang imellem meget\nlangsommere. Sammenlign EXPLAIN-output for de langsomme sætninger før og efter\nopgraderingen, og tilføj MATERIALIZED, hvor barrieren var tilsigtet.\n\n## Læs mere\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, cyklusdetektion, materialisering og\n  dataændrende sætninger.\n- [E.23. Release 12](https://www.postgresql.org/docs/12/release-12.html)\n  — udgivelsen, der begyndte at folde CTE'er, der bruges én gang, ind i den\n  ydre forespørgsel.\n- [E.25. Release 14](https://www.postgresql.org/docs/14/release-14.html)\n  — udgivelsen, der tilføjede SQL-standardens SEARCH- og CYCLE-klausuler.\n- [The WITH Clause](https://www.sqlite.org/lang_with.html)\n  — SQLite's udgave, med dens materialiseringshints og hvor de er lånt fra.\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 for CTE'er, herunder MAXRECURSION-grænsen for rekursion.\n\n\u003chttps://engineer.company/da/glossary/cte/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad en CTE er i SQL, hvornår PostgreSQL folder den ind i den ydre forespørgsel eller beregner den én gang, hvordan rekursion virker, og faldgruberne.","formats":{"gemtext":"https://engineer.company/da/glossary/cte/index.gmi","gopher":"https://engineer.company/da/glossary/cte/gophermap","html":"https://engineer.company/da/glossary/cte/","json":"https://engineer.company/da/glossary/cte/index.json","markdown":"https://engineer.company/da/glossary/cte/index.md","pdf":"https://engineer.company/da/glossary/cte/index.pdf"},"kind":"page","language":"da","title":"Hvad er en CTE?","url":"https://engineer.company/da/glossary/cte/","version":1}