Self-join என்றால் என்ன?

Question

Accepted Answer

ஒரு **self-join** என்பது ஒரு அட்டவணை **தனக்குத்தானே** join செய்யப்படும் ஒரு join ஆகும் — ஒரு அட்டவணையில் உள்ள rows *அதே அட்டவணையில் உள்ள மற்ற rows உடன்* தொடர்புடையதாக இருக்கும்போது பயனுள்ளது, அதாவது hierarchies (ஊழியர்கள் மற்றும் அவர்களின் managers) அல்லது ஒரு அட்டவணைக்குள் rows ஐ ஒப்பிடுதல்.

## உன்னதமான எடுத்துக்காட்டு: ஊழியர்கள் மற்றும் managers

```sql
-- join employees to itself to pair each employee with their manager
SELECT e.name AS employee, m.name AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id;   -- same table, two aliases!
-- → Bob | Ann, Carol | Ann, Ann | NULL
```

முக்கியமானது **table aliases** (`e` மற்றும் `m`) — அவை ஒற்றை அட்டவணையை இரண்டு "நகல்கள்" போலக் கருத உங்களை அனுமதிக்கின்றன, இதனால் அதே அட்டவணைக்குள் ஊழியர் row ஐ அதன் manager row உடன் join செய்ய முடியும். (LEFT JOIN ஐப் பயன்படுத்துவது manager இல்லாத ஊழியர்களைத் தக்கவைக்கிறது.)

## Self-joins இன் பிற பயன்பாடுகள்

```sql
-- find pairs of products with the same price
SELECT a.name, b.name, a.price
FROM products a
JOIN products b ON a.price = b.price AND a.id < b.id;   -- a.id < b.id avoids duplicates/self-pairs

-- find rows related to other rows in the same table (sequences, comparisons)
```

Self-joins ஒரு அட்டவணைக்குள் rows ஐ ஒப்பிடுவதற்கும் பயன்படுத்தப்படுகின்றன (நகல்கள், ஜோடிகள், அல்லது தொடர்புடைய உள்ளீடுகளைக் கண்டறிதல்) — `a.id < b.id` நிபந்தனை ஒரு row ஐ அதே row உடன் ஜோடி சேர்ப்பதைத் தவிர்க்கவும் நகல் ஜோடிகளைத் தவிர்க்கவும் ஒரு பொதுவான தந்திரம்.

## இது கருத்தளவில் எப்படி வேலை செய்கிறது

```text
A self-join is just a regular join where both sides happen to be the SAME table.
The aliases create two logical "instances" of the table, so each row of one instance
can be matched against rows of the other instance.
→ Nothing special syntactically — it's a normal join, with the trick being aliases.
```

## இது ஏன் முக்கியம்

Self-joins **ஒற்றை அட்டவணைக்குள் உள்ள உறவுகளைக்** கையாள்வதற்கான ஒரு பயனுள்ள SQL நுட்பமாகும் — குறிப்பாக படிநிலை அல்லது self-referential தரவு, இது ஒரு பொதுவான நிஜ-உலக pattern ஆகும், எனவே இந்த சூழ்நிலைகளுக்கு அவற்றைப் புரிந்துகொள்வது மதிப்புமிக்கது.

உன்னதமான மற்றும் மிக முக்கியமான பயன்பாடு **hierarchies** ஆகும், அங்கு rows அதே அட்டவணையில் உள்ள மற்ற rows ஐக் குறிப்பிடுகின்றன (ஊழியர்கள் அவர்களின் managers ஐக் குறிப்பிடுதல், parent categories உடன் categories, நிறுவன கட்டமைப்புகள், threaded comments) — self-joins இந்த உறவுகளை query செய்ய உங்களை அனுமதிக்கின்றன (ஒவ்வொரு ஊழியரையும் அவர்களின் manager உடன் ஜோடி சேர்த்தல்) எளிய queries வெளிப்படுத்த முடியாதவை.

முக்கிய வழிமுறை **table aliases** (அதே அட்டவணைக்குள் rows ஐ ஒன்றுக்கொன்று பொருத்த இரண்டு தர்க்கரீதியான "instances" ஐ உருவாக்குதல்) என்பதைப் புரிந்துகொள்வது இந்த நுட்பத்தை தெளிவுபடுத்துகிறது — இது இரு பக்கங்களும் அதே அட்டவணையாக இருக்கும் ஒரு சாதாரண join மட்டுமே.

Self-joins ஒரு அட்டவணைக்குள் rows ஐ ஒப்பிடுவதையும் கையாளுகின்றன (ஜோடிகள், நகல்கள், அல்லது தொடர்புடைய உள்ளீடுகளைக் கண்டறிதல், பெரும்பாலும் self-pairing மற்றும் நகல்களைத் தவிர்க்க `a.id < b.id` போன்ற நிபந்தனையுடன்).

Self-referential மற்றும் படிநிலை தரவு பொதுவாக இருப்பதால் (org charts, category trees, manager உறவுகள், ஒரு அட்டவணைக்குள் பதிவுகளை ஒப்பிடுதல்), மற்றும் self-joins ஒற்றை அட்டவணைக்குள் இத்தகைய உறவுகளை query செய்வதற்கான நிலையான வழியாக இருப்பதால், self-joins ஐப் புரிந்துகொள்வது — ஒரு அட்டவணையை aliases ஐப் பயன்படுத்தி தனக்குத்தானே join செய்ய முடியும் என்பதையும், பொதுவான patterns (hierarchies, row ஒப்பீடுகள்) ஐயும் — நிஜ தரவு மாடல்களில் அடிக்கடி எழும் intra-table உறவுகளை உள்ளடக்கிய ஒரு வகை queries ஐக் கையாள்வதற்கான பயனுள்ள, நடைமுறையில் தொடர்புடைய SQL அறிவாகும், மேலும் joins பற்றிய ஆழமான புரிதலை வெளிப்படுத்தும் ஒரு பொதுவான நேர்காணல் தலைப்பாகும்.