Sqlserver
 sql >> डेटाबेस >  >> RDS >> Sqlserver

SQL सर्वर में संग्रहीत प्रक्रिया द्वारा लौटाए गए कॉलम को फिर से परिभाषित कैसे करें

जब आप एक संग्रहीत कार्यविधि निष्पादित करते हैं जो SQL सर्वर में एक परिणाम सेट देता है, तो लौटाए गए कॉलम संग्रहीत कार्यविधि में परिभाषित होते हैं।

लेकिन क्या आप जानते हैं कि आप उन स्तंभों को फिर से परिभाषित कर सकते हैं?

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

यह आपको उस स्थिति में कॉलम हेडर और डेटा प्रारूपों के साथ खिलवाड़ करने से बचा सकता है, जब आपको उस परिणाम का उपयोग किसी अन्य सेटिंग में करने की आवश्यकता होती है।

उदाहरण के लिए, यदि कोई संग्रहीत कार्यविधि datetime2 . लौटाती है कॉलम, लेकिन आपको केवल दिनांक भाग की आवश्यकता है, आप तारीख specify निर्दिष्ट कर सकते हैं उस कॉलम के लिए, और आपके परिणाम सेट में केवल दिनांक भाग शामिल होगा।

और सबसे अच्छी बात यह है कि आप इसे EXECUTE . के हिस्से के रूप में कर सकते हैं बयान। प्रक्रिया को निष्पादित करने के बाद डेटा की मालिश करने की आवश्यकता नहीं है। ऐसा करने का तरीका WITH RESULT SETS . का उपयोग करना है EXECUTE . का खंड बयान।

उदाहरण

WITH RESULT SETS का उपयोग कैसे करें, यह प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है संग्रहीत प्रक्रिया के परिणाम सेट से कॉलम नाम और डेटा प्रकार बदलने के लिए क्लॉज।

कच्चे परिणाम

सबसे पहले, आइए एक संग्रहीत प्रक्रिया से कच्चे परिणामों को देखें।

EXEC sp_getCityById @CityId = 1;

परिणाम:

+------------+----------------------------+-----------------------------+
| CityName   | LatestRecordedPopulation   | ValidFrom                   |
|------------+----------------------------+-----------------------------|
| Aaronsburg | 613                        | 2013-01-01 00:00:00.0000000 |
+------------+----------------------------+-----------------------------+

हमारी आवश्यकताओं के आधार पर, हम चाहते हैं कि प्रक्रिया जनसंख्या के लिए इतने लंबे कॉलम हेडर का उपयोग न करे (LatestRecordedPopulation )।

हम यह भी चाहते हैं कि ValidFrom कॉलम में समय भाग शामिल नहीं था, क्योंकि यह अनावश्यक स्थान लेता है, और यह हमारे विशेष उद्देश्य के लिए महत्वपूर्ण नहीं है।

हम कॉलम हेडर को एक स्थान के साथ प्रस्तुत करना चाह सकते हैं, बस इसे थोड़ा और अधिक प्रस्तुत करने योग्य बनाने के लिए जिसे हम इसे भेज रहे हैं।

कॉलम फिर से परिभाषित करें

अब आगे बढ़ते हैं और WITH RESULT SETS का उपयोग करते हैं कॉलम को फिर से परिभाषित करने के लिए क्लॉज।

EXEC sp_getCityById @CityId = 1
WITH RESULT SETS   
(  
    (
        [City] nvarchar(50),
        [Population] int,
        [Valid From] date
    )
);

परिणाम:

+------------+--------------+--------------+
| City       | Population   | Valid From   |
|------------+--------------+--------------|
| Aaronsburg | 613          | 2013-01-01   |
+------------+--------------+--------------+

तो WITH RESULT SETS . का उपयोग करके खंड, हम कॉलम के नाम और डेटा प्रकार को बदलने में सक्षम थे।

दरअसल, इस उदाहरण में मैंने पिछले दो कॉलम के डेटा प्रकार को bigint . से बदल दिया है से int . तक , और datetime2(7) . से से तारीख . तक , क्रमशः।

