SQL सर्वर केस एक्सप्रेशन

SQL सर्वर में, T-SQL CASE अभिव्यक्ति एक अदिश व्यंजक है जो सशर्त तर्क के आधार पर मान लौटाता है। यह शर्तों की सूची का मूल्यांकन करता है और उन स्थितियों के परिणाम के आधार पर एक मान देता है..

कुछ मायनों में, SQL सर्वर CASE अभिव्यक्ति IF...ELSE . के समान है . हालांकि, CASE आपको कई स्थितियों की जांच करने की अनुमति देता है, जबकि IF...ELSE नहीं करता है।

साथ ही, SQL सर्वर में, IF...ELSE एक नियंत्रण-प्रवाह भाषा कीवर्ड है, जबकि CASE क्या नहीं है। CASE एक्सप्रेशन का उपयोग टी-एसक्यूएल स्टेटमेंट्स, स्टेटमेंट ब्लॉक्स, यूज़र-डिफ़ाइंड फ़ंक्शंस और संग्रहीत प्रक्रियाओं के निष्पादन के प्रवाह को नियंत्रित करने के लिए नहीं किया जा सकता है।

केस एक्सप्रेशन के 2 रूप

CASE . के दो रूप हैं SQL सर्वर में एक्सप्रेशन:

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

इन्हें नीचे उदाहरणों के साथ समझाया गया है।

फॉर्म 1 - साधारण केस एक्सप्रेशन

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

यह दिखाने के लिए एक बुनियादी उदाहरण दिया गया है कि कैसे CASE अभिव्यक्ति SQL सर्वर में काम करती है।

DECLARE @stock_ticker varchar(4) = 'V';

SELECT Company =  
    CASE @stock_ticker  
        WHEN 'AAPL' THEN 'Apple'
        WHEN 'FB' THEN 'Facebook'
        WHEN 'V' THEN 'Visa'
        ELSE 'Not in the portfolio'  
    END

परिणाम:

+-----------+
| Company   |
|-----------|
| Visa      |
+-----------+

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

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

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

    CASE @stock_ticker  
        WHEN 'AAPL' THEN 'Apple'
        WHEN 'FB' THEN 'Facebook'
        WHEN 'MA' THEN 'Mastercard'
        WHEN 'V' THEN 'Visa'
        ELSE 'Not in the portfolio'  
    END

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

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

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

फॉर्म 2 - सर्च किया गया केस एक्सप्रेशन

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

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

DECLARE @price int = 1500;

SELECT Affordability =  
    CASE   
        WHEN @price < 100 THEN 'Cheap'
        WHEN @price >= 100 AND @price < 500 THEN 'Affordable'
        ELSE 'Expensive'  
    END

परिणाम:

+-----------------+
| Affordability   |
|-----------------|
| Expensive       |
+-----------------+

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

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

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

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

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

USE WideWorldImporters;
SELECT 
    CityName AS [City], 
    LatestRecordedPopulation AS [Population], 
    Size =  
      CASE 
         WHEN LatestRecordedPopulation < 2000000 THEN 'Small City'  
         WHEN LatestRecordedPopulation >= 2000000 AND LatestRecordedPopulation < 3000000 THEN 'Big City' 
         ELSE 'Really Big City'
      END 
FROM Application.Cities
WHERE LatestRecordedPopulation > 1000000;

परिणाम:

+--------------+--------------+-----------------+
| City         | Population   | Size            |
|--------------+--------------+-----------------|
| Brooklyn     | 2565635      | Big City        |
| Chicago      | 2695598      | Big City        |
| Dallas       | 1197816      | Small City      |
| Houston      | 2099451      | Big City        |
| Los Angeles  | 3792621      | Really Big City |
| Manhattan    | 1619090      | Small City      |
| New York     | 8175133      | Really Big City |
| Philadelphia | 1526006      | Small City      |
| Phoenix      | 1445632      | Small City      |
| Queens       | 2272771      | Big City        |
| San Antonio  | 1327407      | Small City      |
| San Diego    | 1307402      | Small City      |
| The Bronx    | 1408473      | Small City      |
+--------------+--------------+-----------------+

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

डेटा प्रकार

SQL सर्वर में, इनपुट एक्सप्रेशन का डेटा प्रकार और WHEN अभिव्यक्ति समान होनी चाहिए या एक अंतर्निहित रूपांतरण होना चाहिए।

यदि वे नहीं हैं तो यहां क्या होगा:

DECLARE @stock_ticker varchar(4) = 'V';

SELECT Company =  
      CASE @stock_ticker  
         WHEN 1 THEN 'Apple'
         WHEN 2 THEN 'Facebook'
         WHEN 3 THEN 'Mastercard'
         WHEN 4 THEN 'Visa'
         ELSE 'Not in the portfolio'  
      END

परिणाम:

Msg 245, Level 16, State 1, Line 3
Conversion failed when converting the varchar value 'V' to data type int.

मूल्यांकन का आदेश

टी-एसक्यूएल CASE अभिव्यक्ति क्रमिक रूप से अपनी शर्तों का मूल्यांकन करती है और पहली शर्त के साथ रुकती है जिसकी स्थिति संतुष्ट होती है।

इसे प्रदर्शित करने के लिए, आइए कई WHEN . का उपयोग करें समान मान साझा करने वाले भाव:

DECLARE @stock_ticker varchar(4) = 'V';

SELECT Company =  
    CASE @stock_ticker  
        WHEN 'V' THEN 'Visa 1'
        WHEN 'V' THEN 'Visa 2'
        WHEN 'V' THEN 'Visa 3'
        ELSE 'Not in the portfolio'  
    END

परिणाम:

+-----------+
| Company   |
|-----------|
| Visa 1    |
+-----------+

इस मामले में, यह पहले WHEN . पर रुक गया अभिव्यक्ति।

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

इस कारण से, Microsoft सलाह देता है कि:

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

ELSE वैकल्पिक है

ELSE तर्क वैकल्पिक है। इसलिए, हम अपने "किफायती" उदाहरण को इस प्रकार फिर से लिख सकते हैं:

DECLARE @price int = 1500;

SELECT Affordability =  
    CASE   
        WHEN @price < 100 THEN 'Cheap'
        WHEN @price >= 100 AND @price < 500 THEN 'Affordable'
        WHEN @price >= 500 THEN 'Expensive'
    END    

परिणाम:

+-----------------+
| Affordability   |
|-----------------|
| Expensive       |
+-----------------+

हालांकि, ध्यान रखें कि आप NULL . के साथ समाप्त हो सकते हैं यदि आप ELSE . को छोड़ देते हैं बहस।

निम्न उदाहरण NULL में परिणत होता है :

DECLARE @price int = 1500;

SELECT Affordability =  
    CASE   
        WHEN @price < 100 THEN 'Cheap'
        WHEN @price >= 100 AND @price < 500 THEN 'Affordable'
        WHEN @price >= 500 AND @price < 1000 THEN 'Expensive'
    END    

परिणाम:

+-----------------+
| Affordability   |
|-----------------|
| NULL            |
+-----------------+

ऐसे मामलों में, हम हमेशा एक ELSE जोड़ सकते हैं तर्क, बस मामले में (सज़ा के लिए खेद है!):

DECLARE @price int = 1500;

SELECT Affordability =  
    CASE   
        WHEN @price < 100 THEN 'Cheap'
        WHEN @price >= 100 AND @price < 500 THEN 'Affordable'
        WHEN @price >= 500 AND @price < 1000 THEN 'Expensive'
        ELSE 'Unknown'
    END  

परिणाम:

+-----------------+
| Affordability   |
|-----------------|
| Unknown         |
+-----------------+

बेशक, यह उदाहरण शायद थोड़ा सा कल्पित है। आखिरकार, "महंगे" को सीमित करने की कोई आवश्यकता नहीं है। अगर कोई चीज़ $1000 से कम में महंगी है, तो वह $1000 से अधिक होने पर भी महंगी है।

लेकिन बात यह है कि आप ELSE . का उपयोग कर सकते हैं ऐसी किसी भी चीज़ को पकड़ने के लिए जो WHEN . के अंतर्गत नहीं आती है एक्सप्रेशन/एस.

नेस्टेड केस एक्सप्रेशन

आप CASE nest नेस्ट कर सकते हैं यदि आवश्यक हो तो भाव।

DECLARE @price int, @on_sale bit;
SET @price = 1500;
SET @on_sale = 1;

SELECT Affordability =  
    CASE   
        WHEN @price < 100 THEN 'Cheap'
        WHEN @price >= 100 THEN 
            CASE @on_sale
                WHEN 0 THEN 'Expensive (but it''s not currently on sale)' 
                WHEN 1 THEN 'Expensive (and it''s already on sale!)'
            END
    END

परिणाम:

+---------------------------------------+
| Affordability                         |
|---------------------------------------|
| Expensive (and it's already on sale!) |
+---------------------------------------+

हालांकि, यह ध्यान रखना महत्वपूर्ण है कि CASE . के लिए नेस्टिंग के केवल 10 स्तरों की अनुमति है SQL सर्वर में अभिव्यक्तियाँ। यदि आप 10 से अधिक स्तरों को नेस्ट करने का प्रयास करते हैं, तो आपको एक त्रुटि मिलेगी।

मामला एक आदेश द्वारा खंड में

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

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

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

SELECT Genre 
FROM MusicGenres
ORDER BY Genre ASC;

परिणाम:

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

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

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

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

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

परिणाम:

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

अद्यतन विवरण में मामला

यहां CASE . का उपयोग करने का एक उदाहरण दिया गया है एक UPDATE में अभिव्यक्ति बयान।

मान लीजिए हमारे पास निम्न तालिका है:

+---------+-----------+-----------+----------+
| DogId   | DogName   | GoodDog   | Dinner   |
|---------+-----------+-----------+----------|
| 1       | Fetch     | 1         | NULL     |
| 2       | Fluffy    | 0         | NULL     |
| 3       | Wag       | 0         | NULL     |
| 1001    | Brian     | 1         | NULL     |
| 1002    | Rambo     | 0         | NULL     |
| 1003    | BamBam    | 1         | NULL     |
+---------+-----------+-----------+----------+

हमने हाल ही में Dinner जोड़ा है कॉलम, और यह अभी भी NULL है , मान डालने की प्रतीक्षा कर रहा है।

लेकिन डाले जाने वाले मान GoodDog . के मान पर निर्भर करेंगे कॉलम।

हम एक CASE . का उपयोग कर सकते हैं ऐसे परिदृश्य में अभिव्यक्ति।

UPDATE Dogs 
SET Dinner = 
    CASE GoodDog
        WHEN 1 THEN 'Sunday Roast'
        ELSE 'Airline food'
    END

SELECT * FROM Dogs;

परिणाम:

+---------+-----------+-----------+--------------+
| DogId   | DogName   | GoodDog   | Dinner       |
|---------+-----------+-----------+--------------|
| 1       | Fetch     | 1         | Sunday Roast |
| 2       | Fluffy    | 0         | Airline food |
| 3       | Wag       | 0         | Airline food |
| 1001    | Brian     | 1         | Sunday Roast |
| 1002    | Rambo     | 0         | Airline food |
| 1003    | BamBam    | 1         | Sunday Roast |
+---------+-----------+-----------+--------------+

एक INSERT कथन में मामला

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

और हम फिर से CASE . का लाभ उठा सकते हैं Dinner . में उचित मान डालने के लिए एक्सप्रेशन कॉलम।

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
    );

SELECT * FROM Dogs;

परिणाम:

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

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

क्या यह केस स्टेटमेंट या केस एक्सप्रेशन है?

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

हालांकि इसे अक्सर CASE . के रूप में संदर्भित किया जाता है कथन, इसे CASE . कहना अधिक सटीक है अभिव्यक्ति . यह भी है कि Microsoft दस्तावेज़ीकरण इसे कैसे संदर्भित करता है।

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

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