मुख्य सामग्री पर जाएं
मॉड्यूल 7 · पाठ 4 का 4पाठ्यक्रम में 28/57~14 min
मॉड्यूल पाठ (4/4)

पुनरावर्ती सीटीई: मनमानी-गहराई पदानुक्रम

एक सेल्फ-जॉइन (मॉड्यूल 5) पदानुक्रम का केवल एक स्तर पाता है: बच्चा → अभिभावक. लेकिन क्या होता है यदि पदानुक्रम 3, 5, या n स्तर गहरा है, और आप पहले से नहीं जानते कि कितने? आपको पुनरावर्ती सीटीई की आवश्यकता है: a CTE जो स्वयं को परिणामों को पुनरावर्ती रूप से "विस्तारित" करने के लिए संदर्भित करता है।

ecommerce डेटासेट में, categories तालिका में 3 मूल हैं (एलेट्रोनिका, लिबरी, कासा) और प्रत्येक में 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. यह केवल उत्पादित पंक्तियों का उपयोग करके पुनरावर्ती शब्द निष्पादित करता है "इनपुट" (संपूर्ण सीटीई नहीं: केवल वेतन वृद्धि)।
  3. यह चरण 2 को तब तक दोहराता है जब तक कि पुनरावर्ती शब्द 0 नई पंक्तियाँ उत्पन्न न कर दे।
  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 का उपयोग करें। आईडी, नाम, गहराई (जड़ों के लिए 1, बच्चों के लिए 2, आदि) और पथ (उदाहरण के लिए 'एलेट्रोनिका > ऑडियो') दिखाएं। पथ के अनुसार आदेश दें.

संपादक लोड हो रहा है...
संकेत दिखाएँ

पुनरावर्ती शब्द में JOIN c.parent_id को पेड़ (t.id) में पहले से मौजूद पंक्ति से जोड़ता है।

3 प्रयासों के बाद समाधान उपलब्ध है

व्यायाम की समीक्षा करें

व्यायाम#sql.m7.l4.e2
प्रयास: 0लोड हो रहा है...

प्रत्येक श्रेणी के लिए, आईडी, नाम और रूट_नाम (जिस पेड़ से वह संबंधित है, उसके शीर्ष पर मूल श्रेणी का नाम) दिखाएं। जड़ों का root_name = नाम होता है। आईडी द्वारा ऑर्डर करें.

संपादक लोड हो रहा है...
संकेत दिखाएँ

मूल नाम (t.root_name) से बच्चे (c) तक प्रचारित करें।

3 प्रयासों के बाद समाधान उपलब्ध है