खोज…


सिंपल ग्रुपिंग

आदेश तालिका

ग्राहक आईडी, ग्राहक पहचान उत्पाद आइ डि मात्रा कीमत
1 2 5 100
1 3 2 200
1 4 1 500
2 1 4 50
3 5 6 700

जब एक विशिष्ट स्तंभ द्वारा समूहीकरण किया जाता है, तो इस स्तंभ के केवल अनन्य मान वापस किए जाते हैं।

SELECT customerId
FROM orders
GROUP BY customerId;

प्रतिलाभ की मात्रा:

ग्राहक आईडी, ग्राहक पहचान
1
2
3

count() जैसे पूरे कार्य count() प्रत्येक समूह पर लागू होते हैं और पूरी तालिका में नहीं होते हैं:

SELECT customerId, 
       COUNT(productId) as numberOfProducts,
       sum(price) as totalPrice
FROM orders
GROUP BY customerId;

प्रतिलाभ की मात्रा:

ग्राहक आईडी, ग्राहक पहचान numberOfProducts कुल कीमत
1 3 800
2 1 50
3 1 700

कई स्तंभों द्वारा ग्रुप

कोई एक से अधिक कॉलम के लिए ग्रुप बाय करना चाहता है

declare @temp table(age int, name varchar(15))

insert into @temp
select 18, 'matt' union all
select 21, 'matt' union all
select 21, 'matt' union all
select 18, 'luke' union all
select 18, 'luke' union all
select 21, 'luke' union all
select 18, 'luke' union all
select 21, 'luke'

SELECT Age, Name, count(1) count
FROM @temp 
GROUP BY Age, Name

आयु और नाम दोनों का समूह करेगा और उत्पादन करेगा:

आयु नाम गिनती
18 ल्यूक 3
21 ल्यूक 2
18 मैट 1
21 मैट 2

एकाधिक तालिकाओं, कई स्तंभों के साथ समूह

समूह द्वारा अक्सर शामिल बयान के साथ प्रयोग किया जाता है। मान लेते हैं कि हमारे पास दो टेबल हैं। पहला छात्र छात्रों की तालिका है:

ईद पूरा नाम आयु
1 मैट जोन्स 20
2 फ्रैंक ब्लू 21
3 एंथोनी एंजेल 18

दूसरी तालिका उस विषय की तालिका है जिसे प्रत्येक छात्र ले सकता है:

Subject_Id विषय
1 गणित
2 पी.ई
3 भौतिक विज्ञान

और क्योंकि एक छात्र कई विषयों में भाग ले सकता है और एक विषय कई छात्रों द्वारा भाग लिया जा सकता है (इसलिए एन: एन संबंध) हमें तीसरा "बाउंडिंग" टेबल चाहिए। चलिए टेबल को छात्र_सुबिज कहते हैं:

Subject_Id छात्र आईडी
1 1
2 2
2 1
3 2
1 3
1 1

अब हम कहते हैं कि हम जानना चाहते हैं कि प्रत्येक छात्र कितने विषयों में भाग ले रहा है। यहां स्टैंडअलोन GROUP BY स्टेटमेंट पर्याप्त नहीं है क्योंकि जानकारी सिंगल टेबल के माध्यम से उपलब्ध नहीं है। इसलिए हमें JOIN स्टेटमेंट के साथ GROUP BY का उपयोग करने की आवश्यकता है:

Select Students.FullName, COUNT(Subject Id) as SubjectNumber FROM Students_Subjects
LEFT JOIN Students
ON Students_Subjects.Student_id = Students.Id
GROUP BY Students.FullName

दिए गए प्रश्न का परिणाम इस प्रकार है:

पूरा नाम SubjectNumber
मैट जोन्स 3
फ्रैंक ब्लू 2
एंथोनी एंजेल 1

ग्रुप बाय यूज़ के और भी जटिल उदाहरण के लिए, मान लें कि छात्र एक ही विषय को एक से अधिक बार असाइन कर सकता है (जैसा कि तालिका Students_Subjects में दिखाया गया है)। इस परिदृश्य में हम एक छात्र को एक से अधिक स्तंभों द्वारा समूहीकृत करके प्रत्येक विषय को कितनी बार गिना जा सकता है:

SELECT Students.FullName, Subjects.Subject,
COUNT(Students_subjects.Subject_id) AS NumberOfOrders
FROM ((Students_Subjects
INNER JOIN Students
ON Students_Subjcets.Student_id=Students.Id)
INNER JOIN Subjects
ON Students_Subjects.Subject_id=Subjects.Subject_id)
GROUP BY Fullname,Subject

