SQL EXISTS स्टेटमेंट कैसे काम करते हैं?

Question 1

मैं SQL सीखने की कोशिश कर रहा हूं और EXISTS स्टेटमेंट को समझने में मुश्किल समय आ रहा है। मुझे "अस्तित्व" के बारे में यह उद्धरण आया और कुछ समझ में नहीं आया:

मौजूद ऑपरेटर का उपयोग करके, आपकी उपश्रेणी शून्य, एक या कई पंक्तियों को वापस कर सकती है, और स्थिति बस यह जांचती है कि क्या उपकुंजी किसी भी पंक्तियों को वापस कर दिया है। यदि आप उपश्रेणी के चुनिंदा खंड को देखते हैं, तो आप देखेंगे कि इसमें एकल शाब्दिक (1) शामिल है; चूँकि युक्त क्वेरी में स्थिति को केवल यह जानने की आवश्यकता है कि कितनी पंक्तियाँ वापस आ गईं, वास्तविक डेटा जो कि उपकुंजी लौटाया गया है वह अप्रासंगिक है।

मुझे समझ में नहीं आ रहा है कि बाहरी क्वेरी यह कैसे जानती है कि उपकुंजी किस पंक्ति की जाँच कर रही है? उदाहरण के लिए:

SELECT *
  FROM suppliers
 WHERE EXISTS (select *
                 from orders
                where suppliers.supplier_id = orders.supplier_id);

मैं समझता हूं कि यदि आपूर्तिकर्ता और आदेश तालिका मिलान से आईडी, सबकुछ सही हो जाएगा और आपूर्तिकर्ताओं की तालिका में मिलान पंक्ति से सभी कॉलम आउटपुट हो जाएंगे। मुझे क्या नहीं मिलता है कि कैसे उपकुंजी संचार करती है कि किस विशिष्ट पंक्ति (आपूर्तिकर्ता आईडी 25 के साथ पंक्ति कहती है) को मुद्रित किया जाना चाहिए यदि केवल एक सही या गलत लौटाया जा रहा है।

यह मुझे प्रतीत होता है कि बाहरी प्रश्न और उपश्रेणी के बीच कोई संबंध नहीं है।

Question 2

इस पर इस तरीके से विचार करें:

'प्रत्येक' पंक्ति से Suppliers, जांचें कि क्या वहां मौजूद Orderतालिका में एक पंक्ति है जो स्थिति से मिलती है Suppliers.supplier_id(यह बाहरी क्वेरी वर्तमान 'पंक्ति' से आती है) = Orders.supplier_id। जब आप पहली मिलान पंक्ति पाते हैं, तो वहीं रुकें - WHERE EXISTSसंतुष्ट हो गए हैं।

बाहरी क्वेरी और सबक्वेरी के बीच की मैजिक लिंक इस तथ्य में निहित है कि Supplier_idप्रत्येक मूल्यांकन किए गए मूल्यांकन के लिए बाहरी क्वेरी से सबक्वेरी को पास किया जाता है।

या, इसे दूसरे तरीके से रखने के लिए, सबक्वेरी को बाहरी क्वेरी की प्रत्येक तालिका पंक्ति के लिए निष्पादित किया जाता है।

यह ऐसा नहीं है कि उपशम पूरे पर क्रियान्वित किया जाता है और 'सही / गलत' हो जाता है और फिर बाहरी क्वेरी के साथ इस 'सही / गलत' स्थिति का मिलान करने की कोशिश करता है।

Question 3

यह मुझे प्रतीत होता है कि बाहरी प्रश्न और उपश्रेणी के बीच कोई संबंध नहीं है।

आपको क्या लगता है कि EXISTS उदाहरण के अंदर WHause क्लॉज क्या कर रहा है? आप उस नतीजे पर कैसे आते हैं जब SUPPLIERS का संदर्भ FROM में नहीं है या EXISTS क्लॉज के भीतर शामिल हैं?

TRUE / FALSE के लिए EXISTS मूल्यांकन करता है, और मानदंड के पहले मैच पर TRUE के रूप में बाहर निकलता है - यही कारण है कि यह तेजी से हो सकता है IN। यह भी जान लें कि किसी EXISTS में सेलेक्ट क्लॉज को नजरअंदाज किया जाता है - IE:

