SQL में, ऑपरेटर के बराबर नहीं (<> ) दो भावों की गैर-समानता की तुलना करता है। अर्थात्, यह परीक्षण करता है कि क्या एक व्यंजक नहीं है दूसरे व्यंजक के बराबर।
यदि दोनों में से कोई एक या दोनों ऑपरेंड NULL हैं , NULL लौटा दिया गया है।
एसक्यूएल में एक और ऑपरेटर के बराबर नहीं है (!= ), जो वही काम करता है। आप किसका उपयोग करते हैं, यह आपके DBMS पर निर्भर करता है कि आप किसका उपयोग करने में सबसे अधिक सहज हैं, और शायद यह भी कि क्या आपके संगठन में कोई कोडिंग परंपराएँ हैं जो यह निर्धारित करती हैं कि किसका उपयोग किया जाना चाहिए।
स्रोत तालिका
कल्पना कीजिए कि हमारे डेटाबेस में निम्न तालिका है। यह वह तालिका है जिसका उपयोग हम इस पृष्ठ पर उदाहरणों के लिए करेंगे।
SELECT * FROM Pets;परिणाम:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+ (8 rows affected)
उदाहरण
अगर हम उन सभी पालतू जानवरों को प्राप्त करना चाहते हैं जो नहीं करते हैं एक निश्चित मालिक है, हम यह कर सकते हैं:
SELECT *
FROM Pets
WHERE OwnerId <> 3;परिणाम:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
हमारी क्वेरी ऑपरेटर के बराबर नहीं का उपयोग करती है (<> ) यह जांचने के लिए कि क्या OwnerId कॉलम 3 . के बराबर नहीं है . क्वेरी उन सभी पालतू जानवरों को लौटाती है जिनके पास स्वामी के रूप में स्वामी संख्या 3 नहीं है।
स्ट्रिंग्स
स्ट्रिंग मान के साथ तुलना करते समय, स्ट्रिंग के चारों ओर उद्धरण चिह्नों का उपयोग करें। उदाहरण के लिए, यदि हम उन सभी पालतू जानवरों के बारे में जानकारी प्राप्त करना चाहते हैं जिनका नाम Fluffy नहीं है, तो हम निम्न कार्य कर सकते हैं:
SELECT *
FROM Pets
WHERE PetName <> 'Fluffy';परिणाम:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
एकाधिक शर्तें
यदि आपके पास एकाधिक शर्तें हैं, तो आप एकाधिक ऑपरेटरों का उपयोग कर सकते हैं (चाहे एक ही ऑपरेटर या अलग दोनों)।
इस तरह:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;परिणाम:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
शर्त को नकारना
यदि आप NOT का उपयोग करते हैं ऑपरेटर के बराबर नहीं ऑपरेटर द्वारा प्रदान की गई शर्त को अस्वीकार करने के लिए, आप अंत में (= के बराबर के परिणाम प्राप्त करेंगे। ) ऑपरेटर:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';परिणाम:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
इस मामले में, आप केवल (= . के बराबर का उपयोग करने से बेहतर हैं ) ऑपरेटर, इस तरह:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
बेशक, इसे NOT . से नकारा जा सकता है ऑपरेटर, जो तब हमें वही परिणाम देगा जो (<> .) के बराबर है ) ऑपरेटर हमें देता है:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';शून्य मान
आपने देखा होगा कि हमारी मूल नमूना तालिका में कुछ NULL हैं DOB कॉलम में मान।
एक कॉलम जिसमें NULL . है यानी इसका कोई मूल्य नहीं है। यह 0 . से अलग है या false , या यहां तक कि एक खाली स्ट्रिंग।
NULL . से तुलना करने के लिए आप नॉट बराबर ऑपरेटर का उपयोग नहीं कर सकते हैं . दरअसल, यह आपके डीबीएमएस और इसके कॉन्फ़िगरेशन पर निर्भर हो सकता है। लेकिन अभी के लिए, आइए देखें कि क्या होता है यदि मैं DOB कॉलम की तुलना NULL से करने की कोशिश करता हूं ।
SELECT * FROM Pets
WHERE DOB <> NULL;परिणाम:
(0 rows affected)
गैर के लिए परीक्षण करने का तरीका-NULL मानों का उपयोग करना है IS NOT NULL ।
इसलिए, हमें उपरोक्त कथन को निम्नानुसार फिर से लिखना होगा।
SELECT * FROM Pets
WHERE DOB IS NOT NULL;परिणाम:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
अब हमें केवल वही पंक्तियाँ मिलती हैं जो NULL . नहीं हैं DOB . में कॉलम।
यदि आप रुचि रखते हैं, तो देखें SQL Server ANSI_NULLS Explained यह देखने के लिए कि आप NULL का तरीका कैसे बदल सकते हैं SQL सर्वर में मानों का इलाज किया जाता है।
