සම්බන්ධතා දත්ත ගබඩාවක ධූරාවලි දත්ත ගබඩා කිරීම සඳහා ඇති විකල්ප මොනවාද? [වසා ඇත]

හොඳ දළ විශ්ලේෂණ

පොදුවේ ගත් කල, ඔබ වේගයෙන් කියවන වේලාවන් (නිදසුනක් ලෙස, කැදැලි කට්ටලය) හෝ වේගවත් ලිවීමේ වේලාවන් (යාබද ලැයිස්තුව) අතර තීරණයක් ගන්නවා. සාමාන්‍යයෙන්, ඔබ අවසන් වන්නේ ඔබේ අවශ්‍යතාවන්ට වඩාත් ගැලපෙන පහත විකල්පයන්ගේ එකතුවෙනි. පහත දැක්වෙන්නේ ගැඹුරු කියවීමක් සපයයි:

• එදිරිව Adjacency ලැයිස්තුව සාපේක්ෂව වැඩි පතරෙහි ප්රාන්තර එක් : හොඳම සංසන්දනය Adjacency ලැයිස්තුව, වෙස් පාත්, කැදලි Set හා කැදලි පරතරය මම එක හොදයි සොයාගෙන ඇත.
• ධූරාවලි දත්ත සඳහා ආකෘති : වෙළඳාම සහ උදාහරණ භාවිතය පිළිබඳ හොඳ පැහැදිලි කිරීම් සහිත විනිවිදක
• MySQL හි ධූරාවලිය නියෝජනය කිරීම : විශේෂයෙන් නෙස්ටඩ් සෙට් පිළිබඳ ඉතා හොඳ දළ විශ්ලේෂණයක්
• ආර්.ඩී.බී.එම්.එස් හි ධූරාවලි දත්ත : මා දුටු වඩාත් සවිස්තරාත්මක හා සංවිධානාත්මක සබැඳි සමූහය, නමුත් පැහැදිලි කිරීමේ ආකාරයෙන් නොවේ

විකල්ප

මා දන්නා සහ පොදු ලක්ෂණ:

1. යාබද ලැයිස්තුව :
   • තීරු: ID, ParentID
   • ක්‍රියාත්මක කිරීමට පහසුය.
   • ලාභ නෝඩ් චලනයන්, ඇතුළු කිරීම් සහ මකාදැමීම්.
   • මට්ටම, පරම්පරාව සහ පැවත එන්නන් සොයා ගැනීමට මිල අධිකය
   • ඒවාට සහාය වන දත්ත සමුදායන්හි පොදු වගු ප්‍රකාශන හරහා N + 1 වළකින්න
2. නෙස්ටඩ් සෙට් ( නවීකරණය කරන ලද පෙර ඇණවුම් ගස් සංචලනය )
   • තීරු: වම, දකුණ
   • ලාභ පරම්පරාව, පැවත එන්නන්
   • O(n/2)වාෂ්පශීලී කේතීකරණය හේතුවෙන් ඉතා මිල අධික චලනයන්, ඇතුළත් කිරීම්, මකාදැමීම්
3. පාලම් වගුව ( වසා දැමීමේ වගුව / w ප්‍රේරක )
   • මේ සමඟ වෙනම සම්බන්ධක වගුවක් භාවිතා කරයි: මුතුන් මිත්තන්, පැවත එන්නන්, ගැඹුර (අත්‍යවශ්‍ය නොවේ)
   • ලාභ පරම්පරාව සහ පැවත එන්නන්
   • O(log n)ඇතුළත් කිරීම, යාවත්කාලීන කිරීම, මකා දැමීම සඳහා පිරිවැය (උප කුලයේ ප්‍රමාණය) ලියයි
   • සාමාන්‍යකරණය කළ කේතන ක්‍රමය: RDBMS සංඛ්‍යාලේඛන සහ විමසුම් සැලසුම්කරුට සම්බන්ධ වීම සඳහා හොඳයි
   • එක් නෝඩයකට පේළි කිහිපයක් අවශ්‍ය වේ
