दिलचस्प पोस्ट
क्या sprintf (बफर, "% s ", बफर, ) सुरक्षित है? अलंकार संस्कृति क्या है? mongodb कर्सर id मान्य त्रुटि नहीं है रिलीज़ एंड्रॉइड ऐप में पूरी तरह से लॉगकैट आउटपुट अक्षम करें? मुझे कैसे पता चलेगा कि मेरी खिड़कियों मशीन पर जेडीके कहाँ स्थापित है? क्रोम विंडोज के तहत एचटीएमएल 5 कैनवास में एंटी-अलियास क्लिप () किनारों को कैसे? ASP.NET MVC ViewBag और DropDownListfor का उपयोग करने में कठिनाई हो रही है नरम कीबोर्ड प्रोग्राम को खोलें ऑब्जेक्ट इनिलाइज़र का उपयोग करते समय, कंपाइलर एक अतिरिक्त स्थानीय चर उत्पन्न क्यों करता है? WinForms के लिए रिबन UI नियंत्रण घटाव करी सी ++ 11 स्टैटिक_एस्टर्ट और टेम्पलेट इंस्टाशन सक्रिय निर्देशिका में किसी उपयोगकर्ता के समूह कैसे प्राप्त करें? (सी #, एएसपी.एन.नेट) सुपर क्लास विधि और इंटरफ़ेस डिफ़ॉल्ट विधि संघर्ष समाधान जावा – नियमित अभिव्यक्ति कोड में टिप्पणियां ढूंढने

SQL में EXISTS और IN के बीच का अंतर?

SQL IN EXISTS और IN खंड के बीच अंतर क्या है?

हमें कब उपयोग किया जाना चाहिए, और हमें कब उपयोग करना चाहिए?

Solutions Collecting From Web of "SQL में EXISTS और IN के बीच का अंतर?"

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 ... ) 

यह सबसे उपयोगी है जहां आपके पास है if कंडीशनल स्टेटमेंट्स exists हैं, तो count से बहुत तेज हो सकता है।

इन in सर्वश्रेष्ठ उपयोग किया जाता है, जहां पास पास करने के लिए एक स्थिर सूची है:

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

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

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) 

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

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

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

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

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

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

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

क्या यह एक निष्पक्ष धारणा है?


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

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

 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 का इस्तेमाल करता है, या ठीक इसके विपरीत, क्या यह एक अच्छा विचार होगा?

  1. EXISTS जब उपवर्ती परिणाम बहुत बड़ा है तो EXISTS से अधिक तेज़ है
    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 की तुलना अशक्त के साथ कर सकते हैं।

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

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

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

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

मुझे लगता है,

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

  • IN को पुनः प्राप्त करना है यदि एक विशिष्ट स्तंभ का मान सूची IN निहित है (1,2,3,4,5) उदाहरण चुनें, जो निम्नलिखित ज़िपकोड में हैं, अर्थात zip_code मान (….) सूची में है।

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

अंतर यहां है:

 select * from abcTable where exists (select null) 

क्वेरी के ऊपर सभी रिकॉर्ड्स वापस आ जाएंगी, जबकि नीचे एक खाली रिक्त होगा।

 select * from abcTable where abcTable_ID in (select null) 

इसे आज़माएं और आउटपुट देखें।

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

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

EXISTS विभिन्न प्रकार के संबंधों का समर्थन करता है, जिसे 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 के बीच तकनीकी मतभेद विशिष्ट विक्रेताओं के कार्यान्वयन / सीमाओं / बगों से हो सकते हैं, लेकिन कई बार वे कुछ भी नहीं हैं लेकिन डेटाबेस इंटरनेशनल की समझ के अभाव के कारण मिथक बनाए गए हैं

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

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

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

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

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

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

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

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

हालांकि, इन ऑपरेटर का उपयोग करने वाली क्वेरी तेजी से निष्पादित करेगी यदि उपकुंजी से प्राप्त परिणाम का परिणाम बहुत छोटा है।

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

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

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

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

आप एक सबक्वरीज़ का उपयोग करके जांच सकते हैं कि रिकॉर्ड का एक समूह मौजूद है या नहीं। इसके लिए, आपको एक subquery के साथ exists खंड का उपयोग करने की आवश्यकता है exists कीवर्ड हमेशा सही या गलत मान वापस आता है।

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

मेरा मानना ​​है कि इसका सीधा उत्तर है आप उन लोगों से क्यों नहीं जांचते हैं जिन्होंने अपने सिस्टम में उस समारोह को विकसित किया?

यदि आप एक एमएस एसक्यूएल डेवलपर हैं, तो यहां सीधे माइक्रोसॉफ्ट से जवाब है

IN :

यह निर्धारित करता है कि क्या कोई निर्दिष्ट मान एक subquery या एक सूची में किसी भी मान से मेल खाता है।

EXISTS :

पंक्तियों के अस्तित्व के लिए परीक्षण करने के लिए एक subquery निर्दिष्ट करता है

मुझे पता चला कि EXISTS कीवर्ड का उपयोग करना वाकई बहुत धीमा है (जो कि माइक्रोसॉफ्ट एक्सेस में बिल्कुल सच है)। मैं इसके बजाय इस ऑपरेटर में इस तरीके से उपयोग करता हूं: I-use-the-keyword-exist-in-sql

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

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