SQL सर्वर में 'पिवट' का उपयोग करके पंक्तियों को कॉलम में बदलें


279

मैंने एमएस पिवट टेबल पर सामान पढ़ा है और मुझे अभी भी इसे सही करने में समस्या आ रही है।

मेरे पास एक अस्थायी तालिका है जो हम बना रहे हैं, हम कहेंगे कि कॉलम 1 एक स्टोर नंबर है, और कॉलम 2 एक सप्ताह की संख्या है और अंतिम कॉलम 3 किसी प्रकार का कुल है। इसके अलावा, सप्ताह संख्या गतिशील हैं, स्टोर संख्या स्थिर हैं।

Store      Week     xCount
-------    ----     ------
102        1        96
101        1        138
105        1        37
109        1        59
101        2        282
102        2        212
105        2        78
109        2        97
105        3        60
102        3        123
101        3        220
109        3        87

मैं इसे एक पिवट टेबल के रूप में बाहर आना चाहूंगा, जैसे:

Store        1          2          3        4        5        6....
----- 
101        138        282        220
102         96        212        123
105         37        
109

नीचे की ओर संख्या और सप्ताह भर में स्टोर करें।


जवाबों:


356

यदि आप SQL Server 2005+ का उपयोग कर रहे हैं, तो आप PIVOTफ़ंक्शन का उपयोग पंक्तियों से डेटा को कॉलम में बदलने के लिए कर सकते हैं।

ऐसा लगता है कि यदि सप्ताह अज्ञात हैं, तो आपको गतिशील sql का उपयोग करने की आवश्यकता होगी, लेकिन प्रारंभ में हार्ड-कोड संस्करण का उपयोग करके सही कोड को देखना आसान है।

सबसे पहले, यहां कुछ त्वरित तालिका परिभाषाएं और उपयोग के लिए डेटा हैं:

CREATE TABLE #yt 
(
  [Store] int, 
  [Week] int, 
  [xCount] int
);

INSERT INTO #yt
(
  [Store], 
  [Week], [xCount]
)
VALUES
    (102, 1, 96),
    (101, 1, 138),
    (105, 1, 37),
    (109, 1, 59),
    (101, 2, 282),
    (102, 2, 212),
    (105, 2, 78),
    (109, 2, 97),
    (105, 3, 60),
    (102, 3, 123),
    (101, 3, 220),
    (109, 3, 87);

यदि आपके मूल्य ज्ञात हैं, तो आप क्वेरी को हार्ड-कोड करेंगे:

select *
from 
(
  select store, week, xCount
  from yt
) src
pivot
(
  sum(xcount)
  for week in ([1], [2], [3])
) piv;

SQL डेमो देखें

फिर यदि आपको गतिशील रूप से सप्ताह संख्या उत्पन्न करने की आवश्यकता है, तो आपका कोड होगा:

DECLARE @cols AS NVARCHAR(MAX),
    @query  AS NVARCHAR(MAX)

select @cols = STUFF((SELECT ',' + QUOTENAME(Week) 
                    from yt
                    group by Week
                    order by Week
            FOR XML PATH(''), TYPE
            ).value('.', 'NVARCHAR(MAX)') 
        ,1,1,'')

set @query = 'SELECT store,' + @cols + ' from 
             (
                select store, week, xCount
                from yt
            ) x
            pivot 
            (
                sum(xCount)
                for week in (' + @cols + ')
            ) p '

execute(@query);

SQL डेमो देखें ।

डायनामिक संस्करण, weekउन संख्याओं की सूची तैयार करता है जिन्हें कॉलम में परिवर्तित किया जाना चाहिए। दोनों एक ही परिणाम देते हैं:

| STORE |   1 |   2 |   3 |
---------------------------
|   101 | 138 | 282 | 220 |
|   102 |  96 | 212 | 123 |
|   105 |  37 |  78 |  60 |
|   109 |  59 |  97 |  87 |

4
बहुत अच्छा! लेकिन जब कॉलम के सभी मान NULL हैं तो कॉलम को कैसे खत्म किया जाए?
ज़ूज़

1
@ZooZ नीचे उत्तर देखें । यह शब्दशः की कोशिश नहीं की है, लेकिन अवधारणा ध्वनि है।
रफिन

