PricingLoginStart free
SQL Academy · Lektion

Sådan fungerer rekursive CTE'er

Basistilfælde plus rekursivt trin.

Lektion 1 af 413 trin

Sådan fungerer rekursive CTE'er er en gratis SQL Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i SQL Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. SQL Academy-kurset indeholder 4 lektioner i alt.

Hvad er en rekursiv CTE

En rekursiv CTE er et fælles tabeludtryk, der refererer til sig selv. Det lader dig skrive forespørgsler, der gentager et trin, indtil en betingelse er opfyldt — ligesom en løkke, men udtrykt som ren SQL.

Rekursive CTE'er defineres med nøgleordet WITH RECURSIVE og er ideelle til at gennemgå hierarkiske eller graf-lignende data som organisationsdiagrammer, mappetræer og styklister.

Struktur i to dele

Enhver rekursiv CTE består præcis af to dele, der er adskilt af UNION ALL:

1. Basistilfælde — en ikke-rekursiv SELECT, der returnerer startrækkerne.

2. Rekursivt trin — en SELECT, der joiner CTE'en med sig selv og producerer det næste niveau af rækker.

Databasemotoren fortsætter med at køre det rekursive trin og samle resultater, indtil det ikke producerer flere nye rækker.

WITH RECURSIVE cte_name AS (
  -- Base case
  SELECT ...
  UNION ALL
  -- Recursive step (references cte_name)
  SELECT ... FROM source JOIN cte_name ON ...
)
SELECT * FROM cte_name;

Tæl fra 1 til 5

Den enkleste rekursive CTE tæller tal. Basistilfældet initialiserer værdien 1. Det rekursive trin lægger 1 til i hver iteration. WHERE-klausulen i det rekursive trin fungerer som afslutningsbetingelse — uden den ville forespørgslen køre for evigt.

WITH RECURSIVE counter(n) AS (
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM counter WHERE n < 5
)
SELECT n FROM counter;

Trinvis udførelse

Sådan behandler databasemotoren tæller-CTE'en iteration for iteration:

Iteration 0 (basistilfælde): returnerer {1}.

Iteration 1: anvender det rekursive trin på {1} og returnerer {2}.

Iteration 2: anvender det rekursive trin på {2} og returnerer {3}.

Iteration 3 og 4: returnerer først {4} og derefter {5}.

Iteration 5: WHERE n < 5 er falsk for n=5, så der returneres ingen rækker. Forespørgslen afsluttes.

Alle samlede rækker — 1, 2, 3, 4, 5 — udgør det endelige resultat.

Opsætning af en hierarkitabel

Rekursive CTE'er er særligt nyttige på selvrefererende tabeller. Lad os oprette en employees-tabel, hvor hver medarbejder har en valgfri manager_id, der peger tilbage på den samme tabel.

CREATE TABLE employees (
  id       INTEGER PRIMARY KEY,
  name     VARCHAR(50),
  manager_id INTEGER REFERENCES employees(id)
);

INSERT INTO employees VALUES
  (1, 'Alice',   NULL),
  (2, 'Bob',     1),
  (3, 'Carol',   1),
  (4, 'Dave',    2),
  (5, 'Eve',     2),
  (6, 'Frank',   3);

Gennemgang af hierarkiet

Nu kan vi gennemgå hele rapporteringskæden med udgangspunkt i den administrerende direktør (Alice, id=1). Basistilfældet vælger Alice, og det rekursive trin finder alle medarbejdere, hvis manager_id matcher et id, der allerede findes i CTE'en.

Resultatet omfatter alle medarbejdere, der kan nås fra Alice, uanset hvor dybt træet går.

WITH RECURSIVE org_tree AS (
  SELECT id, name, manager_id, 0 AS depth
  FROM employees
  WHERE manager_id IS NULL
  UNION ALL
  SELECT e.id, e.name, e.manager_id, ot.depth + 1
  FROM employees e
  JOIN org_tree ot ON e.manager_id = ot.id
)
SELECT depth, name FROM org_tree ORDER BY depth, name;

Sporing af stien

En almindelig forbedring er at opbygge en stistreng, der viser hele kæden fra roden til hver node. Vi sammenkæder navne adskilt af ' -> ', mens vi bevæger os længere ned i rekursionen.

Det gør det nemt at vise brødkrummenavigation eller fejlfinde dybe hierarkier.