4. රේඛීය තීරුව ( ද්‍රව්‍යමය මාර්ගය , මාර්ග ගණනය කිරීම)
   • තීරුව: පෙළපත (උදා: දෙමව්පියන් / දරුවා / මුනුබුරා / යනාදිය ...)
   • උපසර්ග විමසුම හරහා ලාභ පරම්පරාව (උදා LEFT(lineage, #) = '/enumerated/path')
   • O(log n)ඇතුළත් කිරීම, යාවත්කාලීන කිරීම, මකා දැමීම සඳහා පිරිවැය (උප කුලයේ ප්‍රමාණය) ලියයි
   • සම්බන්ධ නොවන: අරා දත්ත සමුදාය හෝ අනුක්‍රමික නූල් ආකෘතිය මත රඳා පවතී
5. කැදැලි අන්තරයන්
   • කැදැලි කට්ටලය මෙන්, නමුත් කේතීකරණයේ වාෂ්පශීලී නොවන පරිදි තාත්වික / පාවෙන / දශමයෙන් (මිල අඩු චලනය / ඇතුළු කිරීම / මකා දැමීම)
   • තාත්වික / පාවෙන / දශම නිරූපණය / නිරවද්‍යතා ගැටළු ඇත
   • මැට්‍රික්ස් කේතීකරණ ප්‍රභේදය "නොමිලේ" සඳහා මුතුන් මිත්තන්ගේ කේතීකරණ (ද්‍රව්‍යමය මාර්ගය) එක් කරයි, නමුත් රේඛීය වීජ ගණිතයේ අමතර උපක්‍රම සමඟ.
6. පැතලි වගුව
   • එක් එක් වාර්තාවට මට්ටම් සහ ශ්‍රේණියේ (උදා: ඇණවුම් කිරීමේ) තීරුවක් එක් කරන නවීකරණය කරන ලද යාබද ලැයිස්තුවක්.
   • නැවත සැකසීමට / පැගිනේට් කිරීමට ලාභයි
   • මිල අධික පියවර සහ මකන්න
   • හොඳ භාවිතය: නූල් සාකච්ඡාව - සංසද / බ්ලොග් අදහස්
7. බහු පෙළ රේඛා තීරු
   • තීරු: එක් එක් පෙළපත් මට්ටමට එකක්, මුල දක්වා සියලුම දෙමව්පියන් යොමු කරයි, අයිතමයේ මට්ටමේ සිට පහළට NULL ලෙස සකසා ඇත
   • ලාභ මුතුන් මිත්තන්, පැවත එන්නන්, මට්ටම
   • ලාභ ඇතුළු කිරීම, මකා දැමීම, කොළ චලනය කිරීම
   • අභ්‍යන්තර නෝඩ් වල මිල අධික ඇතුළත් කිරීම, මකා දැමීම, චලනය කිරීම
   • ධූරාවලිය කෙතරම් ගැඹුරු විය හැකිද යන්නට දැඩි සීමාවක්

දත්ත සමුදාය විශේෂිත සටහන්

MySQL

• යාබද ලැයිස්තුව සඳහා සැසි විචල්‍යයන් භාවිතා කරන්න

ඔරකල්

• භාවිතය සම්බන්ධ මැරයෝ තරණය Adjacency ලැයිස්තු කිරීමට

PostgreSQL

• ද්‍රව්‍යමය මාවත සඳහා ltree datatype

SQL සේවාදායකය

• පොදු සාරාංශය
• 2008 පිරිනැමීම් මඟින් ධූරාවලිය දත්ත වර්ගය රේඛීය තීරු ප්‍රවේශයට සහ නිරූපණය කළ හැකි ගැඹුර පුළුල් කිරීමට උපකාරී වේ.

මගේ ප්‍රියතම පිළිතුර මෙම ත්‍රෙඩ් එකේ පළමු වාක්‍යය යෝජනා කළ ආකාරයටම ය. ධූරාවලිය පවත්වා ගැනීම සඳහා යාබද ලැයිස්තුවක් භාවිතා කරන්න සහ ධූරාවලිය විමසීමට නෙස්ටඩ් සෙට් භාවිතා කරන්න.

මේ දක්වා ඇති ගැටළුව නම්, ගැලපුම් ලැයිස්තුවේ සිට නෙස්ටඩ් සෙට් දක්වා ආවරණ ක්‍රමය ඉතා මන්දගාමී වීමයි. මන්දයත් බොහෝ දෙනා පරිවර්තනය කිරීම සඳහා “පුෂ් ස්ටැක්” ලෙස හඳුන්වන ආන්තික RBAR ක්‍රමය භාවිතා කරන අතර එය මිල අධික ක්‍රමයක් ලෙස සැලකේ. යාබද ලැයිස්තුවෙන් නඩත්තු කිරීමේ සරල බව සහ නෙස්ටඩ් කට්ටලවල විශිෂ්ට ක්‍රියාකාරිත්වය නිර්වාණය කරා ළඟා වීමට. එහි ප්‍රති As ලයක් වශයෙන්, බොහෝ මිනිසුන් අවසන් වන්නේ එක් හෝ තවත් එකක් සඳහා පදිංචි වීමට සිදුවීමෙනි. විශේෂයෙන් කියනුයේ 100,000 කට වඩා වැඩි නෝඩ් ප්‍රමාණයක් තිබේ නම්. කුඩා ප්‍රමාණයේ නෝඩ් ධූරාවලියක් ලෙස එම්එල්එම්එස් විසින් සලකනු ලබන දේ පරිවර්තනය කිරීම සඳහා තල්ලු කිරීමේ ක්‍රමය භාවිතා කිරීම සඳහා මුළු දවසම ගත වේ.

මම සිතුවේ, කළ නොහැකි යැයි පෙනෙන වේගයෙන් යාබද ලැයිස්තුවක් නෙස්ටඩ් කට්ටල බවට පරිවර්තනය කිරීමේ ක්‍රමවේදයක් ඉදිරිපත් කිරීමෙන් මම සෙල්කෝට තරමක් තරඟකාරීත්වයක් ලබා දෙනු ඇතැයි කියාය. මෙන්න මගේ i5 ලැප්ටොප් පරිගණකයේ තල්ලු කිරීමේ ක්‍රමයේ ක්‍රියාකාරිත්වය.

Duration for     1,000 Nodes = 00:00:00:870 
Duration for    10,000 Nodes = 00:01:01:783 (70 times slower instead of just 10)
Duration for   100,000 Nodes = 00:49:59:730 (3,446 times slower instead of just 100) 
Duration for 1,000,000 Nodes = 'Didn't even try this'

නව ක්‍රමය සඳහා කාලසීමාව මෙන්න (වරහන් තුළ තල්ලු කිරීමේ ක්‍රමය සමඟ).

Duration for     1,000 Nodes = 00:00:00:053 (compared to 00:00:00:870)
Duration for    10,000 Nodes = 00:00:00:323 (compared to 00:01:01:783)
Duration for   100,000 Nodes = 00:00:03:867 (compared to 00:49:59:730)
Duration for 1,000,000 Nodes = 00:00:54:283 (compared to something like 2 days!!!)

ඔව්, එය නිවැරදිය. මිනිත්තුවකට අඩු කාලයකින් නෝඩ් මිලියනයක් සහ තත්පර 4 ට අඩු නෝඩ් 100,000 ක් පරිවර්තනය වේ.

ඔබට නව ක්‍රමය ගැන කියවා කේතයේ පිටපතක් පහත URL වෙතින් ලබා ගත හැකිය. http://www.sqlservercentral.com/articles/Hierarchy/94040/

ඒ හා සමාන ක්‍රම උපයෝගී කරගනිමින් මම “පූර්ව-සමස්ථ” ධූරාවලියක් ද වර්ධනය කළෙමි. MLM'ers සහ ද්‍රව්‍ය බිල්පත් කරන පුද්ගලයින් මෙම ලිපිය කෙරෙහි විශේෂයෙන් උනන්දු වනු ඇත. http://www.sqlservercentral.com/articles/T-SQL/94570/

ඔබ එක් ලිපියක් බැලීමට නැවැත්වුවහොත්, "සාකච්ඡාවට එක්වන්න" සබැඳිය වෙත ගොස් ඔබ සිතන්නේ කුමක්දැයි මට දන්වන්න.

මෙය ඔබගේ ප්‍රශ්නයට ඉතා අර්ධ පිළිතුරකි, නමුත් මම තවමත් ප්‍රයෝජනවත් යැයි සිතමි.

මයික්‍රොසොෆ්ට් SQL සේවාදායකය 2008 ධූරාවලි දත්ත කළමනාකරණය සඳහා අතිශයින්ම ප්‍රයෝජනවත් වන අංග දෙකක් ක්‍රියාත්මක කරයි:

• මෙම HierarchyId දත්ත වර්ගය.
• පොදු වගු ප්‍රකාශන, සමඟ යතුරු පදය භාවිතා කිරීම .

ආරම්භය සඳහා MSDN හි කෙන්ට් ටෙගල්ස් විසින් "SQL Server 2008 සමඟ ඔබේ දත්ත ධූරාවලිය ආදර්ශනය කරන්න" බලන්න . මගේම ප්‍රශ්නයද බලන්න: SQL Server 2008 හි පුනරාවර්තන එකම වගු විමසුම

මෙම සැලසුම තවම සඳහන් කර නැත:

බහු පෙළ රේඛා තීරු

එයට සීමාවන් තිබුණද, ඔබට ඒවා දරාගත හැකි නම්, එය ඉතා සරල හා ඉතා කාර්යක්ෂම වේ. විශේෂාංග:

• තීරු: එක් එක් පෙළපත් මට්ටමට එකක්, මුල දක්වා සියලුම දෙමව්පියන් යොමු කරයි, වත්මන් අයිතම මට්ටමට වඩා පහළ මට්ටම් 0 (හෝ NULL) ලෙස සකසා ඇත.
• ධූරාවලිය කෙතරම් ගැඹුරු විය හැකිද යන්නට නිශ්චිත සීමාවක් තිබේ
• ලාභ මුතුන් මිත්තන්, පැවත එන්නන්, මට්ටම
• ලාභ ඇතුළු කිරීම, මකා දැමීම, කොළ චලනය කිරීම
• අභ්‍යන්තර නෝඩ් වල මිල අධික ඇතුළත් කිරීම, මකා දැමීම, චලනය කිරීම

මෙන්න උදාහරණයක් පහත දැක්වේ - කුරුල්ලන්ගේ වර්ගීකරණ ගසක්, එබැවින් ධූරාවලිය පංතිය / පිළිවෙල / පවුල / කුලය / විශේෂය - විශේෂය පහලම මට්ටම, 1 පේළිය = 1 කුලී රථය (කොළ නෝඩ් සම්බන්ධයෙන් විශේෂයට අනුරූප වේ):

CREATE TABLE `taxons` (
  `TaxonId` smallint(6) NOT NULL default '0',
  `ClassId` smallint(6) default NULL,
  `OrderId` smallint(6) default NULL,
  `FamilyId` smallint(6) default NULL,
  `GenusId` smallint(6) default NULL,
  `Name` varchar(150) NOT NULL default ''
);

සහ දත්තවල උදාහරණය:

+---------+---------+---------+----------+---------+-------------------------------+
| TaxonId | ClassId | OrderId | FamilyId | GenusId | Name                          |
+---------+---------+---------+----------+---------+-------------------------------+
|     254 |       0 |       0 |        0 |       0 | Aves                          |
|     255 |     254 |       0 |        0 |       0 | Gaviiformes                   |
|     256 |     254 |     255 |        0 |       0 | Gaviidae                      |
|     257 |     254 |     255 |      256 |       0 | Gavia                         |
|     258 |     254 |     255 |      256 |     257 | Gavia stellata                |
|     259 |     254 |     255 |      256 |     257 | Gavia arctica                 |
|     260 |     254 |     255 |      256 |     257 | Gavia immer                   |
|     261 |     254 |     255 |      256 |     257 | Gavia adamsii                 |
|     262 |     254 |       0 |        0 |       0 | Podicipediformes              |
|     263 |     254 |     262 |        0 |       0 | Podicipedidae                 |
|     264 |     254 |     262 |      263 |       0 | Tachybaptus                   |

අභ්‍යන්තර කාණ්ඩයන් ගස තුළ ඔවුන්ගේ මට්ටම වෙනස් නොකරන තාක් කල්, අවශ්‍ය සියලු මෙහෙයුම් ඉතා පහසු ආකාරයකින් ඉටු කරන බැවින් මෙය විශිෂ්ටයි.

යාබද ආකෘතිය + කැදැලි කට්ටල ආකෘතිය

මම ඒ සඳහා ගියේ මට පහසුවෙන් ගසට නව අයිතම ඇතුළු කළ හැකි බැවිනි (ඔබට නව අයිතමයක් ඇතුළු කිරීමට ශාඛා හැඳුනුම්පතක් අවශ්‍යය) සහ එය ඉතා ඉක්මණින් විමසන්න.

+-------------+----------------------+--------+-----+-----+
| category_id | name                 | parent | lft | rgt |
+-------------+----------------------+--------+-----+-----+
|           1 | ELECTRONICS          |   NULL |   1 |  20 |
|           2 | TELEVISIONS          |      1 |   2 |   9 |
|           3 | TUBE                 |      2 |   3 |   4 |
|           4 | LCD                  |      2 |   5 |   6 |
|           5 | PLASMA               |      2 |   7 |   8 |
|           6 | PORTABLE ELECTRONICS |      1 |  10 |  19 |
|           7 | MP3 PLAYERS          |      6 |  11 |  14 |
|           8 | FLASH                |      7 |  12 |  13 |
|           9 | CD PLAYERS           |      6 |  15 |  16 |
|          10 | 2 WAY RADIOS         |      6 |  17 |  18 |
+-------------+----------------------+--------+-----+-----+

• ඔබට ඕනෑම දෙමාපියෙකුගේ සියලු දරුවන් අවශ්‍ය සෑම අවස්ථාවකම ඔබ parentතීරුව විමසන්න.
• ඔබට ඕනෑම දෙමාපියෙකුගෙන් පැවත එන්නන් අවශ්‍ය නම්, ඔවුන් lftඅතර lftසහ rgtදෙමව්පියන් අතර ඇති අයිතම විමසනු ඇත.
• ඔබ යම් node එකක් මතම ඊට අදාල සියලු දෙමාපියන් වෘක්ෂයේ root දක්වා, ඔබ විමසුමක් සහිත භාණ්ඩ සඳහා අවශ්ය නම්, lftමෙම node එකක් මතම ඊට අදාල ගේ වඩා අඩු lftහා rgtමංසල ගේ වඩා විශාල rgtසහ ආකාරයක විසින් parent.

ඇතුළත් කිරීමට වඩා වේගයෙන් ගසට ප්‍රවේශ වීම සහ විමසීම මට අවශ්‍ය විය, ඒ නිසා මම මෙය තෝරා ගත්තෙමි

එකම ගැටළුව වන්නේ නව අයිතම ඇතුළු කිරීමේදී තීරු leftසහ rightතීරු සවි කිරීමයි . හොඳයි, මම ඒ සඳහා ගබඩා කළ ක්‍රියාපටිපාටියක් නිර්මාණය කළ අතර මගේ අයිතමය දුර්ලභ වූ නමුත් එය ඉතා වේගවත් වන නව අයිතමයක් ඇතුළු කරන සෑම අවස්ථාවකම එය ඇමතුවෙමි. මට අදහස ලැබුණේ ජෝ සෙල්කෝගේ පොතෙන් වන අතර, ගබඩා කර ඇති ක්‍රියා පටිපාටිය සහ මා එය ඉදිරිපත් කළ ආකාරය මෙහි DBA SE https://dba.stackexchange.com/q/89051/41481

ඔබේ දත්ත සමුදාය අරා සඳහා සහය දක්වන්නේ නම්, ඔබට මව් අයිඩී සමූහයක් ලෙස පෙළපත් තීරුවක් හෝ ද්‍රව්‍යමය මාර්ගයක් ක්‍රියාත්මක කළ හැකිය.

විශේෂයෙන් Postgres සමඟ ඔබට ධූරාවලිය විමසීමට සෙට් ක්‍රියාකරුවන් භාවිතා කළ හැකි අතර GIN දර්ශක සමඟ විශිෂ්ට කාර්ය සාධනයක් ලබා ගත හැකිය. මෙය තනි විමසුමකින් දෙමාපියන්, දරුවන් සහ ගැඹුර සොයා ගැනීම ඉතා සුළු කාරණයක් බවට පත් කරයි. යාවත්කාලීනයන් ද කළමනාකරණය කළ හැකිය.

ඔබ කුතුහලයෙන් සිටී නම්, ද්‍රව්‍යමය මාර්ග සඳහා අරා භාවිතා කිරීම පිළිබඳව මට සම්පූර්ණ ලිවීමක් තිබේ.

මෙය සැබවින්ම හතරැස් කූඩුවක්, වටකුරු සිදුරු ප්‍රශ්නයකි.

සබැඳි දත්ත සමුදායන් සහ SQL ඔබට ඇති එකම මිටිය හෝ භාවිතා කිරීමට කැමති නම්, මෙතෙක් පළ කර ඇති පිළිතුරු ප්‍රමාණවත් වේ. කෙසේ වෙතත්, ධූරාවලි දත්ත හැසිරවීමට නිර්මාණය කර ඇති මෙවලමක් භාවිතා නොකරන්නේ ඇයි? ප්‍රස්තාර දත්ත සමුදාය සංකීර්ණ ධූරාවලි දත්ත සඳහා වඩාත් සුදුසු වේ.

ප්‍රස්ථාර / ධූරාවලි ආකෘතියක් සම්බන්ධතා ආකෘතියකට සිතියම් ගත කිරීම සඳහා සම්බන්ධතා ආකෘතියේ අකාර්යක්ෂමතාව සහ ඕනෑම කේතයක / විමසුම් විසඳුමක ඇති සංකීර්ණතාවයන් ප්‍රස්ථාර දත්ත සමුදා විසඳුමකට එකම ගැටළුව විසඳිය හැකි පහසුව සමඟ සසඳන විට උත්සාහ කිරීම වටී නැත.

ද්‍රව්‍යමය පනත් කෙටුම්පතක් පොදු ධූරාවලි දත්ත ව්‍යුහයක් ලෙස සලකන්න.

class Component extends Vertex {
    long assetId;
    long partNumber;
    long material;
    long amount;
};

class PartOf extends Edge {
};

class AdjacentTo extends Edge {
};

උප එකලස් දෙකක් අතර කෙටිම මාර්ගය : සරල ප්‍රස්තාර ගමන් ඇල්ගොරිතම. පිළිගත හැකි මාර්ග නිර්ණායක මත පදනම්ව සුදුසුකම් ලැබිය හැකිය.

සමානතාව : එකලස් දෙකක් අතර සමානතාවයේ තරම කුමක්ද? උප ගස් දෙකෙහි මංසන්ධිය හා එකමුතුකම ගණනය කරමින් උප ගස් දෙකටම ගමන් කරන්න. සමාන ප්‍රතිශතය සමිතිය විසින් බෙදූ ඡේදනය වේ.

සංක්‍රාන්ති වසා දැමීම : උප ගසෙහි ගමන් කර උනන්දුවක් දක්වන ක්ෂේත්‍රය සාරාංශ කරන්න, උදා: "උප එකලස් කිරීමක ඇලුමිනියම් කොපමණ ද?"

ඔව්, ඔබට SQL සහ සම්බන්ධිත දත්ත සමුදායක් සමඟ ගැටළුව විසඳා ගත හැකිය. කෙසේ වෙතත්, ඔබ කාර්යය සඳහා නිවැරදි මෙවලම භාවිතා කිරීමට කැමති නම් වඩා හොඳ ප්‍රවේශයන් ඇත.

මම මගේ ධූරාවලිය සඳහා සංවෘත වගු සමඟ PostgreSQL භාවිතා කරමි. සමස්ත දත්ත ගබඩාව සඳහා මට එක් විශ්වීය ගබඩා කළ ක්‍රියා පටිපාටියක් ඇත:

CREATE FUNCTION nomen_tree() RETURNS trigger
    LANGUAGE plpgsql
    AS $_$
DECLARE
  old_parent INTEGER;
  new_parent INTEGER;
  id_nom INTEGER;
  txt_name TEXT;
BEGIN
-- TG_ARGV[0] = name of table with entities with PARENT-CHILD relationships (TBL_ORIG)
-- TG_ARGV[1] = name of helper table with ANCESTOR, CHILD, DEPTH information (TBL_TREE)
-- TG_ARGV[2] = name of the field in TBL_ORIG which is used for the PARENT-CHILD relationship (FLD_PARENT)
    IF TG_OP = 'INSERT' THEN
    EXECUTE 'INSERT INTO ' || TG_ARGV[1] || ' (child_id,ancestor_id,depth) 
        SELECT $1.id,$1.id,0 UNION ALL
      SELECT $1.id,ancestor_id,depth+1 FROM ' || TG_ARGV[1] || ' WHERE child_id=$1.' || TG_ARGV[2] USING NEW;
    ELSE                                                           
    -- EXECUTE does not support conditional statements inside
    EXECUTE 'SELECT $1.' || TG_ARGV[2] || ',$2.' || TG_ARGV[2] INTO old_parent,new_parent USING OLD,NEW;
    IF COALESCE(old_parent,0) <> COALESCE(new_parent,0) THEN
      EXECUTE '
      -- prevent cycles in the tree
      UPDATE ' || TG_ARGV[0] || ' SET ' || TG_ARGV[2] || ' = $1.' || TG_ARGV[2]
        || ' WHERE id=$2.' || TG_ARGV[2] || ' AND EXISTS(SELECT 1 FROM '
        || TG_ARGV[1] || ' WHERE child_id=$2.' || TG_ARGV[2] || ' AND ancestor_id=$2.id);
      -- first remove edges between all old parents of node and its descendants
      DELETE FROM ' || TG_ARGV[1] || ' WHERE child_id IN
        (SELECT child_id FROM ' || TG_ARGV[1] || ' WHERE ancestor_id = $1.id)
        AND ancestor_id IN
        (SELECT ancestor_id FROM ' || TG_ARGV[1] || ' WHERE child_id = $1.id AND ancestor_id <> $1.id);
      -- then add edges for all new parents ...
      INSERT INTO ' || TG_ARGV[1] || ' (child_id,ancestor_id,depth) 
        SELECT child_id,ancestor_id,d_c+d_a FROM
        (SELECT child_id,depth AS d_c FROM ' || TG_ARGV[1] || ' WHERE ancestor_id=$2.id) AS child
        CROSS JOIN
        (SELECT ancestor_id,depth+1 AS d_a FROM ' || TG_ARGV[1] || ' WHERE child_id=$2.' 
        || TG_ARGV[2] || ') AS parent;' USING OLD, NEW;
    END IF;
  END IF;
  RETURN NULL;
END;
$_$;

මට ධූරාවලියක් ඇති සෑම වගුවක් සඳහාම මම ප්‍රේරකයක් නිර්මාණය කරමි

CREATE TRIGGER nomenclature_tree_tr AFTER INSERT OR UPDATE ON nomenclature FOR EACH ROW EXECUTE PROCEDURE nomen_tree('my_db.nomenclature', 'my_db.nom_helper', 'parent_id');

පවත්නා ධූරාවලියෙන් සංවෘත වගුවක් ජනගහනය කිරීම සඳහා මම මෙම ගබඩා කළ ක්‍රියා පටිපාටිය භාවිතා කරමි:

CREATE FUNCTION rebuild_tree(tbl_base text, tbl_closure text, fld_parent text) RETURNS void
    LANGUAGE plpgsql
    AS $$
BEGIN
    EXECUTE 'TRUNCATE ' || tbl_closure || ';
    INSERT INTO ' || tbl_closure || ' (child_id,ancestor_id,depth) 
        WITH RECURSIVE tree AS
      (
        SELECT id AS child_id,id AS ancestor_id,0 AS depth FROM ' || tbl_base || '
        UNION ALL 
        SELECT t.id,ancestor_id,depth+1 FROM ' || tbl_base || ' AS t
        JOIN tree ON child_id = ' || fld_parent || '
      )
      SELECT * FROM tree;';
END;
$$;

වසා දැමීමේ වගු තීරු 3 කින් අර්ථ දක්වා ඇත - ANCESTOR_ID, DESCENDANT_ID, DEPTH. ANCESTOR සහ DESCENDANT සඳහා සමාන අගයක් සහ DEPTH සඳහා ශුන්‍ය අගයක් සහිත වාර්තා ගබඩා කළ හැකිය (සහ මම උපදෙස් දෙමි). මෙය ධූරාවලිය නැවත ලබා ගැනීම සඳහා වන විමසුම් සරල කරනු ඇත. ඒවා ඇත්තෙන්ම ඉතා සරල ය:

-- get all descendants
SELECT tbl_orig.*,depth FROM tbl_closure LEFT JOIN tbl_orig ON descendant_id = tbl_orig.id WHERE ancestor_id = XXX AND depth <> 0;
-- get only direct descendants
SELECT tbl_orig.* FROM tbl_closure LEFT JOIN tbl_orig ON descendant_id = tbl_orig.id WHERE ancestor_id = XXX AND depth = 1;
-- get all ancestors
SELECT tbl_orig.* FROM tbl_closure LEFT JOIN tbl_orig ON ancestor_id = tbl_orig.id WHERE descendant_id = XXX AND depth <> 0;
-- find the deepest level of children
SELECT MAX(depth) FROM tbl_closure WHERE ancestor_id = XXX;