1
+1 "ऐसा लगता है कि यदि सप्ताह अज्ञात हैं, तो आपको गतिशील sql का उपयोग करने की आवश्यकता होगी, लेकिन प्रारंभ में हार्ड-कोडेड संस्करण का उपयोग करके सही कोड को देखना आसान है।" Qlikview जेनेरिक फ़ंक्शन ( समुदाय .qlik.com/blogs/qlikviewdesignblog/2014/03/31/generic ) के विपरीत, जो आपको यह अनुमति नहीं देता है कि आप स्पष्ट रूप से अलग-अलग "for ____ IN (...)
लाल मटर का नाम दें।

1
यदि आप पहले एक सीटी के साथ एक पिवट टेबल बना रहे हैं। cte3 AS (select ... )तब आपके पास तर्क के साथ परिभाषित ऊपर है @colsऔर @query... एक त्रुटि है। 'अमान्य ऑब्जेक्ट नाम' cte3'.` यह कैसे तय करते हैं। -
एलिजाबेथ

3
यह शानदार है - अच्छा एक @bluefeet। मैं STUFF(...)(या XML PATHतो) से पहले कभी नहीं किया था । अन्य पाठकों के लाभ के लिए, वह सब कर रहा है जो स्तंभ नामों में शामिल हो रहा है और अग्रणी अल्पविराम को काट रहा है। नोट मुझे लगता है कि निम्नलिखित थोड़ा सरल है: @cols = (SELECT DISTINCT QUOTENAME (सप्ताह) + 'का चयन करें,' yt के आदेश से 1 के लिए XML PATH ('')) @cols = SUBING (@cols, 1, LEN) सेट करें @ रंग) - 1) ... group byद्वारा प्रतिस्थापित distinctऔर order by 1और मैन्युअल रूप से एक प्रत्यय अल्पविराम काट !
डार्थपब्लो

26

यह गतिशील # सप्ताह के लिए है।

यहां पूरा उदाहरण: SQL डायनामिक पिवट

DECLARE @DynamicPivotQuery AS NVARCHAR(MAX)
DECLARE @ColumnName AS NVARCHAR(MAX)

--Get distinct values of the PIVOT Column 
SELECT @ColumnName= ISNULL(@ColumnName + ',','') + QUOTENAME(Week)
FROM (SELECT DISTINCT Week FROM #StoreSales) AS Weeks

--Prepare the PIVOT query using the dynamic 
SET @DynamicPivotQuery = 
  N'SELECT Store, ' + @ColumnName + ' 
    FROM #StoreSales
    PIVOT(SUM(xCount) 
          FOR Week IN (' + @ColumnName + ')) AS PVTTable'
--Execute the Dynamic Pivot Query
EXEC sp_executesql @DynamicPivotQuery

अरे मेरे पास एक फिडल है जहां मुझे गतिशील रूप से तालिकाओं को पिवट करने की आवश्यकता है क्या आपको लगता है कि आप मेरी मदद कर सकते हैं? dbfiddle.uk/…
वॉली

@SillyVolley यहां एक है, आपने निर्दिष्ट नहीं किया कि आप क्या धुरी बनाना चाहते हैं। इसके अलावा मुझे नहीं पता कि क्या आप पोस्टग्रेज में ऐसा कर सकते हैं तो मैंने इसे SQL सर्वर में किया: dbfiddle.uk/…
Enkode

16

मैंने सबक्वेरीज़ का उपयोग करने से पहले एक ही चीज़ हासिल की है। इसलिए यदि आपकी मूल तालिका को StoreCountsByWeek कहा जाता था, और आपके पास एक अलग तालिका थी जो स्टोर आईडी को सूचीबद्ध करती है, तो यह इस तरह दिखेगा:

SELECT StoreID, 
    Week1=(SELECT ISNULL(SUM(xCount),0) FROM StoreCountsByWeek WHERE StoreCountsByWeek.StoreID=Store.StoreID AND Week=1),
    Week2=(SELECT ISNULL(SUM(xCount),0) FROM StoreCountsByWeek WHERE StoreCountsByWeek.StoreID=Store.StoreID AND Week=2),
    Week3=(SELECT ISNULL(SUM(xCount),0) FROM StoreCountsByWeek WHERE StoreCountsByWeek.StoreID=Store.StoreID AND Week=3)
FROM Store
ORDER BY StoreID

इस पद्धति का एक फायदा यह है कि वाक्यविन्यास अधिक स्पष्ट है और इससे अन्य तालिकाओं में शामिल होने के लिए अन्य फ़ील्ड को परिणामों में भी खींचना आसान हो जाता है।

मेरे वास्तविक परिणाम यह हैं कि इस क्वेरी को एक हज़ार से भी कम समय में पूरी की गई कुछ हज़ार पंक्तियों में चलाया जा रहा है, और मेरे पास वास्तव में 7 उपश्रेणियाँ थीं। लेकिन जैसा कि टिप्पणियों में कहा गया है, यह इस तरह से करना अधिक कम्प्यूटेशनल रूप से महंगा है, इसलिए इस पद्धति का उपयोग करने के बारे में सावधान रहें यदि आप इसे बड़ी मात्रा में डेटा पर चलने की उम्मीद करते हैं।


8
यह आसान है, लेकिन यह एक बहुत महंगा ऑपरेशन है, उन उपश्रेणियों को तालिका से लौटी प्रत्येक पंक्ति के लिए एक बार निष्पादित किया जाना है।
ग्रेग


5

मैं एक ऐसा sp लिख रहा हूं जो इस उद्देश्य के लिए उपयोगी हो सकता है, मूल रूप से यह sp किसी भी तालिका को पिवट करता है और एक नया टेबल pivoted लौटाता है या सिर्फ डेटा के सेट को लौटाता है, यह इसे निष्पादित करने का तरीका है:

Exec dbo.rs_pivot_table @schema=dbo,@table=table_name,@column=column_to_pivot,@agg='sum([column_to_agg]),avg([another_column_to_agg]),',
        @sel_cols='column_to_select1,column_to_select2,column_to_select1',@new_table=returned_table_pivoted;

कृपया ध्यान दें कि पैरामीटर @ लैग में कॉलम नाम के साथ होना चाहिए '['और पैरामीटर कॉमा के साथ समाप्त होना चाहिए','

सपा

Create Procedure [dbo].[rs_pivot_table]
    @schema sysname=dbo,
    @table sysname,
    @column sysname,
    @agg nvarchar(max),
    @sel_cols varchar(max),
    @new_table sysname,
    @add_to_col_name sysname=null
As
--Exec dbo.rs_pivot_table dbo,##TEMPORAL1,tip_liq,'sum([val_liq]),sum([can_liq]),','cod_emp,cod_con,tip_liq',##TEMPORAL1PVT,'hola';
Begin

    Declare @query varchar(max)='';
    Declare @aggDet varchar(100);
    Declare @opp_agg varchar(5);
    Declare @col_agg varchar(100);
    Declare @pivot_col sysname;
    Declare @query_col_pvt varchar(max)='';
    Declare @full_query_pivot varchar(max)='';
    Declare @ind_tmpTbl int; --Indicador de tabla temporal 1=tabla temporal global 0=Tabla fisica

    Create Table #pvt_column(
        pivot_col varchar(100)
    );

    Declare @column_agg table(
        opp_agg varchar(5),
        col_agg varchar(100)
    );

    IF  EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(@table) AND type in (N'U'))
        Set @ind_tmpTbl=0;
    ELSE IF OBJECT_ID('tempdb..'+ltrim(rtrim(@table))) IS NOT NULL
        Set @ind_tmpTbl=1;

    IF  EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(@new_table) AND type in (N'U')) OR 
        OBJECT_ID('tempdb..'+ltrim(rtrim(@new_table))) IS NOT NULL
    Begin
        Set @query='DROP TABLE '+@new_table+'';
        Exec (@query);
    End;

    Select @query='Select distinct '+@column+' From '+(case when @ind_tmpTbl=1 then 'tempdb.' else '' end)+@schema+'.'+@table+' where '+@column+' is not null;';
    Print @query;

    Insert into #pvt_column(pivot_col)
    Exec (@query)

    While charindex(',',@agg,1)>0
    Begin
        Select @aggDet=Substring(@agg,1,charindex(',',@agg,1)-1);

        Insert Into @column_agg(opp_agg,col_agg)
        Values(substring(@aggDet,1,charindex('(',@aggDet,1)-1),ltrim(rtrim(replace(substring(@aggDet,charindex('[',@aggDet,1),charindex(']',@aggDet,1)-4),')',''))));

        Set @agg=Substring(@agg,charindex(',',@agg,1)+1,len(@agg))

    End

    Declare cur_agg cursor read_only forward_only local static for
    Select 
        opp_agg,col_agg
    from @column_agg;

    Open cur_agg;

    Fetch Next From cur_agg
    Into @opp_agg,@col_agg;

    While @@fetch_status=0
    Begin

        Declare cur_col cursor read_only forward_only local static for
        Select 
            pivot_col 
        From #pvt_column;

        Open cur_col;

        Fetch Next From cur_col
        Into @pivot_col;

        While @@fetch_status=0
        Begin

            Select @query_col_pvt='isnull('+@opp_agg+'(case when '+@column+'='+quotename(@pivot_col,char(39))+' then '+@col_agg+
            ' else null end),0) as ['+lower(Replace(Replace(@opp_agg+'_'+convert(varchar(100),@pivot_col)+'_'+replace(replace(@col_agg,'[',''),']',''),' ',''),'&',''))+
                (case when @add_to_col_name is null then space(0) else '_'+isnull(ltrim(rtrim(@add_to_col_name)),'') end)+']'
            print @query_col_pvt
            Select @full_query_pivot=@full_query_pivot+@query_col_pvt+', '

            --print @full_query_pivot

            Fetch Next From cur_col
            Into @pivot_col;        

        End     

        Close cur_col;
        Deallocate cur_col;

        Fetch Next From cur_agg
        Into @opp_agg,@col_agg; 
    End

    Close cur_agg;
    Deallocate cur_agg;

    Select @full_query_pivot=substring(@full_query_pivot,1,len(@full_query_pivot)-1);

    Select @query='Select '+@sel_cols+','+@full_query_pivot+' into '+@new_table+' From '+(case when @ind_tmpTbl=1 then 'tempdb.' else '' end)+
    @schema+'.'+@table+' Group by '+@sel_cols+';';

    print @query;
    Exec (@query);

