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

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 कीवर्ड का उपयोग अक्सर वास्तव में धीमा होता है (यह माइक्रोसॉफ्ट एक्सेस में बहुत सच है)। मैं इसके बजाय जॉइन ऑपरेटर का इस तरीके से उपयोग करता हूं: should-i-use-the-keyword-exists-in-sql

यदि आप IN ऑपरेटर का उपयोग कर रहे हैं, तो 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)

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

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

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

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

अंतर यहां निहित है:

select * 
from abcTable
where exists (select null)

उपर्युक्त क्वेरी सभी रिकॉर्ड्स वापस कर देगी जबकि नीचे एक खाली वापस आ जाएगा।

select *
from abcTable
where abcTable_ID in (select null)

इसे आज़माएं और आउटपुट का निरीक्षण करें।

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

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

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

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

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

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 तब होता है जब आपको क्वेरी के परिणामों को किसी अन्य सबक्वायरी से मेल करने की आवश्यकता होती है। क्वेरी # 1 परिणामों को पुनर्प्राप्त करने की आवश्यकता है जहां SubQuery परिणाम मेल खाते हैं। शामिल हों .. जैसे ग्राहक तालिका # 1 का चयन करें जिन्होंने आदेश तालिका # 2 भी रखी है

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

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

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

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

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

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

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

कौन सा तेज़ है आंतरिक क्वेरी द्वारा प्राप्त प्रश्नों की संख्या पर निर्भर करता है:

• जब आपकी आंतरिक क्वेरी हजारों पंक्तियों को लाती है तो EXIST बेहतर विकल्प होगा
• जब आपकी आंतरिक क्वेरी कुछ पंक्तियां लाती है, तो IN तेज हो जाएगा

EXIST सही या गलत पर मूल्यांकन करें लेकिन एकाधिक मान की तुलना में। जब आप नहीं जानते कि रिकॉर्ड मौजूद है या नहीं, तो आपको EXIST चुनना चाहिए

exists कीवर्ड का उपयोग इस तरह से किया जा सकता है, लेकिन वास्तव में यह गिनती से बचने के लिए एक तरीका है:

--this statement needs to check the entire table
select count(*) from [table] where ...

--this statement is true as soon as one match is found
exists ( select * from [table] where ... )

यह सबसे उपयोगी है जहां आपके पास सशर्त बयान हैं, जैसा कि exists , count से बहुत तेज हो सकता है।

in का सबसे अच्छा उपयोग किया जाता है जहां आपके पास पास करने के लिए एक स्थिर सूची है:

 select * from [table]
 where [field] in (1, 2, 3)

जब आपके पास एक बयान में एक टेबल है, तो इसमें join का अधिक अर्थ होता है, लेकिन अधिकतर इससे कोई फर्क नहीं पड़ता। क्वेरी ऑप्टिमाइज़र को उसी योजना को किसी भी तरह से वापस करना चाहिए। प्रश्नों में कुछ कार्यान्वयन (ज्यादातर पुराने, जैसे कि माइक्रोसॉफ्ट एसक्यूएल सर्वर 2000) in हमेशा एक नेस्टेड जॉइन प्लान प्राप्त होगा, जबकि प्रश्नों में join नेस्टेड, merge या hash उपयोग उचित होगा। अधिक आधुनिक कार्यान्वयन बेहतर होते हैं और जब भी उपयोग किया जाता है तब भी योजना को समायोजित कर सकते हैं।

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

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

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