परिणाम सेट का विश्लेषण करें

हम गतिशील प्रबंधन दृश्यों का उपयोग कर सकते हैं जैसे sys.dm_exec_describe_first_result_set और sys.dm_exec_describe_first_result_set_for_object प्रत्येक परिणाम सेट के वास्तविक डेटा प्रकारों का पता लगाने के लिए।

यहां sys.dm_exec_describe_first_result_set_for_object का उपयोग करने का एक उदाहरण दिया गया है संग्रहीत प्रक्रिया द्वारा कॉलम नाम और उनके संबंधित डेटा प्रकार लौटाए जाने के लिए।

SELECT 
    name,
    system_type_name,
    max_length,
    [precision],
    scale,
    user_type_name
FROM sys.dm_exec_describe_first_result_set_for_object(OBJECT_ID('sp_getCityById'), 0);

परिणाम:

+--------------------------+--------------------+--------------+-------------+---------+------------------+
| name                     | system_type_name   | max_length   | precision   | scale   | user_type_name   |
|--------------------------+--------------------+--------------+-------------+---------+------------------|
| CityName                 | nvarchar(50)       | 100          | 0           | 0       | NULL             |
| LatestRecordedPopulation | bigint             | 8            | 19          | 0       | NULL             |
| ValidFrom                | datetime2(7)       | 8            | 27          | 7       | NULL             |
+--------------------------+--------------------+--------------+-------------+---------+------------------+

तो ये वास्तविक कॉलम नाम और डेटा प्रकार परिणाम सेट में लौटाए गए हैं (बिना कुछ फिर से परिभाषित किए)।

हम देख सकते हैं कि अंतिम दो कॉलम बड़ा हैं और डेटाटाइम2(7) क्रमशः।

आइए अब sys.dm_exec_describe_first_result_set का उपयोग करें हमारी संशोधित क्वेरी के लिए मेटाडेटा प्राप्त करने के लिए।

SELECT 
    name,
    system_type_name,
    max_length,
    [precision],
    scale,
    user_type_name
FROM sys.dm_exec_describe_first_result_set(
    'EXEC sp_getCityById @CityId = 1
        WITH RESULT SETS   
        (  
            (
                [City] nvarchar(50),
                [Population] int,
                [Valid To] date
            )
        );', 
        null, 
        0
    );

परिणाम:

+------------+--------------------+--------------+-------------+---------+------------------+
| name       | system_type_name   | max_length   | precision   | scale   | user_type_name   |
|------------+--------------------+--------------+-------------+---------+------------------|
| City       | nvarchar(50)       | 100          | 0           | 0       | NULL             |
| Population | int                | 4            | 10          | 0       | NULL             |
| Valid To   | date               | 3            | 10          | 0       | NULL             |
+------------+--------------------+--------------+-------------+---------+------------------+

इसलिए हम देख सकते हैं कि कॉलम के नाम बदल गए हैं, और अंतिम दो कॉलम के डेटा प्रकार भी निर्दिष्ट के अनुसार बदल गए हैं।

एकाधिक परिणाम सेट

कुछ संग्रहीत कार्यविधियाँ कई परिणाम सेट लौटाती हैं। WITH RESULT SETS का उपयोग करते समय इन प्रक्रियाओं पर, आपको यह सुनिश्चित करना होगा कि आप प्रत्येक परिणाम सेट के लिए परिभाषाएं शामिल करें।

आप न केवल कुछ को फिर से परिभाषित कर सकते हैं बल्कि दूसरों को नहीं। यदि आप ऐसा करते हैं, तो आपको एक त्रुटि मिलेगी।

यदि आपको केवल एक परिणाम सेट को फिर से परिभाषित करने की आवश्यकता है, तो आपको उन सभी को करने की आवश्यकता है - भले ही उनकी परिभाषा उनकी मूल परिभाषा के समान ही रहे।

ऐसा करते समय, प्रत्येक परिभाषा को अल्पविराम से अलग करें।

मूल परिणाम सेट

निम्नलिखित प्रक्रिया तीन परिणाम सेट लौटाती है।

