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

SQL में, AND ऑपरेटर आपको अपने प्रश्नों को फ़िल्टर करते समय कई शर्तों की जांच करने की अनुमति देता है।

AND ऑपरेटर दो बूलियन अभिव्यक्तियों को जोड़ता है और TRUE returns देता है जब दोनों भाव TRUE हों ।

स्रोत तालिका

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

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)

उदाहरण

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

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

परिणाम:

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

जैसा कि अपेक्षित था, इसने केवल उन पंक्तियों को लौटाया जहां दोनों PetName कॉलम था Fluffy और DOB कॉलम 2020-11-01 . से बड़ा था .

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

अन्य ऑपरेटरों के साथ संयुक्त

आपके फ़िल्टरिंग मानदंड उन अभिव्यक्तियों को जोड़ सकते हैं जो AND . के अतिरिक्त अन्य ऑपरेटरों का उपयोग करते हैं ऑपरेटर।

यहां एक उदाहरण दिया गया है जिसमें OR . शामिल है ऑपरेटर।

SELECT * FROM Pets 
WHERE (PetName = 'Fluffy' OR PetName = 'Tweet')
AND DOB >= '2020-11-20';

परिणाम:

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

ध्यान दें कि मैंने OR . को घेर लिया है कोष्ठक के साथ स्थिति। मैंने ऐसा उस क्रम को निर्दिष्ट करने के लिए किया जिसमें प्रत्येक अभिव्यक्ति का मूल्यांकन किया जाना चाहिए।

डिफ़ॉल्ट रूप से, AND ऑपरेटरों का मूल्यांकन OR . से पहले किया जाता है ऑपरेटरों। SQL में एक एक्सप्रेशन में ऑपरेटरों की प्राथमिकता का एक परिभाषित क्रम होता है, और यह निर्देश देता है कि AND ऑपरेटर का मूल्यांकन OR . से पहले किया जाता है ऑपरेटर।

हालांकि, आप अभिव्यक्ति में ऑपरेटरों की परिभाषित प्राथमिकता को ओवरराइड करने के लिए कोष्ठक का उपयोग कर सकते हैं। कोष्ठक के भीतर सब कुछ एक मूल्य वापस करने के लिए मूल्यांकन किया जाता है। उस मान का उपयोग किसी भी ऑपरेटर द्वारा उन कोष्ठकों के बाहर किया जा सकता है।

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

इस समस्या को प्रदर्शित करने के लिए, जब हम कोष्ठक हटाते हैं तो परिणामों पर एक नज़र डालते हैं।

SELECT * FROM Pets 
WHERE PetName = 'Fluffy' OR PetName = 'Tweet'
AND DOB >= '2020-11-20';

परिणाम:

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

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

ऐसा इसलिए है, क्योंकि क्वेरी अब PetName = 'Tweet' AND DOB >= '2020-11-20' की जांच करती है। सबसे पहले, फिर OR की जांच करता है अभिव्यक्ति PetName = 'Fluffy' ।

यह ऐसा है जैसे हम AND . के चारों ओर कोष्ठक लगाते हैं अभिव्यक्ति, इस तरह:

SELECT * FROM Pets 
WHERE PetName = 'Fluffy' OR (PetName = 'Tweet'
AND DOB >= '2020-11-20');

हालांकि, चीजों को और अधिक भ्रमित करने के लिए, हम अपनी क्वेरी को पुनर्व्यवस्थित कर सकते हैं ताकि हम कोष्ठक का उपयोग न करें, और फिर भी वही परिणाम प्राप्त करें जो हमारे पहले उदाहरण कोष्ठक के साथ है।

इस तरह:

SELECT * FROM Pets 
WHERE DOB >= '2020-11-20' 
AND PetName = 'Fluffy' OR PetName = 'Tweet';

परिणाम:

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

इस मामले में, AND अपेक्षित के रूप में पहले अभिव्यक्ति का मूल्यांकन किया गया था। भावों का क्रम बस इतना हुआ कि DOB >= '2020-11-20' AND PetName = 'Fluffy' पहले मूल्यांकन किया गया था, इसलिए हमने Fluffy नामक दूसरे पालतू जानवर को उसके DOB . के कारण बाहर कर दिया उस सीमा से बाहर गिरना। उसके बाद ही, OR . था अभिव्यक्ति का मूल्यांकन हमारे मौजूदा AND . की वैकल्पिक स्थिति के रूप में किया जाता है परिणाम।

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