एसक्यूएल केस स्टेटमेंट

SQL में, CASE स्टेटमेंट शर्तों की सूची का मूल्यांकन करता है और कई संभावित परिणाम अभिव्यक्तियों में से एक देता है।

कुछ मायनों में, SQL CASE स्टेटमेंट कुछ हद तक IF...ELSE . के समान है इसमें कथन है कि यह हमें किसी दिए गए शर्त की जांच करने और परिणाम के आधार पर एक अलग परिणाम वापस करने की अनुमति देता है।

क्या यह एक CASE है? विवरण या CASE अभिव्यक्ति?

एसक्यूएल में, कभी-कभी चीजों को "कथन" के रूप में संदर्भित किया जाता है, जबकि वास्तव में, वे कुछ और होते हैं। एसक्यूएल “CASE स्टेटमेंट" एक मामला है (सज़ा के लिए खेद है!)।

CASE कथन को SQL मानक (ISO/IEC 9075) में CASE . के रूप में संदर्भित किया गया है अभिव्यक्ति . इसका उद्देश्य "सशर्त मान निर्दिष्ट करना" है।

हालांकि, कुछ DBMS CASE . के बीच अंतर करते हैं स्टेटमेंट और CASE अभिव्यक्ति, और प्रत्येक के लिए थोड़ा अलग वाक्यविन्यास है। उदाहरण के लिए, MySQL और MariaDB दोनों CASE . प्रदान करते हैं स्टेटमेंट और CASE ऑपरेटर दो अलग-अलग विशेषताओं के रूप में, प्रत्येक थोड़ा अलग सिंटैक्स के साथ।

CASE प्रारूप

SQL में CASE . के दो फ़ॉर्मैट होते हैं अभिव्यक्ति:

• सरल CASE अभिव्यक्ति
• खोज CASE अभिव्यक्ति

नीचे प्रत्येक के उदाहरण दिए गए हैं।

सरल CASE अभिव्यक्ति

आसान CASE अभिव्यक्ति परिणाम निर्धारित करने के लिए एक अभिव्यक्ति की तुलना सरल अभिव्यक्तियों के एक सेट से करती है।

उदाहरण:

DECLARE @animal VARCHAR(40);
SET @animal = 'Cow';

SELECT  
    CASE @animal  
        WHEN 'Bird' THEN 'Seed'
        WHEN 'Dog' THEN 'Beef'
        WHEN 'Cow' THEN 'Grass'
        ELSE 'Leftovers'  
    END;

परिणाम:

Grass

यह उदाहरण MySQL में किया गया था, लेकिन वास्तविक CASE अभिव्यक्ति को अधिकांश प्रमुख RDBMS में काम करना चाहिए।

इस उदाहरण में, मेरा CASE एक्सप्रेशन SELECT . का हिस्सा है बयान। यह तीन स्थितियों की जांच करता है और इसमें एक ELSE होता है ऐसी किसी भी चीज़ को पूरा करने के लिए जो तीन स्थितियों में शामिल नहीं है।

इस मामले में, जानवर Cow तीसरे से मेल खाता है WHEN अभिव्यक्ति, और इसके द्वारा प्रदान की गई अभिव्यक्ति THEN लौटा दिया गया है।

स्पष्ट होने के लिए, वास्तविक CASE अभिव्यक्ति यह हिस्सा है:

    CASE @animal  
        WHEN 'Bird' THEN 'Seed'
        WHEN 'Dog' THEN 'Beef'
        WHEN 'Cow' THEN 'Grass'
        ELSE 'Leftovers'  
    END

क्या CASE प्रत्येक WHEN . के मान की जांच करता है इनपुट अभिव्यक्ति के खिलाफ अभिव्यक्ति। इस उदाहरण में, @animal चर इनपुट अभिव्यक्ति है। इसलिए, यह प्रत्येक WHEN . के मान की जांच कर रहा है @animal . के विरुद्ध अभिव्यक्ति चर।

जब/यदि उसे कोई मिलान मिलता है, तो वह संबंधित THEN . द्वारा प्रदान किया गया व्यंजक लौटाता है .

मेरा उदाहरण तीन WHEN का उपयोग करता है भाव, लेकिन मैं और अधिक उपयोग कर सकता था और मैं आवश्यकताओं के आधार पर कम उपयोग कर सकता था।

खोजा गया CASE अभिव्यक्ति

खोजा गया CASE अभिव्यक्ति परिणाम निर्धारित करने के लिए बूलियन अभिव्यक्तियों के एक सेट का मूल्यांकन करती है।

यहां खोजे गए CASE . का एक उदाहरण दिया गया है अभिव्यक्ति।

DECLARE @score int;
SET @score = 7;

SELECT
    CASE   
        WHEN @score > 8 THEN 'Congratulations!'
        WHEN @score > 5 AND @score < 8 THEN 'Well done!'
        ELSE 'Try harder next time'  
    END;

परिणाम:

Well done!

खोजा गया CASE एक्सप्रेशन में साधारण CASE . जैसा इनपुट एक्सप्रेशन नहीं होता है अभिव्यक्ति।

आपको याद होगा कि हमारे सरल CASE . में अभिव्यक्ति, इसकी शुरुआत CASE . से हुई @animal , और इसलिए हम जानते थे कि WHEN सभी भाव @animal . के मान के विरुद्ध मूल्यांकन कर रहे थे ।

खोजे गए CASE . के साथ अभिव्यक्ति, हम इस तरह शुरुआत में एक इनपुट अभिव्यक्ति प्रदान नहीं करते हैं। इसके बजाय, प्रत्येक WHEN अभिव्यक्ति में एक बूलियन अभिव्यक्ति शामिल है जिसके लिए मूल्यांकन किया जाना है।

एक डेटाबेस उदाहरण

यहां एक उदाहरण दिया गया है जो दर्शाता है कि कैसे CASE अभिव्यक्ति का उपयोग डेटाबेस क्वेरी के भीतर किया जा सकता है।

USE World;
SELECT
    Name,
    Population,
      CASE 
         WHEN Population > 2000000 THEN 'Huge City'  
         WHEN Population >= 1000000 AND Population < 2000000 THEN 'Big City' 
         ELSE 'Small City'
      END AS Size
FROM City
WHERE CountryCode = 'USA'
ORDER BY Population DESC
LIMIT 20;

परिणाम:

+---------------+------------+------------+
| Name          | Population | Size       |
+---------------+------------+------------+
| New York      |    8008278 | Huge City  |
| Los Angeles   |    3694820 | Huge City  |
| Chicago       |    2896016 | Huge City  |
| Houston       |    1953631 | Big City   |
| Philadelphia  |    1517550 | Big City   |
| Phoenix       |    1321045 | Big City   |
| San Diego     |    1223400 | Big City   |
| Dallas        |    1188580 | Big City   |
| San Antonio   |    1144646 | Big City   |
| Detroit       |     951270 | Small City |
| San Jose      |     894943 | Small City |
| Indianapolis  |     791926 | Small City |
| San Francisco |     776733 | Small City |
| Jacksonville  |     735167 | Small City |
| Columbus      |     711470 | Small City |
| Austin        |     656562 | Small City |
| Baltimore     |     651154 | Small City |
| Memphis       |     650100 | Small City |
| Milwaukee     |     596974 | Small City |
| Boston        |     589141 | Small City |
+---------------+------------+------------+

यह उदाहरण खोजे गए CASE . का उपयोग करता है Population . से परिणामों का मूल्यांकन करने के लिए व्यंजक City . का कॉलम टेबल।

ELSE वैकल्पिक है

ELSE तर्क वैकल्पिक है। अगर हम ELSE . को छोड़ देते हैं , और कोई भी शर्त ट्रिगर नहीं होती है, परिणाम NULL . है ।

यहां बताया गया है कि जब हम ELSE . को छोड़ देते हैं तो क्या होता है पिछले उदाहरण से खंड:

USE World;
SELECT
    Name,
    Population,
      CASE 
         WHEN Population > 2000000 THEN 'Huge City'  
         WHEN Population >= 1000000 AND Population < 2000000 THEN 'Big City'
      END AS Size
FROM City
WHERE CountryCode = 'USA'
ORDER BY Population DESC
LIMIT 20;

परिणाम:

+---------------+------------+-----------+
| Name          | Population | Size      |
+---------------+------------+-----------+
| New York      |    8008278 | Huge City |
| Los Angeles   |    3694820 | Huge City |
| Chicago       |    2896016 | Huge City |
| Houston       |    1953631 | Big City  |
| Philadelphia  |    1517550 | Big City  |
| Phoenix       |    1321045 | Big City  |
| San Diego     |    1223400 | Big City  |
| Dallas        |    1188580 | Big City  |
| San Antonio   |    1144646 | Big City  |
| Detroit       |     951270 | NULL      |
| San Jose      |     894943 | NULL      |
| Indianapolis  |     791926 | NULL      |
| San Francisco |     776733 | NULL      |
| Jacksonville  |     735167 | NULL      |
| Columbus      |     711470 | NULL      |
| Austin        |     656562 | NULL      |
| Baltimore     |     651154 | NULL      |
| Memphis       |     650100 | NULL      |
| Milwaukee     |     596974 | NULL      |
| Boston        |     589141 | NULL      |
+---------------+------------+-----------+

CASE एक UPDATE . में कथन

आइए City में एक कॉलम जोड़ें पिछले उदाहरण से तालिका:

ALTER TABLE City
ADD COLUMN Size VARCHAR(30) AFTER Population;

SELECT * FROM City
LIMIT 10;

यह अब कैसा दिखता है:

+----+----------------+-------------+---------------+------------+------+
| ID | Name           | CountryCode | District      | Population | Size |
+----+----------------+-------------+---------------+------------+------+
|  1 | Kabul          | AFG         | Kabol         |    1780000 | NULL |
|  2 | Qandahar       | AFG         | Qandahar      |     237500 | NULL |
|  3 | Herat          | AFG         | Herat         |     186800 | NULL |
|  4 | Mazar-e-Sharif | AFG         | Balkh         |     127800 | NULL |
|  5 | Amsterdam      | NLD         | Noord-Holland |     731200 | NULL |
|  6 | Rotterdam      | NLD         | Zuid-Holland  |     593321 | NULL |
|  7 | Haag           | NLD         | Zuid-Holland  |     440900 | NULL |
|  8 | Utrecht        | NLD         | Utrecht       |     234323 | NULL |
|  9 | Eindhoven      | NLD         | Noord-Brabant |     201843 | NULL |
| 10 | Tilburg        | NLD         | Noord-Brabant |     193238 | NULL |
+----+----------------+-------------+---------------+------------+------+

हमने नए Size . में कोई डेटा नहीं डाला है कॉलम, इसलिए यह NULL लौटाता है हर पंक्ति में।

अब हम CASE . का उपयोग कर सकते हैं Size को अपडेट करने के लिए एक्सप्रेशन एक मान वाला कॉलम जो Population . में मान पर निर्भर करता है कॉलम:

UPDATE City 
SET Size = 
    CASE 
        WHEN Population > 2000000 THEN 'Huge City'  
        WHEN Population >= 1000000 AND Population < 2000000 THEN 'Big City'
        ELSE 'Small City'
    END;

अब तालिका से डेटा चुनें:

SELECT * FROM City
WHERE CountryCode = 'USA'
ORDER BY Population DESC
LIMIT 20;

परिणाम:

+------+---------------+-------------+---------------+------------+------------+
| ID   | Name          | CountryCode | District      | Population | Size       |
+------+---------------+-------------+---------------+------------+------------+
| 3793 | New York      | USA         | New York      |    8008278 | Huge City  |
| 3794 | Los Angeles   | USA         | California    |    3694820 | Huge City  |
| 3795 | Chicago       | USA         | Illinois      |    2896016 | Huge City  |
| 3796 | Houston       | USA         | Texas         |    1953631 | Big City   |
| 3797 | Philadelphia  | USA         | Pennsylvania  |    1517550 | Big City   |
| 3798 | Phoenix       | USA         | Arizona       |    1321045 | Big City   |
| 3799 | San Diego     | USA         | California    |    1223400 | Big City   |
| 3800 | Dallas        | USA         | Texas         |    1188580 | Big City   |
| 3801 | San Antonio   | USA         | Texas         |    1144646 | Big City   |
| 3802 | Detroit       | USA         | Michigan      |     951270 | Small City |
| 3803 | San Jose      | USA         | California    |     894943 | Small City |
| 3804 | Indianapolis  | USA         | Indiana       |     791926 | Small City |
| 3805 | San Francisco | USA         | California    |     776733 | Small City |
| 3806 | Jacksonville  | USA         | Florida       |     735167 | Small City |
| 3807 | Columbus      | USA         | Ohio          |     711470 | Small City |
| 3808 | Austin        | USA         | Texas         |     656562 | Small City |
| 3809 | Baltimore     | USA         | Maryland      |     651154 | Small City |
| 3810 | Memphis       | USA         | Tennessee     |     650100 | Small City |
| 3811 | Milwaukee     | USA         | Wisconsin     |     596974 | Small City |
| 3812 | Boston        | USA         | Massachusetts |     589141 | Small City |
+------+---------------+-------------+---------------+------------+------------+

CASE एक INSERT . में कथन

मान लीजिए हमारे पास SQL ​​सर्वर डेटाबेस में निम्न तालिका है:

