Vad är Common Table Expressions (CTEs)?

Question

Accepted Answer

En **CTE** (Common Table Expression), definierad med **`WITH`**, är en namngiven temporär resultatmängd som du kan referera till inom en fråga. CTEs gör komplexa frågor mer **läsbara** genom att dela upp dem i namngivna, logiska steg — och de möjliggör **rekursiva** frågor (för hierarkier).

## En grundläggande CTE — ge ett namn åt en subfråga för läsbarhet

```sql
WITH active_users AS (              -- define a named temporary result set
    SELECT id, name FROM users WHERE active = true
)
SELECT * FROM active_users          -- reference it like a table
WHERE name LIKE 'A%';
```

`WITH ... AS (...)` definierar en CTE — en namngiven fråga som du refererar till senare. Det är som en subfråga, men **namngiven och läsbar**, speciellt för komplexa frågor.

## Flera CTEs — länka logiska steg

```sql
WITH
  monthly_sales AS (
    SELECT month, SUM(amount) AS total FROM orders GROUP BY month
  ),
  avg_sales AS (
    SELECT AVG(total) AS avg_total FROM monthly_sales   -- a CTE can reference another
  )
SELECT m.month, m.total
FROM monthly_sales m, avg_sales a
WHERE m.total > a.avg_total;        -- months above the average
```

Flera CTEs delar upp en komplex fråga i läsbara, sekventiella steg — varje bygger på det föregående. Detta är mycket tydligare än djupt nästlade subfrågor.

## CTEs vs subfrågor (läsbarhet)

```text
Nested subqueries → hard to read when deeply nested
CTEs → name each step, read top-to-bottom like a sequence → much clearer
→ CTEs are often preferred for COMPLEX queries purely for readability/maintainability.
```

## Rekursiva CTEs — för hierarkier

```sql
-- traverse a hierarchy (e.g. all descendants of a category, an org chart)
WITH RECURSIVE subordinates AS (
    SELECT id, name, manager_id FROM employees WHERE id = 1   -- base case (the top)
    UNION ALL
    SELECT e.id, e.name, e.manager_id
    FROM employees e
    JOIN subordinates s ON e.manager_id = s.id               -- recursive step
)
SELECT * FROM subordinates;          -- the whole tree under employee 1
```

**Rekursiva CTEs** (`WITH RECURSIVE`) traverserar hierarkiska/träddata (organisationsscheman, kategoriträd, strukturlistor, grafvägar) — något som annars är mycket svårt i SQL.

## Varför det spelar roll

CTEs är en viktig SQL-funktion för **läsbarhet och rekursion**, och att förstå dem är värdefullt för att skriva underhållbar komplexa frågor och för att hantera hierarkiska data.

Den primära dagliga nyttan är **läsbarhet**: komplexa frågor med flera nivåer av subfrågor blir svåra att läsa och underhålla, medan CTEs låter dig dela upp frågan i namngivna, sekventiella logiska steg (läs uppifrån och ned som en serie operationer), vilket dramatiskt förbättrar tydligheten — av denna anledning föredras CTEs ofta framför djupt nästlade subfrågor för komplexa frågor, vilket gör dem till ett viktigt verktyg för att skriva underhållbar SQL.

Lika viktig är **rekursiv CTE**-kapaciteten (`WITH RECURSIVE`), som möjliggör frågor av **hierarkiska och trädstrukturerade data** (organisationsscheman, kategoriträd, strukturlistor, graftraversering) — en klass av frågor som annars är mycket svår eller omöjlig i standard-SQL, vilket gör rekursiva CTEs till standardlösningen för hierarkisk datatraversering.

Att förstå båda användningarna — CTEs för att dekomponera komplexa frågor i läsbara steg, och rekursiva CTEs för hierarkisk traversering — täcker det praktiska värdet.

Efftersom komplexa frågor är vanliga i verkliga applikationer (och läsbarhet/underhållbarhet spelar roll), och eftersom hierarkiska data (som rekursiva CTEs hanterar väl unikt) förekommer ofta (organisationsstrukturer, nästlade kategorier, trådade data), är förståelse för CTEs värdefullt kunskapskapital på högt nivå som förbättrar frågunderhållbarhet och låser upp hierarkisk frågning — ett ofta relevant verktyg för att skriva ren, sofistikerad SQL och ett vanligt ämne som demonstrerar avancerad SQL-förmåga, särskilt den rekursiva formen för trädstrukturerad data.