SELECT s.*
  FROM SUPPLIERS s
 WHERE EXISTS (SELECT 1/0
                 FROM ORDERS o
                WHERE o.supplier_id = s.supplier_id)

... शून्य त्रुटि से एक विभाजन मारा जाना चाहिए, लेकिन यह नहीं होगा। WHERE क्लॉज एक EXISTS क्लॉज का सबसे महत्वपूर्ण टुकड़ा है।

यह भी जान लें कि एक JOIN EXISTS का प्रत्यक्ष प्रतिस्थापन नहीं है, क्योंकि माता-पिता से जुड़े एक से अधिक बाल रिकॉर्ड होने पर डुप्लिकेट अभिभावक रिकॉर्ड होंगे।

Question 4

आप या तो का उपयोग कर समान परिणाम उत्पन्न कर सकते JOIN, EXISTS, IN, या INTERSECT:

SELECT s.supplier_id
FROM suppliers s
INNER JOIN (SELECT DISTINCT o.supplier_id FROM orders o) o
    ON o.supplier_id = s.supplier_id

SELECT s.supplier_id
FROM suppliers s
WHERE EXISTS (SELECT * FROM orders o WHERE o.supplier_id = s.supplier_id)

SELECT s.supplier_id 
FROM suppliers s 
WHERE s.supplier_id IN (SELECT o.supplier_id FROM orders o)

SELECT s.supplier_id
FROM suppliers s
INTERSECT
SELECT o.supplier_id
FROM orders o

Question 5

यदि आपके पास एक क्लॉज है जो इस तरह दिखता है:

WHERE id in (25,26,27) -- and so on

आप आसानी से समझ सकते हैं कि कुछ पंक्तियाँ क्यों लौटाई जाती हैं और कुछ नहीं हैं।

जब खंड इस तरह है:

WHERE EXISTS (select * from orders where suppliers.supplier_id = orders.supplier_id);

इसका सिर्फ यह अर्थ है: आदेश पंक्तियों में एक ही रिकॉर्ड के साथ एक ही आईडी के साथ वापसी पंक्तियाँ।

Question 6

यह एक बहुत अच्छा सवाल है, इसलिए मैंने अपने ब्लॉग पर इस विषय के बारे में एक बहुत विस्तृत लेख लिखने का फैसला किया है ।

डेटाबेस तालिका मॉडल

मान लेते हैं कि हमारे डेटाबेस में निम्नलिखित दो टेबल हैं, जो एक से कई टेबल रिलेशनशिप बनाते हैं।

studentतालिका अभिभावक होता है और student_gradeबच्चे को मेज है, क्योंकि यह एक student_id विदेशी कुंजी स्तंभ छात्र तालिका में आईडी प्राथमिक कुंजी स्तंभ को संदर्भित है।

student tableनिम्नलिखित दो रिकॉर्ड में शामिल हैं:

| id | first_name | last_name | admission_score |
|----|------------|-----------|-----------------|
| 1  | Alice      | Smith     | 8.95            |
| 2  | Bob        | Johnson   | 8.75            |

और, student_gradeतालिका उन ग्रेडों को संग्रहीत करती है जो छात्र प्राप्त करते हैं:

| id | class_name | grade | student_id |
|----|------------|-------|------------|
| 1  | Math       | 10    | 1          |
| 2  | Math       | 9.5   | 1          |
| 3  | Math       | 9.75  | 1          |
| 4  | Science    | 9.5   | 1          |
| 5  | Science    | 9     | 1          |
| 6  | Science    | 9.25  | 1          |
| 7  | Math       | 8.5   | 2          |
| 8  | Math       | 9.5   | 2          |
| 9  | Math       | 9     | 2          |
| 10 | Science    | 10    | 2          |
| 11 | Science    | 9.4   | 2          |

SQL EXISTS

मान लें कि हम उन सभी छात्रों को प्राप्त करना चाहते हैं, जिन्हें गणित कक्षा में 10 ग्रेड प्राप्त हुए हैं।

यदि हम केवल छात्र पहचानकर्ता में रुचि रखते हैं, तो हम इस तरह एक क्वेरी चला सकते हैं:

SELECT
    student_grade.student_id
FROM
    student_grade
WHERE
    student_grade.grade = 10 AND
    student_grade.class_name = 'Math'
ORDER BY
    student_grade.student_id

लेकिन, आवेदन studentकेवल पहचानकर्ता का पूरा नाम प्रदर्शित करने में रुचि रखता है , इसलिए हमें studentतालिका से भी जानकारी चाहिए ।

studentगणित में 10 ग्रेड वाले रिकॉर्ड को फ़िल्टर करने के लिए , हम इस तरह से EXISTS SQL ऑपरेटर का उपयोग कर सकते हैं:

SELECT
    id, first_name, last_name
FROM
    student
WHERE EXISTS (
    SELECT 1
    FROM
        student_grade
    WHERE
        student_grade.student_id = student.id AND
        student_grade.grade = 10 AND
        student_grade.class_name = 'Math'
)
ORDER BY id

ऊपर क्वेरी चलाते समय, हम देख सकते हैं कि केवल ऐलिस पंक्ति चयनित है:

| id | first_name | last_name |
|----|------------|-----------|
| 1  | Alice      | Smith     |

बाहरी क्वेरी उस studentपंक्ति कॉलम का चयन करती है जिसे हम ग्राहक को वापस करने में रुचि रखते हैं। हालाँकि, WHERE क्लॉज़ संबंधित आंतरिक उपकुंजी के साथ EXISTS ऑपरेटर का उपयोग कर रहा है।

यदि किसी पंक्ति का चयन नहीं किया जाता है, तो उपश्रेणी ऑपरेटर सही रिटर्न देता है और यदि उपकुंजी कम से कम एक रिकॉर्ड और गलत रिटर्न देता है। डेटाबेस इंजन को पूरी तरह से उपकुंजी चलाने की आवश्यकता नहीं है। यदि किसी एकल रिकॉर्ड का मिलान किया जाता है, तो EXISTS ऑपरेटर सही हो जाता है, और संबंधित अन्य क्वेरी पंक्ति चयनित होती है।

आंतरिक सबक्वेरी को सहसंबद्ध किया जाता है क्योंकि student_gradeटेबल के छात्र_आईडी कॉलम को बाहरी छात्र तालिका के आईडी कॉलम से मिलान किया जाता है।

Question 7

EXISTS का मतलब है कि सबकुछ कम से कम एक पंक्ति में वापस आ जाए, यही वास्तव में है। उस मामले में, यह एक सहसंबद्ध उपश्रेणी है क्योंकि यह बाहरी तालिका के सप्लायर_आईडी को आंतरिक तालिका के आपूर्तिकर्ता_एड को जांचता है। यह प्रश्न कहता है, वास्तव में:

सभी आपूर्तिकर्ताओं का चयन करें प्रत्येक आपूर्तिकर्ता आईडी के लिए, देखें कि क्या इस आपूर्तिकर्ता के लिए कोई आदेश मौजूद है यदि आपूर्तिकर्ता आदेश तालिका में मौजूद नहीं है, तो आपूर्तिकर्ता को उन परिणामों से हटा दें RETURN सभी आपूर्तिकर्ता जिनके पास ऑर्डर तालिका में संबंधित पंक्तियां हैं

आप इस मामले में INNER JOIN के साथ भी ऐसा कर सकते हैं।

SELECT suppliers.* 
  FROM suppliers 
 INNER 
  JOIN orders 
    ON suppliers.supplier_id = orders.supplier_id;

पोंजी टिप्पणी सही है। आपको उस जुड़ने के साथ समूहीकरण करना होगा, या आपके द्वारा आवश्यक डेटा के आधार पर अलग-अलग चयन करना होगा।

Question 8

आपके द्वारा वर्णित एक सहसंबद्ध उपश्रेणी के साथ एक तथाकथित क्वेरी है ।

(सामान्य रूप से) यह कुछ ऐसा है जिसे आपको एक जुड़ाव के बजाय क्वेरी लिखकर बचने की कोशिश करनी चाहिए:

SELECT suppliers.* 
FROM suppliers 
JOIN orders USING supplier_id
GROUP BY suppliers.supplier_id

क्योंकि अन्यथा, बाहरी क्वेरी में प्रत्येक पंक्ति के लिए सबक्वेरी निष्पादित की जाएगी।