EXEC sp_getCityStateCountryByCityId @CityId = 1;

परिणाम:

+------------+----------------------------+-----------------------------+
| CityName   | LatestRecordedPopulation   | ValidFrom                   |
|------------+----------------------------+-----------------------------|
| Aaronsburg | 613                        | 2013-01-01 00:00:00.0000000 |
+------------+----------------------------+-----------------------------+
(1 row affected)
+---------------------+---------------------+----------------------------+
| StateProvinceCode   | StateProvinceName   | LatestRecordedPopulation   |
|---------------------+---------------------+----------------------------|
| PA                  | Pennsylvania        | 13284753                   |
+---------------------+---------------------+----------------------------+
(1 row affected)
+-----------------+---------------+----------------------------+
| IsoAlpha3Code   | CountryName   | LatestRecordedPopulation   |
|-----------------+---------------+----------------------------|
| USA             | United States | 313973000                  |
+-----------------+---------------+----------------------------+
(1 row affected)

परिणामों को फिर से परिभाषित करें

हम इन परिणाम सेटों को निम्नलिखित कोड से फिर से परिभाषित कर सकते हैं।

EXEC sp_getCityStateCountryByCityId @CityId = 1
WITH RESULT SETS   
(  
    (
        [City] nvarchar(50),
        [Population] int,
        [Valid From] date
    ),
    (
        [State Code] nvarchar(5),
        [State Name] nvarchar(50),
        [Population] int
    ),
    (
        [Country Code] nvarchar(3),
        [Country Name] nvarchar(60),
        [Population] int
    )
);

परिणाम:

+------------+--------------+--------------+
| City       | Population   | Valid From   |
|------------+--------------+--------------|
| Aaronsburg | 613          | 2013-01-01   |
+------------+--------------+--------------+
(1 row affected)
+--------------+--------------+--------------+
| State Code   | State Name   | Population   |
|--------------+--------------+--------------|
| PA           | Pennsylvania | 13284753     |
+--------------+--------------+--------------+
(1 row affected)
+----------------+----------------+--------------+
| Country Code   | Country Name   | Population   |
|----------------+----------------+--------------|
| USA            | United States  | 313973000    |
+----------------+----------------+--------------+
(1 row affected)

संग्रहीत प्रक्रिया द्वारा लौटाए गए स्तंभों की संख्या कम करना

जब मुझे पहली बार WITH RESULT SETS के बारे में पता चला खंड, मैं उत्साहित था, क्योंकि मुझे लगा कि यह संग्रहीत प्रक्रिया द्वारा लौटाए गए स्तंभों की संख्या को कम करने का एक आसान तरीका प्रदान करेगा।

अफसोस की बात है कि ऐसा नहीं है।

यदि आप अपने WITH RESULT SETS में संग्रहीत प्रक्रिया द्वारा लौटाए गए सभी कॉलम शामिल नहीं करते हैं खंड, आपको एक त्रुटि मिलेगी।

वैसे, सबकुछ नष्ट नहीं हुआ है। यदि आप प्रक्रिया रिटर्न से कम कॉलम चाहते हैं तो संग्रहीत प्रक्रिया से कॉलम के सबसेट का चयन कैसे करें देखें।


  1. Database
  2.   
  3. Mysql
  4.   
  5. Oracle
  6.   
  7. Sqlserver
  8.   
  9. PostgreSQL
  10.   
  11. Access
  12.   
  13. SQLite
  14.   
  15. MariaDB
  1. SQL सर्वर प्रदर्शन टॉप CPU क्वेरी -2

  2. SQL सर्वर 2017 में ट्रिगर इवेंट प्रकारों की श्रेणीबद्ध सूची

  3. SQL सर्वर (T-SQL) में msdb डेटाबेस से डेटाबेस मेल संदेश हटाएं

  4. कैसे ठीक करें "INSERT कथन के लिए चयन सूची में सम्मिलित सूची से कम आइटम हैं"

  5. SQL सर्वर 2014 CTP1 में निम्न प्राथमिकता लॉक प्रतीक्षा विकल्पों की खोज करना