शुरुआती के लिए एसक्यूएल नहीं ऑपरेटर

SQL में, NOT ऑपरेटर एक बूलियन इनपुट को अस्वीकार करता है (यह किसी भी बूलियन अभिव्यक्ति के मूल्य को उलट देता है)। इसलिए यह TRUE returns लौटाता है जब व्यंजक FALSE हो .

स्रोत तालिका

इस पृष्ठ पर उदाहरणों के लिए निम्न तालिका का उपयोग किया गया है।

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)

उदाहरण 1

NOT को प्रदर्शित करने के लिए यहां एक सरल उदाहरण दिया गया है ऑपरेटर।

SELECT * FROM Pets 
WHERE PetName NOT LIKE 'F%';

परिणाम:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 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       |
+---------+-------------+-----------+-----------+------------+

इस मामले में, हमने NOT . का इस्तेमाल किया ऑपरेटर LIKE . के परिणाम को नकारने के लिए ऑपरेटर। हमारी क्वेरी उन सभी पालतू जानवरों को लौटाती है जो F अक्षर से शुरू नहीं होते हैं।

उदाहरण 2 - तुलना ऑपरेटरों के साथ NOT का उपयोग करना

यदि आप NOT . का उपयोग कर रहे हैं तुलना ऑपरेटर को नकारने के लिए, आपको अपने सिंटैक्स को पिछले उदाहरण में उपयोग किए गए सिंटैक्स से थोड़ा संशोधित करना होगा।

उदाहरण के लिए, यदि आप इसका उपयोग बराबर ऑपरेटर को नकारने के लिए करना चाहते हैं (= ), निम्नलिखित सिंटैक्स का उपयोग करें:

SELECT * FROM Pets 
WHERE NOT 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       |
+---------+-------------+-----------+-----------+------------+

यह उन सभी पालतू जानवरों को लौटा देता है जिनका नाम Fluffy नहीं है।

इस उदाहरण में, हम NOT डालते हैं कॉलम नाम के सामने ऑपरेटर। यदि हमने ऐसा नहीं किया होता, तो हमें एक त्रुटि प्राप्त होती जो कुछ इस प्रकार से होती:

SELECT * FROM Pets 
WHERE PetName NOT = 'Fluffy';

परिणाम:

Msg 102, Level 15, State 1, Line 2
Incorrect syntax near '='.

हम ऑपरेटर के बराबर नहीं का उपयोग करके भी वही परिणाम प्राप्त कर सकते थे (या तो <> या != आपके डीबीएमएस के आधार पर)।

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

SELECT * FROM Pets 
WHERE PetName <> 'Fluffy';

या यह:

SELECT * FROM Pets 
WHERE PetName != 'Fluffy';

उदाहरण 3 - तार्किक ऑपरेटरों के साथ समान सिंटैक्स

जैसा कि यह पता चला है, हम तार्किक ऑपरेटरों का उपयोग करते समय उस वाक्यविन्यास का भी उपयोग कर सकते हैं, जैसे कि LIKE ऑपरेटर जिसे हमने पहले उदाहरण में इस्तेमाल किया था।

इसलिए, हम इसका पहला उदाहरण फिर से लिख सकते हैं:

SELECT * FROM Pets 
WHERE NOT PetName LIKE 'F%';

परिणाम:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 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       |
+---------+-------------+-----------+-----------+------------+

यदि आप सुनिश्चित नहीं हैं कि अंतर क्या है, तो हमने NOT को स्थानांतरित कर दिया है PetName . के बाद से ऑपरेटर कॉलम, इससे पहले।

यहां दो कथन एक साथ दिए गए हैं:

SELECT * FROM Pets 
WHERE PetName NOT LIKE 'F%';

SELECT * FROM Pets 
WHERE NOT PetName LIKE 'F%';

उदाहरण 4 - अनेक शर्तों को नकारना

NOT ऑपरेटर केवल एक शर्त को नकारता है। यदि आपके पास कई शर्तें हैं जिन्हें आपको अस्वीकार करने की आवश्यकता है, तो एक अलग NOT का उपयोग करें प्रत्येक शर्त के लिए ऑपरेटर,

SELECT * FROM Pets 
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';

परिणाम:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+

उदाहरण 5 - वरीयता

मिश्रित स्थितियों का उपयोग करते समय, जहां आपके पास एकाधिक ऑपरेटर हैं, NOT ऑपरेटर का मूल्यांकन किसी भी तार्किक ऑपरेटर से पहले किया जाता है, लेकिन किसी के बाद भी। तुलना ऑपरेटर,

जब किसी व्यंजक में दो ऑपरेटरों की प्राथमिकता का स्तर समान होता है, तो उनका मूल्यांकन व्यंजक में उनकी स्थिति के आधार पर बाएँ से दाएँ किया जाता है। हालांकि, आप उस क्रम को निर्दिष्ट करने के लिए कोष्ठक का उपयोग कर सकते हैं जिसमें आप चाहते हैं कि प्रत्येक शर्त का मूल्यांकन किया जाए।

यहाँ एक उदाहरण है।

SELECT * FROM Pets 
WHERE 
    NOT PetName = 'Fluffy'
    OR NOT PetName = 'Wag'
    AND NOT DOB > '2020-01-01';

परिणाम:

+---------+-------------+-----------+-----------+------------+
| 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       |
+---------+-------------+-----------+-----------+------------+

हमने यहां किसी भी कोष्ठक का उपयोग नहीं किया, और NOT के साथ सभी शर्तों को नकार दिया गया ऑपरेटर, और इसलिए AND ऑपरेटर ने OR . पर वरीयता ली ऑपरेटर।

हालांकि, हम यह निर्दिष्ट करने के लिए कोष्ठक का उपयोग कर सकते हैं कि OR स्थिति का मूल्यांकन AND . से पहले किया जाना चाहिए हालत।

SELECT * FROM Pets 
WHERE 
    (NOT PetName = 'Fluffy'
    OR NOT PetName = 'Wag')
    AND NOT DOB > '2020-01-01';

परिणाम:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
+---------+-------------+-----------+-----------+------------+

इस मामले में हमें एक अलग परिणाम मिलता है।

उदाहरण 6 - ऑपरेटर के बीच नेगेट करें

यहां एक और उदाहरण दिया गया है, इस बार NOT . का उपयोग करते हुए ऑपरेटर BETWEEN . के परिणाम को नकारने के लिए ऑपरेटर।

SELECT * FROM Pets 
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';

परिणाम:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
+---------+-------------+-----------+-----------+------------+

इस उदाहरण में, हमने उन सभी पंक्तियों को लौटा दिया जहां DOB कॉलम नहीं है 2018-10-01 . के बीच और 2020-09-17 .

इस मामले में, दो पंक्तियाँ उस मानदंड से मेल खाती थीं, और इसलिए, दो पंक्तियाँ वापस कर दी गईं।

यह निम्न क्वेरी का विपरीत परिणाम है:

SELECT * FROM Pets 
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';

परिणाम:

+---------+-------------+-----------+-----------+------------+
| 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 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
+---------+-------------+-----------+-----------+------------+

इस उदाहरण में, हमने उन सभी पंक्तियों को लौटा दिया जहां DOB कॉलम है 2018-10-01 . के बीच और 2020-09-17 .

इस मामले में, चार पंक्तियाँ उस मानदंड से मेल खाती थीं, और इसलिए, चार पंक्तियाँ वापस कर दी गईं।