12 आमतौर पर इस्तेमाल होने वाले SQL ऑपरेटर्स

SQL में, एक ऑपरेटर एक विशेष वर्ण या कीवर्ड होता है जो एक या अधिक अभिव्यक्तियों पर की जाने वाली क्रिया को निर्दिष्ट करता है।

SQL ऑपरेटर SQL का एक अभिन्न अंग हैं, और वे हमें प्रासंगिक परिणाम देने वाली क्वेरी लिखने में सक्षम बनाते हैं।

इस लेख में, मैं SQL क्वेरी लिखते समय सबसे अधिक उपयोग किए जाने वाले SQL ऑपरेटरों में से 12 प्रस्तुत करता हूं।

बराबर (= ) ऑपरेटर

बराबर ऑपरेटर (= ) शायद SQL में सबसे अधिक इस्तेमाल किया जाने वाला ऑपरेटर है। यह दो भावों की समानता की तुलना करता है। भले ही आप SQL के बारे में पूरी तरह से परिचित न हों, आप शायद इस ऑपरेटर को जानते होंगे।

कल्पना कीजिए कि हमारे पास एक पालतू होटल के लिए एक डेटाबेस है, और हम Fluffy नाम के सभी पालतू जानवरों के बारे में जानकारी प्राप्त करना चाहते हैं।

उस स्थिति में, हम यह कर सकते हैं:

SELECT PetId, PetName, DOB 
FROM Pets
WHERE PetName = 'Fluffy';

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
+---------+-----------+------------+

हमारी क्वेरी बराबर ऑपरेटर का उपयोग करती है (= ) PetName . के मान की समानता की तुलना करने के लिए कॉलम और स्ट्रिंग Fluffy .

हमारे मामले में, हम देख सकते हैं कि पालतू होटल में वर्तमान में Fluffy नामक दो पालतू जानवर हैं।

द ग्रेटर दैन (> ) ऑपरेटर

ग्रेटर थान ऑपरेटर (> ) दो भावों की तुलना करता है और TRUE . देता है यदि बाएं ऑपरेंड का मान दाएं ऑपरेंड से अधिक है; अन्यथा, परिणाम FALSE है ।

SELECT PetName, DOB 
FROM Pets
WHERE DOB > '2020-01-01';

परिणाम:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

इस मामले में, यह DOB . के मान की तुलना कर रहा है कॉलम और तारीख 2020-01-01 यह देखने के लिए कि क्या DOB कॉलम बड़ा है।

इससे कम (< ) ऑपरेटर

कम से कम ऑपरेटर (< ) इसके विपरीत करता है। यह दो भावों की तुलना करता है और TRUE returns देता है यदि बाएं ऑपरेंड का मान दाएं ऑपरेंड से कम है; अन्यथा, परिणाम FALSE है ।

SELECT PetName, DOB 
FROM Pets
WHERE DOB < '2020-01-01';

परिणाम:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
+-----------+------------+

इससे बड़ा या इसके बराबर (>= ) ऑपरेटर

ग्रेटर दैन या इक्वल टू ऑपरेटर (>= ) दो भावों की तुलना करता है और TRUE . देता है यदि बाएँ संकार्य का मान दाएँ संकार्य से अधिक या उसके बराबर है; अन्यथा, यह FALSE returns लौटाता है ।

SELECT PetName, DOB 
FROM Pets
WHERE DOB >= '2020-09-17';

परिणाम:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

ध्यान दें कि यह 2020-09-17 लौटाया गया है और उससे बड़ी सभी तिथियां। अगर हमने ग्रेटर थान ऑपरेटर का इस्तेमाल किया होता (> ), केवल पहली दो पंक्तियाँ लौटा दी जातीं।

इससे कम या इसके बराबर (<= ) ऑपरेटर

ऑपरेटर से कम या उसके बराबर (<= ) दो भावों की तुलना करता है और TRUE . देता है यदि बाएं ऑपरेंड का मान दाएं ऑपरेंड से कम या उसके बराबर है; अन्यथा, परिणाम FALSE है ।

SELECT PetName, DOB 
FROM Pets
WHERE DOB <= '2020-09-17';

परिणाम:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
| Wag       | 2020-03-15 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

ध्यान दें कि यह 2020-09-17 लौटाया गया है और सभी तिथियां उससे कम। अगर हमने कम से कम ऑपरेटर का इस्तेमाल किया था (< ), केवल पहली तीन पंक्तियाँ लौटा दी जातीं।

AND संचालिका

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

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

SELECT PetId, DOB 
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';

परिणाम:

+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

इस मामले में, हमें केवल उन पालतू जानवरों का विवरण मिलता है जहां उनका नाम Fluffy है और उनकी जन्मतिथि दो तिथियों के बीच है।

OR संचालिका

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

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

SELECT 
    PetId, 
    PetName,
    DOB 
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

यह मूल रूप से AND . के विपरीत है ऑपरेटर। अगर हम AND का इस्तेमाल करते , कोई पंक्तियाँ नहीं लौटाई जातीं, क्योंकि हम एक ही समय में एक कॉलम में दो अलग-अलग मान नहीं रख सकते।

BETWEEN संचालिका

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

SELECT
    PetName,
    DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';

परिणाम:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
+-----------+------------+

NOT संचालिका

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

यहां बताया गया है कि जब हम NOT जोड़ते हैं तो क्या होता है हमारे पिछले उदाहरण के लिए ऑपरेटर।

SELECT
    PetName,
    DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';

परिणाम:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

इस बार हमें अन्य सभी पालतू जानवर मिले - वे पालतू जानवर जो नहीं थे उन तिथियों के बीच पैदा हुए।

मारियाडीबी में, NOT IN . को नकारने तक सीमित है , BETWEEN , और EXISTS खंड। अधिकांश अन्य DBMS NOT की अनुमति देते हैं किसी भी अभिव्यक्ति को नकारने के लिए।

द IN संचालिका

IN ऑपरेटर यह निर्धारित करता है कि निर्दिष्ट मान किसी सबक्वेरी या सूची में किसी भी मान से मेल खाता है या नहीं।

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

SELECT 
    PetId, 
    PetName, 
    DOB 
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 4       | Wag       | 2020-03-15 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

हम दो OR . का उपयोग करके एक ही परिणाम प्राप्त कर सकते हैं ऑपरेटर:

SELECT 
    PetId, 
    PetName, 
    DOB 
FROM Pets
WHERE PetName = 'Fluffy' 
    OR PetName = 'Bark' 
    OR PetName = 'Wag';

हालांकि, IN ऑपरेटर इसे करने का एक संक्षिप्त तरीका है। IN ऑपरेटर विशेष रूप से फायदेमंद होता है जब आपके पास मूल्यों की एक लंबी सूची होती है जिसके खिलाफ तुलना की जा सकती है।

IN ऑपरेटर लगभग हमेशा एक से अधिक OR . की तुलना में जल्दी निष्पादित करता है ऑपरेटरों, विशेष रूप से बड़े डेटा सेट पर।

IN . का एक अन्य लाभ ऑपरेटर, यह है कि इसमें एक और SELECT हो सकता है सूची। इसे सबक्वायरी . के रूप में जाना जाता है . एक सबक्वेरी एक क्वेरी है जो किसी अन्य क्वेरी (या किसी अन्य सबक्वेरी) के अंदर नेस्ट की जाती है।

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

SELECT 
    PetTypeId,
    PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );

परिणाम:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
+-------------+-----------+

यह उदाहरण हमें दिखाता है कि हमारे पालतू होटल में कितने प्रकार के पालतू जानवर हैं।

हम NOT का उपयोग कर सकते हैं ऑपरेटर को इसे इधर-उधर करने के लिए और देखें कि कितने पालतू प्रकार हैं नहीं हमारे पालतू होटल में।

SELECT 
    PetTypeId,
    PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );

परिणाम:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 4           | Rabbit    |
+-------------+-----------+

तो हमारे डेटाबेस में एक पालतू प्रकार का Rabbit . है , लेकिन वर्तमान में हमारे पास पालतू जानवर के रूप में कोई खरगोश नहीं है।

द + और || स्ट्रिंग कॉन्सटेनेशन ऑपरेटर्स

+ और || स्ट्रिंग कॉन्सटेनेशन ऑपरेटर आपको स्ट्रिंग्स को जोड़ने की अनुमति देता है। स्ट्रिंग कॉन्सटेनेशन कैरेक्टर स्ट्रिंग्स को एंड-टू-एंड जोड़ने का ऑपरेशन है।

मैंने दो ऑपरेटरों को सूचीबद्ध किया है जो एक ही काम करते हैं, क्योंकि + ऑपरेटर SQL सर्वर में समर्थित है, और || ऑपरेटर DB2, Oracle, PostgreSQL, SQLite में समर्थित है।

यहां एक उदाहरण दिया गया है जो SQL सर्वर में काम करता है।

SELECT 
    FirstName,
    LastName,
    FirstName + LastName
FROM Owners;

परिणाम:

+-------------+------------+--------------------+
| FirstName   | LastName   | (No column name)   |
|-------------+------------+--------------------|
| Homer       | Connery    | HomerConnery       |
| Bart        | Pitt       | BartPitt           |
| Nancy       | Simpson    | NancySimpson       |
| Boris       | Trump      | BorisTrump         |
+-------------+------------+--------------------+

इस मामले में, मालिकों का अपना पहला नाम और अंतिम नाम अलग-अलग कॉलम में संग्रहीत होता है। हमारे SELECT . में सूची, हम पहले उन्हें अलग-अलग पुनर्प्राप्त करते हैं, लेकिन हम उन्हें एक साथ जोड़ने के लिए एक संयोजन ऑपरेटर का उपयोग करके उन्हें फिर से पुनर्प्राप्त भी करते हैं।

हालांकि हमारे परिणामों में कुछ समस्याएं हैं।

• प्रथम और अंतिम नामों के बीच कोई स्थान नहीं है।
• कोई कॉलम नाम नहीं है।

सौभाग्य से इसे ठीक करना आसान है।

हम प्रथम नाम और अंतिम नाम के बीच की जगह को शामिल करने के लिए समान संयोजन संचालन का उपयोग कर सकते हैं।

और हम परिणाम सेट में एक कॉलम नाम प्रदान करने के लिए एक कॉलम उपनाम का उपयोग कर सकते हैं।

SELECT 
    FirstName,
    LastName,
    FirstName + ' ' + LastName AS FullName
FROM Owners;

परिणाम:

+-------------+------------+---------------+
| FirstName   | LastName   | FullName      |
|-------------+------------+---------------|
| Homer       | Connery    | Homer Connery |
| Bart        | Pitt       | Bart Pitt     |
| Nancy       | Simpson    | Nancy Simpson |
| Boris       | Trump      | Boris Trump   |
+-------------+------------+---------------+

यदि आप DB2, Oracle, PostgreSQL, SQLite का उपयोग कर रहे हैं, तो + . को स्वैप करें || . के लिए और इसे ठीक काम करना चाहिए।

यदि आप MySQL या MariaDB का उपयोग कर रहे हैं, तो आपको CONCAT() . का उपयोग करना होगा स्ट्रिंग्स को जोड़ने का कार्य करता है।

LIKE संचालिका

LIKE ऑपरेटर आपको पैटर्न मिलान करने की अनुमति देता है। यह निर्धारित करता है कि एक विशिष्ट वर्ण स्ट्रिंग एक निर्दिष्ट पैटर्न से मेल खाती है या नहीं। एक पैटर्न में नियमित वर्ण और वाइल्डकार्ड वर्ण शामिल हो सकते हैं।

SELECT 
    FirstName,
    LastName,
    Email
FROM Owners
WHERE Email LIKE '%.com';

परिणाम:

+-------------+------------+-------------------+
| FirstName   | LastName   | Email             |
|-------------+------------+-------------------|
| Homer       | Connery    | [email protected] |
| Bart        | Pitt       | [email protected]  |
+-------------+------------+-------------------+

इस उदाहरण में, मैंने LIKE . का उपयोग किया है % . के साथ संचालिका वाइल्डकार्ड ऑपरेटर उन मालिकों को लौटाएगा जिनके ईमेल पते .com . में समाप्त होते हैं ।

बोनस ऑपरेटर! % वाइल्डकार्ड ऑपरेटर

% वाइल्डकार्ड ऑपरेटर शून्य या अधिक वर्णों की किसी भी स्ट्रिंग से मेल खाता है। इसका उपयोग उपसर्ग या प्रत्यय के रूप में किया जा सकता है, और इसका उपयोग स्ट्रिंग के बीच में भी किया जा सकता है।

यह आमतौर पर प्रत्यय के रूप में अधिक उपयोग किया जाता है, और पैटर्न के बीच में इसका सीमित उपयोग होता है, हालांकि पैटर्न के बीच में इसका उपयोग करने के लिए कुछ वैध उपयोग-मामले हैं, जैसे कि निम्न:

SELECT 
    FirstName,
    LastName,
    Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';

परिणाम:

+-------------+------------+------------------+
| FirstName   | LastName   | Email            |
|-------------+------------+------------------|
| Bart        | Pitt       | [email protected] |
+-------------+------------+------------------+

इस मामले में, हमें बार्ट का ईमेल पता नहीं पता था, लेकिन हमें पता था कि यह [email protected] से शुरू हुआ था। और .com . में समाप्त हुआ . इसलिए, हम LIKE . का उपयोग करने में सक्षम थे % . के संयोजन में बाकी को भरने के लिए वाइल्डकार्ड ऑपरेटर।

ध्यान रखें कि यह तकनीक डेटा के आधार पर और आप अपने SQL स्टेटमेंट को कैसे बनाते हैं, इसके आधार पर बहुत सारी अप्रासंगिक पंक्तियाँ लौटा सकती हैं।

यह भी जान लें कि LIKE . वाली क्वेरीज़ क्लॉज अन्य प्रश्नों की तुलना में बहुत धीमी गति से चल सकता है, और आपको संभवतः LIKE . का उपयोग करने से बचना चाहिए खंड जब तक आपको वास्तव में इसकी आवश्यकता न हो। % का उपयोग करना उपसर्ग के रूप में ऑपरेटर विशेष रूप से धीमा हो सकता है।

इसका मतलब यह नहीं है कि आपको इसका इस्तेमाल बिल्कुल नहीं करना चाहिए। LIKE ऑपरेटर एसक्यूएल का एक अभिन्न अंग है, और आप कई परिदृश्यों का सामना करेंगे जहां यह एकमात्र विकल्प होगा (या कम से कम, सबसे अच्छा विकल्प)।

अधिक SQL ऑपरेटर

अन्य ऑपरेटरों के पूरे समूह के लिए SQL ऑपरेटरों की मेरी पूरी सूची देखें जो यहां शामिल नहीं हैं।