WITH RECURSIVE org_tree AS (
  SELECT id, name, name AS path
  FROM employees
  WHERE manager_id IS NULL
  UNION ALL
  SELECT e.id, e.name, ot.path || ' -> ' || e.name
  FROM employees e
  JOIN org_tree ot ON e.manager_id = ot.id
)
SELECT name, path FROM org_tree ORDER BY path;

Begrænsning af rekursionsdybden

Dybe eller cirkulære data kan få en rekursiv CTE til at køre meget længe. To sikre fremgangsmåder:

1. Spor dybden, og tilføj en WHERE-klausul — WHERE depth < 10 sikrer, at du aldrig går længere end 10 niveauer.

2. Brug en kolonne til cyklusdetektion — nogle databaser (PostgreSQL 14+) tilbyder CYCLE-syntaks til automatisk at registrere gentagne besøg på noder.

WITH RECURSIVE org_tree AS (
  SELECT id, name, 0 AS depth
  FROM employees
  WHERE manager_id IS NULL
  UNION ALL
  SELECT e.id, e.name, ot.depth + 1
  FROM employees e
  JOIN org_tree ot ON e.manager_id = ot.id
  WHERE ot.depth < 10
)
SELECT depth, name FROM org_tree;

UNION og UNION ALL i rekursive CTE'er

Det rekursive trin bruger næsten altid UNION ALL, ikke UNION. Her er hvorfor:

UNION fjerner dubletter efter hver iteration ved at sammenligne hele resultatsættet — det er ekstremt dyrt og kan ændre betydningen for grafer, hvor den samme node legitimt nås via flere stier.

UNION ALL beholder alle rækker uden at fjerne dubletter, hvilket både er hurtigere og korrekt ved gennemgang af træer. Brug kun UNION, når du har et specifikt behov for at fjerne dubletter og forstår omkostningen for ydeevnen.

Generering af en datoserie

Rekursive CTE'er er også praktiske til at generere sekvenser af datoer. Dette eksempel producerer hver dag i en given uge — et mønster, der ofte bruges til at opbygge kalenderrapporter eller udfylde huller i tidsseriedata.

WITH RECURSIVE date_series AS (
  SELECT DATE '2024-01-01' AS day
  UNION ALL
  SELECT day + INTERVAL '1 day'
  FROM date_series
  WHERE day < DATE '2024-01-07'
)
SELECT day FROM date_series;

Find alle underordnede medarbejdere for én leder

Du kan starte basistilfældet med en bestemt node — ikke kun roden. Her starter vi med Bob (id=2) og finder alle, der rapporterer direkte eller indirekte til ham.

Dette mønster er nyttigt til kontrol af tilladelser, aggregeringer af undertræer eller til at afgrænse dashboards til en enkelt afdeling.

WITH RECURSIVE subordinates AS (
  SELECT id, name
  FROM employees
  WHERE id = 2
  UNION ALL
  SELECT e.id, e.name
  FROM employees e
  JOIN subordinates s ON e.manager_id = s.id
)
SELECT name FROM subordinates;

Hurtigt tjek

Test din forståelse af, hvordan rekursive CTE'er fungerer.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion lærte du, hvordan rekursive CTE'er fungerer:

Struktur: Enhver rekursiv CTE har et basistilfælde (startrækker), der joines med et rekursivt trin (en selvrefererende SELECT) ved hjælp af UNION ALL.

Afslutning: Databasemotoren gentager det rekursive trin og samler resultater, indtil trinnet returnerer nul rækker.

Almindelige anvendelser: gennemgang af organisationsdiagrammer og mappetræer, generering af tal- eller datoserier, beregning af stier og søgning efter alle noder i et undertræ.

Sikkerhedstip: Medtag altid en afslutningsbetingelse (dybdebegrænsning eller cyklusbeskyttelse), og foretræk UNION ALL frem for UNION af hensyn til ydeevnen.

Gratis at komme i gang

Lær SQL med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
46
Lektioner
183
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Sådan fungerer rekursive CTE'er” gratis?

Ja — hele teksten til “Sådan fungerer rekursive CTE'er” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af SQL Academy-kurset, skal du opgradere til CoddyKit PRO. SQL Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Sådan fungerer rekursive CTE'er”?

Basistilfælde plus rekursivt trin. Du øver dig i SQL Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på SQL Academy?

Der kræves ingen tidligere erfaring. SQL Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Sådan fungerer rekursive CTE'er”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne SQL Academy-lektion?

Ja. Alle SQL Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Sådan fungerer rekursive CTE'er
  2. Gå gennem et kategoritræ
  3. Generering af serier og sekvenser
  4. Undgå uendelige løkker
← Tilbage til SQL Academy