End;
GO

यह निष्पादन का एक उदाहरण है:

Exec dbo.rs_pivot_table @schema=dbo,@table=##TEMPORAL1,@column=tip_liq,@agg='sum([val_liq]),avg([can_liq]),',@sel_cols='cod_emp,cod_con,tip_liq',@new_table=##TEMPORAL1PVT;

फिर Select * From ##TEMPORAL1PVTलौटेंगे:

यहां छवि विवरण दर्ज करें



2

यहां ऊपर दिए गए @Tayrn उत्तर का एक संशोधन है जो आपको थोड़ा आसान समझने में मदद कर सकता है:

यह ऐसा करने का सबसे अच्छा तरीका नहीं हो सकता है, लेकिन यह वही है जिसने मुझे अपना सिर चारों ओर से लपेटने में मदद की है कि कैसे तालिकाओं को पिवट किया जाए।

ID = पंक्तियाँ जो आप पिवट करना चाहते हैं

MY_KEY = वह कॉलम जिसे आप अपनी मूल तालिका से चुन रहे हैं जिसमें वह कॉलम नाम शामिल हैं जिन्हें आप पिवट करना चाहते हैं।

वैल = वह मान जो आप प्रत्येक कॉलम के तहत वापस चाहते हैं।

MAX (VAL) => को अन्य समुच्चय कार्यों से बदला जा सकता है। SUM (VAL), MIN (VAL), ETC ...

DECLARE @cols AS NVARCHAR(MAX),
@query  AS NVARCHAR(MAX)
select @cols = STUFF((SELECT ',' + QUOTENAME(MY_KEY) 
                from yt
                group by MY_KEY
                order by MY_KEY ASC
        FOR XML PATH(''), TYPE
        ).value('.', 'NVARCHAR(MAX)') 
    ,1,1,'')
set @query = 'SELECT ID,' + @cols + ' from 
         (
            select ID, MY_KEY, VAL 
            from yt
        ) x
        pivot 
        (
            sum(VAL)
            for MY_KEY in (' + @cols + ')
        ) p '

        execute(@query);

2

बस आपको कुछ विचार दें कि कैसे अन्य डेटाबेस इस समस्या को हल करते हैं। DolphinDBधुरी के लिए अंतर्निहित समर्थन भी है और एसक्यूएल बहुत अधिक सहज और साफ दिखता है। यह कुंजी कॉलम ( Store), पिविंग कॉलम ( Week), और परिकलित मीट्रिक ( sum(xCount)) निर्दिष्ट करने जैसा ही सरल है ।

//prepare a 10-million-row table
n=10000000
t=table(rand(100, n) + 1 as Store, rand(54, n) + 1 as Week, rand(100, n) + 1 as xCount)

//use pivot clause to generate a pivoted table pivot_t
pivot_t = select sum(xCount) from t pivot by Store, Week

DolphinDB एक स्तंभ उच्च प्रदर्शन डेटाबेस है। डेमो में गणना एक dell xps लैपटॉप (i7 cpu) पर कम से कम 546 ms है। अधिक विवरण प्राप्त करने के लिए, कृपया ऑनलाइन डॉल्फिनबीडी नियमावली https://www.dolphindb.com/help/index.html??ivotn.html.html देखें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.