यह प्रश्न निम्नलिखित परिणाम देता है:

पूरा नाम विषय SubjectNumber
मैट जोन्स गणित 2
मैट जोन्स पी.ई 1
फ्रैंक ब्लू पी.ई 1
फ्रैंक ब्लू भौतिक विज्ञान 1
एंथोनी एंजेल गणित 1

होने

क्योंकि GROUP BY पहले WHERE क्लॉज का मूल्यांकन किया जाता है, आप ग्रुपिंग के परिणामों (आमतौर पर एक समुच्चय समारोह, जैसे COUNT(*) ) को रोकने के लिए WHERE का उपयोग नहीं कर सकते। इस जरूरत को पूरा करने के लिए HAVING क्लॉज का उपयोग किया जा सकता है।

उदाहरण के लिए, निम्नलिखित डेटा का उपयोग करना:

DECLARE @orders TABLE(OrderID INT, Name NVARCHAR(100))

INSERT INTO @orders VALUES
( 1, 'Matt' ),
( 2, 'John' ),
( 3, 'Matt' ),
( 4, 'Luke' ),
( 5, 'John' ),
( 6, 'Luke' ),
( 7, 'John' ),
( 8, 'John' ),
( 9, 'Luke' ),
( 10, 'John' ),
( 11, 'Luke' )

यदि हम चाहते हैं कि प्रत्येक व्यक्ति ने जितने आदेश दिए हैं, हम उनका उपयोग करें

SELECT Name, COUNT(*) AS 'Orders'
FROM @orders
GROUP BY Name

और पाओ

नाम आदेश
मैट 2
जॉन 5
ल्यूक 4

हालाँकि, यदि हम इसे उन व्यक्तियों तक सीमित करना चाहते हैं, जिन्होंने दो से अधिक ऑर्डर रखे हैं, तो हम एक HAVING क्लॉज जोड़ सकते हैं।

SELECT Name, COUNT(*) AS 'Orders'
FROM @orders
GROUP BY Name
HAVING COUNT(*) > 2

निकलेगा

नाम आदेश
जॉन 5
ल्यूक 4

ध्यान दें कि, जैसे कि GROUP BY , HAVING में डाले गए कॉलम का SELECT स्टेटमेंट में अपने समकक्षों से बिल्कुल मेल खाना चाहिए। यदि उपरोक्त उदाहरण में हमने इसके बजाय कहा था

SELECT Name, COUNT(DISTINCT OrderID)

हमारे HAVING क्लॉज कहना होगा

HAVING COUNT(DISTINCT OrderID) > 2

रोलअप और सीयूबी के साथ ग्रुप बाय

ROLLUP ऑपरेटर उन रिपोर्टों को उत्पन्न करने में उपयोगी है जिनमें सबटोटल और योग हैं।

  • CUBE एक परिणाम सेट उत्पन्न करता है जो चयनित कॉलम में मूल्यों के सभी संयोजनों के लिए समुच्चय दर्शाता है।

  • रोलअप एक परिणाम सेट बनाता है जो चयनित स्तंभों में मानों के पदानुक्रम के लिए समुच्चय दिखाता है।

    मद रंग मात्रा
    तालिका नीला 124
    तालिका लाल 223
    कुरसी नीला 101
    कुरसी लाल 210
SELECT CASE WHEN (GROUPING(Item) = 1) THEN 'ALL'
            ELSE ISNULL(Item, 'UNKNOWN')
       END AS Item,
       CASE WHEN (GROUPING(Color) = 1) THEN 'ALL'
            ELSE ISNULL(Color, 'UNKNOWN')
       END AS Color,
       SUM(Quantity) AS QtySum
FROM Inventory
GROUP BY Item, Color WITH ROLLUP

Item                 Color                QtySum                     
-------------------- -------------------- -------------------------- 
Chair                Blue                 101.00                     
Chair                Red                  210.00                     
Chair                ALL                  311.00                     
Table                Blue                 124.00                     
Table                Red                  223.00                     
Table                ALL                  347.00                     
ALL                  ALL                  658.00 

(7 पंक्ति) प्रभावित

यदि क्वेरी में ROLLUP कीवर्ड को CUBE में बदल दिया जाता है, तो CUBE परिणाम सेट समान होता है, सिवाय इन दो अतिरिक्त पंक्तियों के अंत में वापस आ जाते हैं:

ALL                  Blue                 225.00                     
ALL                  Red                  433.00 

https://technet.microsoft.com/en-us/library/ms189305(v=sql.90).aspx



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow