SQL Academy · पाठ

एक ही तालिका की पंक्तियों की तुलना

Q: क्या “एक ही तालिका की पंक्तियों की तुलना” पाठ निःशुल्क है?

हाँ—“एक ही तालिका की पंक्तियों की तुलना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और SQL Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। SQL Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Q: “एक ही तालिका की पंक्तियों की तुलना” में मैं क्या सीखूँगा?

युग्म और संबंध खोजें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ SQL Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

Q: क्या SQL Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर SQL Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

Q: “एक ही तालिका की पंक्तियों की तुलना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

Q: क्या मैं इस SQL Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर SQL Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

युग्म और संबंध खोजें।

पाठ 3, कुल 4 में से13 चरण

एक ही तालिका की पंक्तियों की तुलना, CoddyKit पर SQL Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह SQL Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। SQL Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

स्वयं-जोड़ क्या होता है

स्वयं-जोड़ तब होता है, जब आप किसी तालिका को उसी तालिका से जोड़ते हैं। यह शुरुआत में असामान्य लग सकता है, लेकिन एक ही तालिका के भीतर पंक्तियों की तुलना करने के लिए यह एक शक्तिशाली तकनीक है।

कल्पना कीजिए कि employees तालिका में प्रत्येक कर्मचारी के पास एक manager_id है, जो उसी तालिका की किसी दूसरी पंक्ति की ओर संकेत करता है। स्वयं-जोड़ आपको एक ही क्वेरी में प्रत्येक कर्मचारी का उसके प्रबंधक से मिलान करने देता है।

उदाहरण तालिका तैयार करना

आइए इस पूरे पाठ में उपयोग करने के लिए एक सरल employees तालिका बनाएँ। प्रत्येक पंक्ति में id, name, salary और manager_id होता है, जो उसी तालिका के किसी दूसरे कर्मचारी का संदर्भ देता है।

CREATE TABLE employees (
  id         INT PRIMARY KEY,
  name       VARCHAR(50),
  salary     INT,
  manager_id INT
);

INSERT INTO employees VALUES
  (1, 'Alice',   90000, NULL),
  (2, 'Bob',     70000, 1),
  (3, 'Carol',   65000, 1),
  (4, 'Dave',    55000, 2),
  (5, 'Eve',     60000, 2),
  (6, 'Frank',   48000, 3);

स्वयं-जोड़ का मूल वाक्यविन्यास

स्वयं-जोड़ करने के लिए उसी तालिका को दो अलग-अलग उपनामों के साथ दो बार संदर्भित कीजिए। उपनाम ऐसे काम करते हैं, मानो आपके पास तालिका की दो अलग प्रतियाँ हों। इसके बाद दोनों प्रतियों को जोड़ने वाली जोड़ने की शर्त निर्दिष्ट कीजिए।

यहाँ हम employees को e यानी कर्मचारी और m यानी प्रबंधक का उपनाम देते हैं, फिर e.manager_id = m.id पर मिलान करते हैं।

SELECT
  e.name   AS employee,
  m.name   AS manager
FROM employees e
JOIN employees m ON e.manager_id = m.id;

LEFT JOIN के साथ शीर्ष-स्तरीय पंक्तियों को शामिल करना

सामान्य INNER JOIN उन पंक्तियों को हटा देता है जिनमें manager_id का मान NULL होता है। इसका अर्थ है कि शीर्ष-स्तरीय कर्मचारी, यानी CEO ऐलिस, परिणामों से बाहर हो जाएँगी।

LEFT JOIN का उपयोग कीजिए, ताकि प्रत्येक कर्मचारी दिखाई दे, यहाँ तक कि वे भी जिनका कोई प्रबंधक नहीं है। उनके लिए प्रबंधक वाला कॉलम केवल NULL होगा।

SELECT
  e.name          AS employee,
  m.name          AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id
ORDER BY m.name NULLS LAST, e.name;

समान गुण वाले युग्म खोजना

स्वयं-जोड़ किसी मान को साझा करने वाली पंक्तियों के युग्म खोजने के लिए भी उपयोगी हैं। उदाहरण के लिए, आप उन सभी कर्मचारियों के युग्म खोज सकते हैं जो एक ही प्रबंधक को रिपोर्ट करते हैं।

a.id < b.id जैसी शर्त डुप्लिकेट युग्मों को रोकती है, ताकि (बॉब, कैरल) और (कैरल, बॉब) दोनों परिणामों में दिखाई न दें।

SELECT
  a.name       AS employee_1,
  b.name       AS employee_2,
  a.manager_id AS shared_manager
FROM employees a
JOIN employees b
  ON a.manager_id = b.manager_id
 AND a.id < b.id;

पंक्तियों के बीच वेतनों की तुलना करना

आप पंक्तियों के बीच संख्यात्मक मानों की तुलना करने के लिए स्वयं-जोड़ का उपयोग कर सकते हैं। नीचे दी गई क्वेरी उन सभी कर्मचारियों को खोजती है जिनका वेतन उनके अपने प्रबंधक के वेतन से अधिक है—यह एक पारंपरिक विश्लेषणात्मक जाँच है।

SELECT
  e.name       AS employee,
  e.salary     AS emp_salary,
  m.name       AS manager,
  m.salary     AS mgr_salary
FROM employees e
JOIN employees m ON e.manager_id = m.id
WHERE e.salary > m.salary;

बिना मेल वाली पंक्तियाँ खोजना

LEFT JOIN और WHERE ... IS NULL जाँच के साथ स्वयं-जोड़ आपको उन पंक्तियों को खोजने देता है जिनकी कोई मेल खाती दूसरी पंक्ति नहीं है। यहाँ हम ऐसे कर्मचारियों को खोजते हैं जिनके अधीन कोई कर्मचारी नहीं है—ये पदानुक्रम के अंतिम नोड होते हैं।

SELECT e.name AS employee
FROM employees e
LEFT JOIN employees sub ON sub.manager_id = e.id
WHERE sub.id IS NULL
ORDER BY e.name;

प्रत्यक्ष अधीनस्थों की गिनती करना

तालिका को स्वयं से जोड़कर और प्रबंधक वाली ओर के आधार पर समूह बनाकर आप गिन सकते हैं कि प्रत्येक प्रबंधक के कितने प्रत्यक्ष अधीनस्थ हैं। शून्य अधीनस्थ वाले कर्मचारियों को LEFT JOIN के माध्यम से शामिल किया जाता है।

SELECT
  m.name           AS manager,
  COUNT(e.id)      AS direct_reports
FROM employees m
LEFT JOIN employees e ON e.manager_id = m.id
GROUP BY m.id, m.name
ORDER BY direct_reports DESC;

स्वयं-जोड़ों को स्पष्ट करने के लिए CTEs का उपयोग करना

जब स्वयं-जोड़ वाली क्वेरी जटिल हो जाती है, तो उसे सामान्य तालिका अभिव्यक्ति (CTE) में लपेटने से तर्क को पढ़ना आसान हो जाता है। पदानुक्रम के लिए एक CTE परिभाषित कीजिए और फिर उस पर स्पष्ट रूप से क्वेरी चलाइए।

WITH hierarchy AS (
  SELECT
    e.id         AS emp_id,
    e.name       AS employee,
    e.salary     AS emp_salary,
    m.name       AS manager,
    m.salary     AS mgr_salary
  FROM employees e
  LEFT JOIN employees m ON e.manager_id = m.id
)
SELECT *
FROM hierarchy
WHERE mgr_salary IS NOT NULL
  AND emp_salary > mgr_salary;

गैर-पदानुक्रमित तालिका पर स्वयं-जोड़

स्वयं-जोड़ केवल प्रबंधक-कर्मचारी पदानुक्रमों तक सीमित नहीं हैं। नीचे दिया गया उदाहरण products तालिका का उपयोग करके एक ही श्रेणी से संबंधित सभी उत्पादों के युग्म खोजता है, जो सुझाव प्रणालियों या समानता की जाँच के लिए उपयोगी है।

CREATE TABLE products (
  id       INT PRIMARY KEY,
  name     VARCHAR(50),
  category VARCHAR(30)
);

INSERT INTO products VALUES
  (1, 'Laptop',  'Electronics'),
  (2, 'Phone',   'Electronics'),
  (3, 'Tablet',  'Electronics'),
  (4, 'Shirt',   'Clothing'),
  (5, 'Jeans',   'Clothing');

SELECT
  a.name AS product_1,
  b.name AS product_2,
  a.category
FROM products a
JOIN products b
  ON a.category = b.category
 AND a.id < b.id;

सावधानियाँ: कार्तीय गुणनफल और डुप्लिकेट

स्वयं-जोड़ों में होने वाली दो सामान्य गलतियाँ हैं: कार्तीय गुणनफल यानी जोड़ने की शर्त पूरी तरह भूल जाना, और डुप्लिकेट युग्म यानी a.id <> b.id का उपयोग करना, जबकि a.id < b.id का उपयोग होना चाहिए।

हमेशा जाँच लें कि जोड़ने की शर्त सही है। जब आपको क्रमित युग्मों के बजाय केवल क्रम-रहित युग्म चाहिए हों, तब <> के बजाय < का उपयोग कीजिए।

-- Wrong: returns every ordered pair (A,B) AND (B,A)
SELECT a.name, b.name
FROM employees a
JOIN employees b ON a.manager_id = b.manager_id
                AND a.id <> b.id;

-- Correct: returns each unordered pair once
SELECT a.name, b.name
FROM employees a
JOIN employees b ON a.manager_id = b.manager_id
                AND a.id < b.id;

त्वरित जाँच

स्वयं-जोड़ और उसी तालिका की पंक्तियों की तुलना की अपनी समझ का परीक्षण कीजिए।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने सीखा कि उसी तालिका की पंक्तियों की तुलना करने के लिए स्वयं-जोड़ का उपयोग कैसे किया जाता है।

मुख्य बातें:

तालिका को दो बार उपनाम दें, जैसे e और m, ताकि डेटाबेस उन्हें अलग-अलग स्रोतों के रूप में समझे।
जब आपको केवल मिलान वाली पंक्तियाँ चाहिए हों, तब INNER JOIN का उपयोग करें; और जब बिना-मिलान वाली पंक्तियों को भी शामिल करना हो, तब LEFT JOIN का उपयोग करें।
क्रम-रहित युग्मों को दोहरने से बचने के लिए a.id < b.id का उपयोग करें।
स्वयं-जोड़ पदानुक्रमों, जैसे प्रबंधक-कर्मचारी संबंध, समानता-खोजों, जैसे समान श्रेणी, और ऐसी किसी भी तुलना के लिए उपयोगी हैं जिसमें एक ही तालिका की दो पंक्तियों को आपस में संबंधित करना हो।
जटिल स्वयं-जोड़ क्वेरियों को पढ़ना और बनाए रखना CTE की सहायता से बहुत आसान हो सकता है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ SQL सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 46
पाठ: 183

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “एक ही तालिका की पंक्तियों की तुलना” पाठ निःशुल्क है?

हाँ—“एक ही तालिका की पंक्तियों की तुलना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और SQL Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। SQL Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।