SQL
समूह द्वारा

परिचय

वाक्य - विन्यास

• समूह द्वारा {
  स्तंभ अभिव्यक्ति
  | रोलअप (<group_by_expression> [, ... n])
  | CUBE (<group_by_expression> [, ... n])
  | समूह बनाना ([, ... n])
  | () - भव्य कुल को दर्शाता है
  } [, ... एन]

• <group_by_expression> :: =
  स्तंभ अभिव्यक्ति
  | (कॉलम-एक्सप्रेशन [, ... n])

• <समूहीकरण_सेट> :: =
  () - भव्य कुल को दर्शाता है
  | <Grouping_set_item>
  | (<grouping_set_item> [, ... n])

• <Grouping_set_item> :: =
  <Group_by_expression>
  | रोलअप (<group_by_expression> [, ... n])
  | CUBE (<group_by_expression> [, ... n])

किसी दिए गए कॉलम में प्रत्येक अद्वितीय प्रविष्टि के लिए पंक्तियों की संख्या को गिनने के लिए उपयोग करें

मान लें कि आप किसी कॉलम में दिए गए मान के लिए गणना या उप-योग उत्पन्न करना चाहते हैं।

इस तालिका को देखते हुए, "वेस्टरोसियन":

ग्रुप बाय के बिना, COUNT बस कुल पंक्तियों को लौटाएगी:

SELECT Count(*) Number_of_Westerosians
FROM Westerosians

रिटर्न ...

लेकिन ग्रुप BY को जोड़कर, हम उपयोगकर्ताओं को दिए गए कॉलम में प्रत्येक मूल्य के लिए, किसी दिए गए ग्रेट हाउस में लोगों की संख्या वापस करने के लिए, कह सकते हैं:

SELECT GreatHouseAllegience House, Count(*) Number_of_Westerosians
FROM Westerosians
GROUP BY GreatHouseAllegience

रिटर्न ...

सबसे बड़ी या छोटी श्रेणी के अनुसार परिणामों को क्रमबद्ध करने के लिए ORDER BY के साथ ग्रुप को जोड़ना आम बात है:

SELECT GreatHouseAllegience House, Count(*) Number_of_Westerosians
FROM Westerosians
GROUP BY GreatHouseAllegience
ORDER BY Number_of_Westerosians Desc

रिटर्न ...

फ़िल्टर ग्रुप BY एक हाइविंग क्लॉज का उपयोग करके परिणाम

HAVING क्लॉज, GROUP BY अभिव्यक्ति के परिणामों को फ़िल्टर करता है। नोट: निम्नलिखित उदाहरण लाइब्रेरी उदाहरण डेटाबेस का उपयोग कर रहे हैं।

उदाहरण:

सभी लेखकों को लौटाएं जिन्होंने एक से अधिक पुस्तक ( लाइव उदाहरण ) लिखी हैं।

SELECT
  a.Id,
  a.Name,
  COUNT(*) BooksWritten
FROM BooksAuthors ba
  INNER JOIN Authors a ON a.id = ba.authorid
GROUP BY
  a.Id,
  a.Name
HAVING COUNT(*) > 1    -- equals to HAVING BooksWritten > 1
;

उन सभी पुस्तकों को लौटाएं जिनमें तीन से अधिक लेखक हैं ( जीवंत उदाहरण )।

SELECT
  b.Id,
  b.Title,
  COUNT(*) NumberOfAuthors
FROM BooksAuthors ba
  INNER JOIN Books b ON b.id = ba.bookid
GROUP BY
  b.Id,
  b.Title
HAVING COUNT(*) > 3    -- equals to HAVING NumberOfAuthors > 3
;

मूल समूह उदाहरण के लिए

यदि आप स्पष्टीकरण के लिए "प्रत्येक के लिए" के रूप में ग्रुप बीई के बारे में सोचते हैं तो यह आसान हो सकता है। नीचे क्वेरी:

SELECT EmpID, SUM (MonthlySalary) 
FROM Employee
GROUP BY EmpID

कहना:

"मुझे प्रत्येक कर्मचारी के लिए मासिक वेतन का योग दें"

तो अगर आपकी तालिका इस तरह दिखती है:

+-----+-------------+
|EmpID|MonthlySalary|
+-----+-------------+
|1    |200          |
+-----+-------------+
|2    |300          |
+-----+-------------+

परिणाम:

+-+---+
|1|200|
+-+---+
|2|300|
+-+---+

कुछ भी करने के लिए योग दिखाई नहीं देगा क्योंकि एक नंबर का योग वह संख्या है। दूसरी ओर अगर यह इस तरह दिखता है:

+-----+-------------+
|EmpID|MonthlySalary|
+-----+-------------+
|1    |200          |
+-----+-------------+
|1    |300          |
+-----+-------------+
|2    |300          |
+-----+-------------+

परिणाम:

+-+---+
|1|500|
+-+---+
|2|300|
+-+---+

तब यह होता है क्योंकि एक साथ योग करने के लिए दो EmpID 1 हैं।

रोल एकत्रीकरण (डेटा खनन)

विवरण

SQL मानक दो अतिरिक्त कुल ऑपरेटर प्रदान करता है। ये सभी मानों के सेट को निरूपित करने के लिए पॉलीमॉर्फिक मान "ALL" का उपयोग करते हैं जो एक विशेषता ले सकता है। दो ऑपरेटर हैं:

• with data cube कि यह क्लॉज के तर्क विशेषताओं की तुलना में सभी संभव संयोजन प्रदान करता है।
• with roll up कि यह क्लाज के तर्क में सूचीबद्ध होने की तुलना में बाएं से दाएं की विशेषताओं पर विचार करके प्राप्त किए गए समुच्चय प्रदान करता है।

SQL मानक संस्करण जो इन सुविधाओं का समर्थन करते हैं: 1999,2003,2006,2008,2011।

उदाहरण

इस तालिका पर विचार करें:

घन के साथ

select Food,Brand,Total_amount
from Table
group by Food,Brand,Total_amount with cube

रोल के साथ

select Food,Brand,Total_amount
from Table
group by Food,Brand,Total_amount with roll up