तुलना ऑपरेटर अधिकांश प्रोग्रामिंग भाषाओं का एक महत्वपूर्ण हिस्सा हैं।
तुलना ऑपरेटरों का उपयोग दो भावों की तुलना करने के लिए किया जाता है। परिणाम या तो true है या false . यह अज्ञात भी हो सकता है। इसे 1 . द्वारा भी दर्शाया जा सकता है , 0 , या NULL , भाषा के आधार पर। इन्हें आम तौर पर "बूलियन एक्सप्रेशन" के रूप में जाना जाता है।
जब डेटाबेस के साथ उपयोग किया जाता है, तो डेटा को एक निश्चित मानदंड पर फ़िल्टर करने के लिए आपके SQL क्वेरी के अंदर तुलना ऑपरेटरों का उपयोग किया जा सकता है।
सामान्य तुलना ऑपरेटर
अधिकांश प्रोग्रामिंग भाषाएं किसी न किसी रूप में निम्नलिखित तुलना ऑपरेटरों का समर्थन करती हैं:
| ऑपरेटर | <थ>अर्थ|
|---|---|
= | बराबर |
> | से बड़ा |
< | इससे कम |
>= | इससे बड़ा या इसके बराबर |
<= | इससे कम या इसके बराबर |
<> | बराबर नहीं |
SQL उपरोक्त तालिका में सूचीबद्ध समान सिंटैक्स का उपयोग करता है।
असाइनमेंट ऑपरेटरों के साथ भ्रम से बचने के लिए कुछ भाषाएं एक अलग सिंटैक्स का उपयोग करती हैं। उदाहरण के लिए, पायथन और जावास्क्रिप्ट == . का उपयोग करते हैं = . के बजाय . दूसरी ओर, कोल्डफ्यूजन eq . का उपयोग करता है ।
विभिन्न डेटा प्रकार
कुछ भाषाओं में यह निर्दिष्ट करने के लिए एक विशेष ऑपरेटर होता है कि दोनों मान एक ही डेटा प्रकार के होने चाहिए।
उदाहरण के लिए, जावास्क्रिप्ट में === . भी शामिल है ऑपरेटर जो निर्दिष्ट करता है कि दोनों मान समान हैं और कि वे एक ही डेटा प्रकार के होने चाहिए। लेकिन अगर डेटा प्रकार अप्रासंगिक है, तो == . का उपयोग करें बजाय।
उदाहरण
ऑपरेटर से बड़ा
टी-एसक्यूएल क्वेरी में ग्रेटर थान ऑपरेटर का उपयोग करने का एक उदाहरण यहां दिया गया है।
SELECT Name, Population
FROM country
WHERE Population > 100000000
ORDER BY Population DESC;परिणाम:
+--------------------+--------------+ | Name | Population | |--------------------+--------------| | China | 1277558000 | | India | 1013662000 | | United States | 278357000 | | Indonesia | 212107000 | | Brazil | 170115000 | | Pakistan | 156483000 | | Russian Federation | 146934000 | | Bangladesh | 129155000 | | Japan | 126714000 | | Nigeria | 111506000 | +--------------------+--------------+
इस उदाहरण में मैंने ग्रेटर थान ऑपरेटर का इस्तेमाल किया (> ) केवल 100000000 से अधिक जनसंख्या वाले देशों का चयन करने के लिए।
बराबर ऑपरेटर
यहां एक और उदाहरण है, जहां मैं बराबर ऑपरेटर का उपयोग करता हूं (= ) दिए गए मान के बिल्कुल बराबर डेटा लौटाने के लिए।
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'परिणाम:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
इस मामले में मैं केवल उन्हीं शहरों को लौटाता हूं जिनका देश कोड AFG . के बराबर है .
यह दर्शाता है कि तुलना ऑपरेटर केवल संख्यात्मक डेटा प्रकारों तक ही सीमित नहीं हैं।
तिथियां
आप तिथियों पर तुलना ऑपरेटरों का भी उपयोग कर सकते हैं, उदाहरण के लिए:
SELECT * FROM Artists
WHERE ActiveFrom > '1990-01-01';परिणाम:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | +------------+----------------+--------------+
जैसा कि आप देख सकते हैं, केवल वही परिणाम लौटाए गए हैं जो निर्दिष्ट तिथि से (बाद में) अधिक हैं।
ऑपरेटर से बड़ा या उसके बराबर
मैं परिणामों में निर्दिष्ट तिथि को शामिल करने के लिए ग्रेटर देन या इक्वल टू ऑपरेटर का उपयोग कर सकता हूं।
SELECT * FROM Artists
WHERE ActiveFrom >= '1990-01-01';परिणाम:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | | 16 | Bodyjar | 1990-01-01 | +------------+----------------+--------------+
इस मामले में, एक अतिरिक्त पंक्ति (अंतिम पंक्ति) लौटा दी जाती है।
ऑपरेटर से कम
अगर मैं अपनी क्वेरी को कम से कम ऑपरेटर का उपयोग करने के लिए बदलता हूं तो यहां क्या होता है।
SELECT * FROM Artists
WHERE ActiveFrom < '1990-01-01';परिणाम:
+------------+------------------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+------------------------+--------------| | 1 | Iron Maiden | 1975-12-25 | | 2 | AC/DC | 1973-01-11 | | 3 | Allan Holdsworth | 1969-01-01 | | 4 | Buddy Rich | 1919-01-01 | | 6 | Jim Reeves | 1948-01-01 | | 7 | Tom Jones | 1963-01-01 | | 10 | Lit | 1988-06-26 | | 11 | Black Sabbath | 1968-01-01 | | 12 | Michael Learns to Rock | 1988-03-15 | | 13 | Carabao | 1981-01-01 | +------------+------------------------+--------------+
मुझे सभी पंक्तियां मिलती हैं जो निर्दिष्ट तिथि से कम हैं।
नल मानों की तुलना करना
NULL तुलना ऑपरेटरों का उपयोग करते समय मूल्य चीजों को थोड़ा जटिल कर सकते हैं। संक्षेप में, आपको एक भिन्न परिणाम मिल सकता है, जो इस पर निर्भर करता है कि आपका परिवेश कैसे कॉन्फ़िगर किया गया है।
उदाहरण के लिए, SQL सर्वर में, यदि आप बराबर ऑपरेटर का उपयोग करते हैं (= ) या नॉट इक्वल ऑपरेटर (<> ) NULL . के विरुद्ध परीक्षण करने के लिए , आपका परिणाम आपके ANSI_NULLS . पर निर्भर करेगा सेटिंग (अर्थात क्या यह ON है या OFF )।
NULL के विरुद्ध परीक्षण करने के लिए मान, SQL सर्वर IS NULL भी प्रदान करता है विधेय, जो आपके ANSI_NULLS . की परवाह किए बिना, लगातार काम करता है सेटिंग। इसमें IS NOT NULL . भी शामिल है गैर-NULL . के विरुद्ध परीक्षण के लिए भिन्नता मूल्य।
नीचे एक उदाहरण दिया गया है जो दर्शाता है कि मेरा क्या मतलब है।
ANSI_NULLS ON
पहले हम ANSI_NULLS . सेट करते हैं करने के लिए ON , फिर NULL . के विरुद्ध कुछ परीक्षण चलाएँ .
SET ANSI_NULLS ON;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;परिणाम:
(0 rows affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) (0 rows affected)
ANSI_NULLS OFF
अब हम ANSI_NULLS . सेट करते हैं करने के लिए OFF , फिर वही परीक्षण चलाएँ।
SET ANSI_NULLS OFF;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;परिणाम:
+--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected)
