ప్రధాన కంటెంట్‌కు వెళ్లండి
మాడ్యూల్ 7 · 4లో పాఠం 4కోర్సులో 28/57~14 min
మాడ్యూల్ పాఠాలు (4/4)

పునరావృత CTEలు: ఏకపక్ష-లోతు సోపానక్రమాలు

స్వీయ-జాయిన్ (మాడ్యూల్ 5) సోపానక్రమం యొక్క ఒకే స్థాయిని కనుగొంటుంది: చైల్డ్ → తల్లిదండ్రులు. సోపానక్రమం 3, 5 లేదా n స్థాయిలు లోతుగా ఉంటే ఏమి జరుగుతుంది, మరియు మీకు ఎన్ని ముందుగానే తెలియదా? మీకు ** పునరావృత CTEలు** అవసరం: a CTE ఫలితాలను పునరుక్తిగా "విస్తరించు" అని సూచిస్తుంది.

ecommerce డేటాసెట్‌లో, categories పట్టిక 3 మూలాలను కలిగి ఉంది (Elettronica, Libri, Casa) మరియు 2 పిల్లలు ప్రతి - 2-స్థాయి చెట్టు. ఇది ఒక సాధారణ కేసు కానీ నమూనా తెలుసుకోవడానికి సరిపోతుంది.

వాక్యనిర్మాణం

SQL
WITH RECURSIVE nome (col1, col2, …) AS (
  -- (1) Termine BASE: le righe di partenza
  SELECT …
  FROM   …
  WHERE  …

  UNION ALL

  -- (2) Termine RICORSIVO: si appoggia a "nome" stesso per espandere
  SELECT …
  FROM   tabella  t
  JOIN   nome    n  ON …
)
SELECT * FROM nome;

ఇది ఆచరణలో ఎలా పని చేస్తుంది:

  1. PostgreSQL బేస్ టర్మ్ని ఒకసారి అమలు చేస్తుంది.
  2. ఇది ఇప్పుడే ఉత్పత్తి చేయబడిన అడ్డు వరుసలను ఉపయోగించి ** పునరావృత పదం**ని అమలు చేస్తుంది "ఇన్‌పుట్" (మొత్తం CTE కాదు: ఇంక్రిమెంట్ మాత్రమే).
  3. పునరావృత పదం 0 కొత్త అడ్డు వరుసలను ఉత్పత్తి చేసే వరకు ఇది దశ 2ని పునరావృతం చేస్తుంది.
  4. తుది ఫలితం అన్ని దశల్లో UNION ALL.

ఉదాహరణ 1: లోతు మరియు మార్గం ఉన్న చెట్టు

SQL
WITH RECURSIVE tree AS (
  -- base: le radici (parent_id IS NULL)
  SELECT id,
         name,
         parent_id,
         1                 AS depth,
         name              AS path
  FROM   categories
  WHERE  parent_id IS NULL

  UNION ALL

  -- ricorsivo: per ogni categoria che ha come parent una riga già in tree
  SELECT c.id,
         c.name,
         c.parent_id,
         t.depth + 1,
         t.path || ' > ' || c.name
  FROM   categories c
  JOIN   tree       t ON c.parent_id = t.id
)
SELECT id, name, depth, path
FROM   tree
ORDER BY path;

మొదటి పునరావృతం 3 వరుసలను ఉత్పత్తి చేస్తుంది (స్థాయి 1 వద్ద మూలాలు). రెండవది పునరావృతం 6 మంది పిల్లలను కనుగొంటుంది (స్థాయి 2). మూడవ పునరావృతం కనుగొంటుంది ఏమీ → చేయలేదు.

ఉదాహరణ 2: నోడ్ ఇవ్వబడింది, దాని మూలాన్ని కనుగొనండి

"టాప్-డౌన్ → బాటమ్-అప్" వేరియంట్: మేము రూట్ ఐడిని క్రిందికి ప్రచారం చేస్తాము చెట్టు.

SQL
WITH RECURSIVE tree AS (
  SELECT id,
         name,
         parent_id,
         id   AS root_id,
         name AS root_name
  FROM   categories
  WHERE  parent_id IS NULL

  UNION ALL

  SELECT c.id,
         c.name,
         c.parent_id,
         t.root_id,    -- propago lo stesso id_radice
         t.root_name   -- e nome
  FROM   categories c
  JOIN   tree       t ON c.parent_id = t.id
)
SELECT id, name, root_name
FROM   tree
ORDER BY id;

దీనిని ప్రయత్నించండి

వ్యాయామం#sql.m7.l4.e1
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

వర్గం సోపానక్రమాన్ని చదును చేయడానికి 'ట్రీ' పేరుతో పునరావృత CTEని ఉపయోగించండి. id, పేరు, డెప్త్ (మూలాలకు 1, పిల్లలకు 2 మొదలైనవి) మరియు మార్గాన్ని (ఉదా. 'Elettronica > Audio') చూపండి. మార్గం ద్వారా ఆర్డర్ చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

పునరావృత పదంలోని JOIN c.parent_idని చెట్టు (t.id)లో ఇప్పటికే ఉన్న అడ్డు వరుసకు లింక్ చేస్తుంది.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం సమీక్షించండి

వ్యాయామం#sql.m7.l4.e2
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

ప్రతి వర్గానికి, id, పేరు మరియు root_name (చెట్టు పైభాగంలో ఉన్న మూల వర్గం పేరు) చూపండి. మూలాలకు root_name = పేరు ఉంటుంది. ID ద్వారా ఆర్డర్ చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

తల్లిదండ్రుల (t.root_name) నుండి పిల్లలకు (సి) రూట్_పేరును ప్రచారం చేయండి.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది