1. EXISTS IN से बहुत तेज है जब सबक्वायरी परिणाम बहुत बड़े होते हैं।
   जब EXquery परिणाम बहुत छोटे होते हैं तो EXISTS से तेज़ होता है।

   CREATE TABLE t1 (id INT, title VARCHAR(20), someIntCol INT)
   GO
   CREATE TABLE t2 (id INT, t1Id INT, someData VARCHAR(20))
   GO
   
   INSERT INTO t1
   SELECT 1, 'title 1', 5 UNION ALL
   SELECT 2, 'title 2', 5 UNION ALL
   SELECT 3, 'title 3', 5 UNION ALL
   SELECT 4, 'title 4', 5 UNION ALL
   SELECT null, 'title 5', 5 UNION ALL
   SELECT null, 'title 6', 5
   
   INSERT INTO t2
   SELECT 1, 1, 'data 1' UNION ALL
   SELECT 2, 1, 'data 2' UNION ALL
   SELECT 3, 2, 'data 3' UNION ALL
   SELECT 4, 3, 'data 4' UNION ALL
   SELECT 5, 3, 'data 5' UNION ALL
   SELECT 6, 3, 'data 6' UNION ALL
   SELECT 7, 4, 'data 7' UNION ALL
   SELECT 8, null, 'data 8' UNION ALL
   SELECT 9, 6, 'data 9' UNION ALL
   SELECT 10, 6, 'data 10' UNION ALL
   SELECT 11, 8, 'data 11'
   

2. प्रश्न 1

   SELECT
   FROM    t1 
   WHERE   not  EXISTS (SELECT * FROM t2 WHERE t1.id = t2.t1id)
   

   प्रश्न 2

   SELECT t1.* 
   FROM   t1 
   WHERE  t1.id not in (SELECT  t2.t1id FROM t2 )
   

   यदि t1 आपकी आईडी में शून्य मान है तो क्वेरी 1 उन्हें पायेगा, लेकिन क्वेरी 2 नल पैरामीटर नहीं ढूंढ सकता है।

   मेरा मतलब है कि शून्य में कुछ भी तुलना नहीं कर सकता है, इसलिए इसका नतीजा नहीं है, लेकिन EXISTS शून्य के साथ सब कुछ की तुलना कर सकते हैं।

EXISTS IN से प्रदर्शन में तेज है। यदि अधिकांश फ़िल्टर मानदंड सबक्वायरी में हैं तो इन का उपयोग करने के लिए बेहतर है और यदि अधिकांश फ़िल्टर मानदंड मुख्य क्वेरी में हैं तो EXISTS का उपयोग करना बेहतर होगा।

कारण यह है कि EXISTS ऑपरेटर "कम से कम पाया" सिद्धांत के आधार पर काम करता है। यह सच हो जाता है और कम से कम एक मिलान पंक्ति मिलने के बाद स्कैनिंग तालिका रोकता है।

दूसरी तरफ, जब आईएन ऑपरेटर को सबक्वायरी के साथ जोड़ा जाता है, तो MySQL को पहले सबक्वायरी को संसाधित करना होगा, और फिर संपूर्ण क्वेरी को संसाधित करने के लिए सबक्वायरी के परिणाम का उपयोग करना होगा।

अंगूठे का सामान्य नियम यह है कि यदि सबक्वायरी में बड़ी मात्रा में डेटा होता है, तो EXISTS ऑपरेटर बेहतर प्रदर्शन प्रदान करता है।

हालांकि, यदि क्वेरी सेट सबक्वायरी से लौटाया गया है तो क्वेरी ऑपरेटर का उपयोग करता है, यह बहुत तेज़ होगा।

केवल समानता संबंधों का समर्थन करता है (या इससे पहले की असमानता)।
यह एक समानार्थी है = किसी / = कुछ , उदाहरण के लिए

select    * 
from      t1 
where     x in (select x from t2)
;

EXISSTS प्रकार के संबंधों का समर्थन करता है, जिसे IN का उपयोग करके व्यक्त नहीं किया जा सकता है, उदाहरण के लिए -

select    * 
from      t1 
where     exists (select    null 
                  from      t2 
                  where     t2.x=t1.x 
                        and t2.y>t1.y 
                        and t2.z like '℅' || t1.z || '℅'
                  )
;

और एक अलग नोट पर -

EXISTS और IN के बीच कथित रूप से प्रदर्शन और तकनीकी अंतर विशिष्ट विक्रेता के कार्यान्वयन / सीमाओं / बगों के परिणामस्वरूप हो सकते हैं, लेकिन कई बार वे डेटाबेस के आंतरिक की समझ की कमी के कारण मिथकों के अलावा कुछ भी नहीं हैं।

टेबल की परिभाषा, आंकड़े 'सटीकता, डेटाबेस कॉन्फ़िगरेशन और ऑप्टिमाइज़र के संस्करण पर निष्पादन योजना और इसलिए प्रदर्शन मीट्रिक पर सभी प्रभाव पड़ते हैं।

मुझे लगता है कि आप जानते हैं कि वे क्या करते हैं, और इस प्रकार अलग-अलग उपयोग किए जाते हैं, इसलिए मैं आपके प्रश्न को समझने जा रहा हूं: एसक्यूएल को EXISTS के बजाय IN का उपयोग करने के लिए फिर से लिखना अच्छा होगा, या इसके विपरीत।

क्या यह एक उचित धारणा है?

संपादित करें : कारण मैं पूछ रहा हूं कि कई मामलों में आप इसके बजाय EXISTS का उपयोग करने के लिए एक एसक्यूएल को फिर से लिख सकते हैं, और इसके विपरीत, और कुछ डेटाबेस इंजनों के लिए, क्वेरी ऑप्टिमाइज़र दोनों अलग-अलग व्यवहार करेगा।

उदाहरण के लिए:

SELECT *
FROM Customers
WHERE EXISTS (
    SELECT *
    FROM Orders
    WHERE Orders.CustomerID = Customers.ID
)

इसे फिर से लिखा जा सकता है:

SELECT *
FROM Customers
WHERE ID IN (
    SELECT CustomerID
    FROM Orders
)

या शामिल होने के साथ:

SELECT Customers.*
FROM Customers
    INNER JOIN Orders ON Customers.ID = Orders.CustomerID

तो मेरा सवाल अभी भी खड़ा है, क्या मूल पोस्टर यह सोच रहा है कि आईएन और एक्सइस्ट्स क्या करता है, और इस प्रकार इसका उपयोग कैसे किया जाता है, या क्या वह इसके बजाय EXISTS का उपयोग करने के लिए आईएन का उपयोग करके एक एसक्यूएल को फिर से लिखने के लिए गीलेर से पूछताछ करता है, या इसके विपरीत, एक अच्छा विचार होगा?

मुझे लगता है,

• EXISTS तब होता है जब आपको क्वेरी के परिणामों को किसी अन्य सबक्वायरी से मेल करने की आवश्यकता होती है। क्वेरी # 1 परिणामों को पुनर्प्राप्त करने की आवश्यकता है जहां SubQuery परिणाम मेल खाते हैं। शामिल हों .. जैसे ग्राहक तालिका # 1 का चयन करें जिन्होंने आदेश तालिका # 2 भी रखी है

• IN को पुनर्प्राप्त करना है कि किसी विशिष्ट कॉलम का मान किसी सूची में है (1,2,3,4,5) जैसे निम्न जिपकोड्स में स्थित ग्राहकों का चयन करें यानी zip_code मान (....) सूची में हैं।

एक दूसरे के ऊपर कब उपयोग करें ... जब आपको लगता है कि यह उचित रूप से पढ़ता है (संचार का इरादा बेहतर है)।

मेरी समझ यह है कि जब तक हम नल मूल्यों से निपट नहीं रहे हैं, तब तक दोनों एक जैसा होना चाहिए।

वही कारण है कि क्वेरी = NULL बनाम के लिए मान वापस नहीं करती है। http://sqlinthewild.co.za/index.php/2010/02/18/not-exists-vs-not-in/

चूंकि बूलियन बनाम तुलनित्र तर्क के रूप में, एक बूलियन उत्पन्न करने के लिए दोनों मूल्यों की तुलना की जानी चाहिए और यह स्थिति है कि अगर कोई भी स्थिति काम करता है। तो मैं यह समझने में असफल रहता हूं कि कैसे और EXISTS अलग-अलग व्यवहार करते हैं।

मेरे ज्ञान के अनुसार जब एक सबक्वायरी एक पूर्ण मूल्य देता है तो पूरा बयान पूर्ण हो जाता NULL । उन मामलों में हम EXITS कीवर्ड का उपयोग कर रहे हैं। यदि हम सबक्वायरीज़ में विशेष मानों की तुलना करना चाहते हैं तो हम IN कीवर्ड का उपयोग कर रहे हैं।

यदि आप IN ऑपरेटर का उपयोग कर रहे हैं, तो SQL इंजन आंतरिक क्वेरी से प्राप्त सभी रिकॉर्ड स्कैन करेगा। दूसरी तरफ यदि हम EXISTS का उपयोग कर रहे हैं, तो SQL इंजन स्कैनिंग प्रक्रिया को जल्द ही एक मैच मिलने पर रोक देगा।

यदि आप आईएन ऑपरेटर का उपयोग कर रहे हैं, तो SQL इंजन आंतरिक क्वेरी से प्राप्त सभी रिकॉर्ड्स स्कैन करेगा। दूसरी तरफ यदि हम EXISTS का उपयोग कर रहे हैं, तो SQL इंजन स्कैनिंग प्रक्रिया को जल्द ही एक मैच मिलने पर रोक देगा।

EXISTS आपको बताएंगे कि कोई प्रश्न किसी भी परिणाम EXISTS या नहीं। उदाहरण के लिए:

SELECT * 
FROM Orders o 
WHERE EXISTS (
    SELECT * 
    FROM Products p 
    WHERE p.ProductNumber = o.ProductNumber)

IN का उपयोग एक मान की तुलना कई से करने के लिए किया जाता है, और इस तरह के शाब्दिक मूल्यों का उपयोग कर सकते हैं:

SELECT * 
FROM Orders 
WHERE ProductNumber IN (1, 10, 100)

आप इन परिणामों के साथ क्वेरी परिणामों का भी उपयोग कर सकते हैं, जैसे:

SELECT * 
FROM Orders 
WHERE ProductNumber IN (
    SELECT ProductNumber 
    FROM Products 
    WHERE ProductInventoryQuantity > 0)

Exists कीवर्ड वास्तविक या गलत मूल्यांकन करते हैं, लेकिन कीवर्ड में संबंधित उप क्वेरी कॉलम में सभी मानों की तुलना करें। एक और Select 1 का उपयोग Exists कमांड के साथ किया जा सकता है। उदाहरण:

SELECT * FROM Temp1 where exists(select 1 from Temp2 where conditions...)

लेकिन IN कम कुशल है इसलिए तेजी से Exists ।

In certain circumstances, it is better to use IN rather than EXISTS. In general, if the selective predicate is in the subquery, then use IN. If the selective predicate is in the parent query, then use EXISTS.

https://docs.oracle.com/cd/B19306_01/server.102/b14211/sql_1016.htm#i28403

नियम अनुकूलक के आधार पर:

• EXISTS IN से बहुत तेज है, जब उप-क्वेरी परिणाम बहुत बड़े होते हैं।
• IN EXISTS से तेज़ है, जब उप-क्वेरी परिणाम बहुत छोटे होते हैं।

लागत अनुकूलक के आधार पर:

• इसमें कोई फर्क नही है।