+---------+-----------+-----------+--------------+
| DogId   | DogName   | GoodDog   | Dinner       |
|---------+-----------+-----------+--------------|
| 1001    | Brian     | 1         | Sunday Roast |
| 1002    | Rambo     | 0         | Airline food |
| 1003    | BamBam    | 1         | Sunday Roast |
+---------+-----------+-----------+--------------+

आइए उस तालिका में एक नई पंक्ति डालें। लेकिन चलिए CASE . का उपयोग करते हैं Dinner . में उचित मान डालने के लिए एक्सप्रेशन कॉलम, GoodDog . में मान के आधार पर कॉलम:

DECLARE @DogName nvarchar(60), @GoodDog bit;
SET @DogName = 'Lazy';
SET @GoodDog = 0;

INSERT INTO Dogs ( DogName, GoodDog, Dinner )
VALUES (
    @DogName,
    @GoodDog,
    CASE @GoodDog
        WHEN 1 THEN 'Sunday Roast'
        ELSE 'Airline food'
    END
    );

यहां, CASE एक्सप्रेशन ने एक वेरिएबल के मूल्य का मूल्यांकन किया जिसे हमने अभी सेट किया था, और फिर उचित मान को Dinner में डाला कॉलम।

अब तालिका को फिर से देखें:

SELECT * FROM Dogs;

परिणाम:

+---------+-----------+-----------+--------------+
| DogId   | DogName   | GoodDog   | Dinner       |
|---------+-----------+-----------+--------------|
| 1001    | Brian     | 1         | Sunday Roast |
| 1002    | Rambo     | 0         | Airline food |
| 1003    | BamBam    | 1         | Sunday Roast |
| 1004    | Lazy      | 0         | Airline food |
+---------+-----------+-----------+--------------+

हम देख सकते हैं कि उपयुक्त मूल्य Dinner . में है कॉलम।

CASE ORDER BY . में खंड

CASE अभिव्यक्ति का उपयोग किसी भी कथन या खंड में किया जा सकता है जो वैध अभिव्यक्ति की अनुमति देता है। इसलिए, आप इसे SELECT . जैसे स्टेटमेंट में इस्तेमाल कर सकते हैं , UPDATE , DELETE और SET , और खंड में जैसे IN , WHERE , ORDER BY , GROUP BY , और HAVING ।

CASE का उपयोग करना किसी कथन के ORDER BY . में व्यंजक जब आप अपने परिणामों का आदेश देते समय कुछ मूल्यों के लिए एक विशेष अपवाद बनाना चाहते हैं तो क्लॉज आसान हो सकता है।

मान लीजिए कि हम संगीत शैलियों वाली तालिका के विरुद्ध निम्न क्वेरी चलाते हैं।

SELECT Genre 
FROM Genres
ORDER BY Genre ASC;

परिणाम:

+---------+
| Genre   |
+---------+
| Blues   |
| Country |
| Hip Hop |
| Jazz    |
| Other   |
| Pop     |
| Punk    |
| Rap     |
| Rock    |
+---------+

यहां, हम परिणामों को Genre . के अनुसार क्रमित करते हैं स्तंभ, आरोही क्रम में।

यह एक बात को छोड़कर ठीक है। Other . नाम की शैली . क्या यह अच्छा नहीं होगा यदि हम Other नीचे तक?

हम इसे CASE . से हासिल कर सकते हैं उपरोक्त क्वेरी को लेकर और इसे निम्नानुसार संशोधित करके अभिव्यक्ति।

SELECT Genre
FROM Genres
ORDER BY 
    CASE Genre
        WHEN 'Other' THEN 1
        ELSE 0
    END
    ASC, Genre ASC;

परिणाम:

+---------+
| Genre   |
+---------+
| Blues   |
| Country |
| Hip Hop |
| Jazz    |
| Pop     |
| Punk    |
| Rap     |
| Rock    |
| Other   |
+---------+

द COALESCE() और NULLIF() कार्य

परिदृश्य के आधार पर हम COALESCE() . जैसे कार्यों का उपयोग कर सकते हैं और NULLIF() CASE . का उपयोग करने के बजाय शॉर्टकट के रूप में अभिव्यक्ति।

ये दो कार्य SQL मानक हैं, और ये निम्न प्रकार से कार्य करते हैं:

NULLIF (V1, V2)

के बराबर है:

CASE WHEN V1=V2 THEN NULL ELSE V1 END

और:

COALESCE (V1, V2)

के बराबर है:

CASE WHEN V1 IS NOT NULL THEN V1 ELSE V2 END

साथ ही:

COALESCE (V1, V2, ..., Vn)

के बराबर है:

CASE WHEN V1 IS NOT NULL THEN V1 ELSE COALESCE (V2, ..., Vn) END