मैंने देखा है SQL
कि दोनों का उपयोग करता है !=
और समान नहीं के<>
लिए । पसंदीदा वाक्यविन्यास क्या है और क्यों?
मुझे पसंद है !=
, क्योंकि <>
मुझे याद दिलाता है Visual Basic
।
NOT (A = B)
।
मैंने देखा है SQL
कि दोनों का उपयोग करता है !=
और समान नहीं के<>
लिए । पसंदीदा वाक्यविन्यास क्या है और क्यों?
मुझे पसंद है !=
, क्योंकि <>
मुझे याद दिलाता है Visual Basic
।
NOT (A = B)
।
जवाबों:
यदि आप SQL Server AKA T-SQL का उपयोग कर रहे हैं, तो तकनीकी रूप से वे समान कार्य करते हैं। यदि आप इसे संग्रहीत कार्यविधियों में उपयोग कर रहे हैं तो एक के बाद एक उपयोग करने का कोई कारण नहीं है। यह तब व्यक्तिगत वरीयता में आता है। मैं <> का उपयोग करना पसंद करता हूं क्योंकि यह एएनएसआई अनुरूप है।
आप विभिन्न ANSI मानकों के लिंक पा सकते हैं ...
!=
सी-प्रभावित भाषा में अपने अस्तित्व के कारण इसका उपयोग करना पसंद किया था, और क्योंकि पायथन डॉक्यूमेंटेशन कहता है: "फॉर्म <>
और !=
सी के बराबर हैं; सी के साथ संगतता के लिए !=
पसंद किया जाता है; जहां !=
नीचे उल्लेख किया गया <>
है, वह भी स्वीकार किया जाता है। <>
वर्तनी अप्रचलित माना जाता है। " लेकिन SQL पायथन नहीं है!
<>
से उपयोग करने की सलाह देता है !=
, उदाहरण के लिए 70-461 परीक्षा के लिए Microsoft प्रेस प्रशिक्षण किट में, "Microsoft SQL सर्वर को छोड़ते हुए", वे कहते हैं "मानक रूप का चयन करने के उदाहरण के रूप में, T-SQL दो का समर्थन करता है" नहीं "ऑपरेटरों के बराबर: <> और! = पूर्व मानक है और बाद वाला नहीं है। यह मामला एक बड़प्पन होना चाहिए: मानक एक के लिए जाओ!"
अधिकांश डेटाबेस !=
(लोकप्रिय प्रोग्रामिंग भाषाओं) और <>
(ANSI) का समर्थन करते हैं ।
डेटाबेस जो दोनों का समर्थन करते हैं !=
और <>
:
!=
और<>
!=
और<>
!=
और<>
!=
और<>
!=
और<>
!=
और<>
!=
और<>
!=
और<>
!=
और<>
एएनएसआई मानक ऑपरेटर का समर्थन करने वाले डेटाबेस, विशेष रूप से :
NOT (a = b)
के बजाय (a <> b)
या (a != b)
। क्या यह आंतरिक रूप से समान है?
'<>'
से है SQL-92 मानक और '!='
एक है मालिकाना T-SQL ऑपरेटर। यह अन्य डेटाबेस में भी उपलब्ध है, लेकिन चूंकि यह मानक नहीं है इसलिए आपको इसे केस-बाय-केस आधार पर लेना होगा।
ज्यादातर मामलों में, आपको पता चल जाएगा कि आप किस डेटाबेस से जुड़ रहे हैं, यह वास्तव में कोई समस्या नहीं है। कम से कम आपको अपनी SQL में खोज और प्रतिस्थापित करना पड़ सकता है।
!=
में इसका हिस्सा नहीं है। भले ही सभी व्यावहारिक उद्देश्यों के लिए यह एक डिफैक्टो मानक है, हमें यह भ्रमित नहीं करना चाहिए कि क्या हैं और मानक विशेषताएं नहीं हैं।
ANSI SQL मानक <>
"ऑपरेटर के बराबर नहीं" के रूप में परिभाषित करता है ,
http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt ( 5.2 <token> and <separator>
)
!=
ANSI / SQL 92 मानक के अनुसार कोई ऑपरेटर नहीं है ।
<>
SQL-92 मानक के अनुसार मान्य SQL है।
http://msdn.microsoft.com/en-us/library/aa276846(SQL.80).aspx
वे SQL सर्वर के संबंध में मान्य और समान हैं ,
https://docs.microsoft.com/en-us/sql/t-sql/language-elements/not-equal-to-transact-sql-exclamation
ऐसा लगता है कि माइक्रोसॉफ्ट के लिए खुद को पसंद करते हैं <>
करने के लिए !=
के रूप में अपनी मेज की कमी से जाहिर होता है। मैं व्यक्तिगत !=
रूप से उपयोग करना पसंद करता हूं क्योंकि मैंने स्पष्ट रूप से पढ़ा है कि "बराबर नहीं" के रूप में, लेकिन यदि आप [field1 != field2]
इसे दर्ज करते हैं और इसे एक बाधा के रूप में सहेजते हैं, तो अगली बार जब आप इसे क्वेरी करते हैं, तो यह दिखाई देगा [field1 <> field2]
। यह मुझे कहता है कि ऐसा करने का सही तरीका है <>
।
!=
गैर-एएनएसआई होने के बावजूद, एसक्यूएल की वास्तविक भावना में एक पठनीय भाषा के रूप में अधिक है। यह नहीं के बराबर चिल्लाती है।
<>
यह मेरे लिए (कम से कम, अधिक से अधिक) है जो सिर्फ अजीब है। मुझे पता है कि इरादा यह है कि यह या तो कम से कम है या इसलिए नहीं के बराबर है, लेकिन यह वास्तव में सरल कुछ कहने का एक जटिल तरीका है।
मुझे बस कुछ लंबे एसक्यूएल क्वेश्चन लेने हैं और उन्हें प्यार से एक्सएमएल फाइल में जगह देनी चाहिए क्योंकि मैं बेवकूफ नहीं बनूंगा।
एक्सएमएल के बारे में यह कहना बिल्कुल भी कम नहीं है कि मुझे खुद को बरबाद करने से पहले खुद <>
को बदलना पड़ा !=
और जांच करनी पड़ी।
आप टी-एसक्यूएल में से जो भी चाहें उपयोग कर सकते हैं। प्रलेखन का कहना है कि वे दोनों एक ही तरह से कार्य करते हैं। मैं पसंद करता हूं !=
, क्योंकि यह मेरे (C / C ++ / C # आधारित) दिमाग के लिए "बराबर नहीं" पढ़ता है, लेकिन डेटाबेस गुरु पसंद करते हैं <>
।
एक विकल्प यह होगा कि NULLIF ऑपरेटर के अलावा अन्य का उपयोग करें <>
या !=
जो NULL को लौटाता है यदि दोनों तर्क Microsoft Docs में NULLIF के बराबर हैं । इसलिए मेरा मानना है कि जहां <>
और के लिए खंड को संशोधित किया जा सकता !=
है:
NULLIF(arg1, arg2) IS NOT NULL
जैसा कि मैंने पाया कि, का उपयोग करना <>
और !=
कुछ मामलों में तारीख के लिए काम नहीं करता है। इसलिए उपरोक्त अभिव्यक्ति का उपयोग करना आवश्यक है।
<>
सभी कोने के मामलों में सूचकांक के उपयोग के संबंध में भी प्रदर्शन करेगा । इसके अलावा, पठनीयता निश्चित रूप से बहुत खराब है ...
मैंने !=
इसके बजाय का उपयोग करना पसंद किया <>
क्योंकि कभी-कभी मैं <s></s>
SQL कमांड लिखने के लिए सिंटैक्स का उपयोग करता हूं । !=
इस मामले में सिंटैक्स त्रुटियों से बचने के लिए उपयोग करना अधिक आसान है।
वे दोनों टी-एसक्यूएल में स्वीकार किए जाते हैं। हालाँकि, ऐसा लगता है कि उपयोग करने <>
से बहुत तेजी से काम होता है!=
। मैं सिर्फ एक जटिल क्वेरी चला रहा था जो उपयोग कर रहा था !=
, और इसे चलाने में औसतन लगभग 16 सेकंड का समय लगा। मैंने उन्हें बदल दिया <>
और क्वेरी को चलाने के लिए औसतन अब लगभग 4 सेकंड लगते हैं। यह एक बहुत बड़ा सुधार है!
हालांकि वे उसी तरह से कार्य करते हैं, !=
जिसका अर्थ है, जबकि "बराबर नहीं", जबकि<>
संग्रहीत मूल्य से अधिक और कम का मतलब है।
विचार करें >=
<=
, या यह तब समझ में आएगा जब आपके अनुक्रमित प्रश्नों में फैक्टरिंग ...<>
कुछ मामलों में (सही इंडेक्स के साथ) तेजी से चलेगी, लेकिन कुछ अन्य मामलों (इंडेक्स फ्री) में वे सिर्फ एक ही चलेंगे।
यह इस बात पर भी निर्भर करता है कि आपका डेटाबेस सिस्टम मूल्यों को कैसे पढ़ता है !=
और <>
। डेटाबेस प्रदाता केवल इसे शॉर्टकट कर सकता है और उन्हें समान कार्य कर सकता है, इसलिए इसका कोई लाभ नहीं है। PostgreSQL और SQL सर्वर इसे शॉर्टकट नहीं बनाते हैं; जैसा कि ऊपर दिखाई देता है यह पढ़ा जाता है।