Lahat ng Kailangan Mong Malaman Tungkol sa SQL GROUP NG Pahayag

Karamihan sa lakas ng mga magkakaugnay na mga database ay nagmula sa pag-filter ng data at pagsasama-sama ng mga talahanayan. Ito ang dahilan kung bakit kinakatawan namin ang mga relasyon na iyon sa una. Ngunit ang mga modernong sistema ng database ay nagbibigay ng isa pang mahalagang pamamaraan: pagpapangkat.

Pinapayagan ka ng pagpapangkat na kumuha ng impormasyon ng buod mula sa isang database. Hinahayaan ka nitong pagsamahin ang mga resulta upang lumikha ng kapaki-pakinabang na data ng istatistika. Sine-save ka ng pagpapangkat mula sa pagsulat ng code para sa mga karaniwang kaso tulad ng pag-average ng mga listahan ng mga numero. At maaari itong gumawa para sa mas mahusay na mga system.

Ano ang Ginagawa ng GROUP BY Clause?

GROUP BY, tulad ng iminumungkahi ng pangalan, ang mga pangkat ay nagreresulta sa isang mas maliit na hanay. Ang mga resulta ay binubuo ng isang hilera para sa bawat natatanging halaga ng pinangkat na haligi. Maaari naming ipakita ang paggamit nito sa pamamagitan ng pagtingin sa ilang sample na data na may mga hilera na nagbabahagi ng ilang mga karaniwang halaga.

Ang amazon prime video ay nanalo sa paglalaro

Ang sumusunod ay isang napaka-simpleng database na may dalawang talahanayan na kumakatawan sa mga record album. Maaari mong i-set up ang tulad ng isang database sa pamamagitan ng pagsulat ng isang pangunahing iskema para sa iyong napiling sistema ng database. Ang mga album ang talahanayan ay may siyam na hilera na may pangunahing susi id haligi at mga haligi para sa pangalan, artist, taon ng paglabas, at mga benta:

+----+---------------------------+-----------+--------------+-------+  
| id | name | artist_id | release_year | sales |  
+----+---------------------------+-----------+--------------+-------+  
| 1 | Abbey Road | 1 | 1969 | 14 |  
| 2 | The Dark Side of the Moon | 2 | 1973 | 24 |  
| 3 | Rumours | 3 | 1977 | 28 |  
| 4 | Nevermind | 4 | 1991 | 17 |  
| 5 | Animals | 2 | 1977 | 6 |  
| 6 | Goodbye Yellow Brick Road | 5 | 1973 | 8 |  
| 7 | 21 | 6 | 2011 | 25 |  
| 8 | 25 | 6 | 2015 | 22 |  
| 9 | Bat Out of Hell | 7 | 1977 | 28 |  
+----+---------------------------+-----------+--------------+-------+

Ang mga artista mas simple pa ang mesa. Mayroon itong pitong mga hilera na may mga id at mga haligi ng pangalan:

+----+---------------+  
| id | name |  
+----+---------------+  
| 1 | The Beatles |  
| 2 | Pink Floyd |  
| 3 | Fleetwood Mac |  
| 4 | Nirvana |  
| 5 | Elton John |  
| 6 | Adele |  
| 7 | Meat Loaf |  
+----+---------------+

Maaari mong maunawaan ang iba't ibang mga aspeto ng GROUP BY sa pamamagitan lamang ng isang simpleng hanay ng data tulad nito. Siyempre, ang isang hanay ng data na totoong buhay ay magkakaroon ng marami, maraming mga hilera, ngunit mananatiling pareho ang mga prinsipyo.

Pagpapangkat ng isang solong Hanay

Sabihin nating nais nating malaman kung gaano karaming mga album ang mayroon tayo para sa bawat artist. Magsimula sa isang tipikal PUMILI query upang makuha ang haligi ng artist_id:

SELECT artist_id FROM albums

Ibinabalik nito ang lahat ng siyam na hilera, tulad ng inaasahan:

+-----------+  
| artist_id |  
+-----------+  
| 1 |  
| 2 |  
| 3 |  
| 4 |  
| 2 |  
| 5 |  
| 6 |  
| 6 |  
| 7 |  
+-----------+

Upang mapangkat ang mga resulta ng artist, idagdag ang parirala GRUPO NG artist_id :

SELECT artist_id FROM albums GROUP BY artist_id

Alin ang nagbibigay ng mga sumusunod na resulta:

+-----------+  
| artist_id |  
+-----------+  
| 1 |  
| 2 |  
| 3 |  
| 4 |  
| 5 |  
| 6 |  
| 7 |  
+-----------+

Mayroong pitong mga hilera sa itinakdang resulta, nabawasan mula sa kabuuang siyam sa mga album mesa Natatangi ang bawat isa artist_id ay may isang solong hilera. Panghuli, upang makuha ang aktwal na bilang, magdagdag COUNT (*) sa mga napiling haligi:

SELECT artist_id, COUNT(*)  
FROM albums  
GROUP BY artist_id  
+-----------+----------+  
| artist_id | COUNT(*) |  
+-----------+----------+  
| 1 | 1 |  
| 2 | 2 |  
| 3 | 1 |  
| 4 | 1 |  
| 5 | 1 |  
| 6 | 2 |  
| 7 | 1 |  
+-----------+----------+

Pinangkat ng mga resulta ang dalawang pares ng mga hilera para sa mga artist na may mga id 2 at 6 . Ang bawat isa ay may dalawang mga album sa aming database.

Kaugnay: Ang Mahalagang SQL ay Nag-uutos sa Cheat Sheet para sa Mga Nagsisimula

Paano Mag-access sa Pinangkat na Data Sa Isang Pinagsamang Pag-andar

Maaaring ginamit mo ang BILANG pagpapaandar dati, partikular sa COUNT (*) form tulad ng nakikita sa itaas. Kinukuha nito ang bilang ng mga resulta sa isang hanay. Maaari mo itong gamitin upang makuha ang kabuuang bilang ng mga tala sa isang talahanayan:

SELECT COUNT(*) FROM albums  
+----------+  
| COUNT(*) |  
+----------+  
| 9 |  
+----------+

Ang COUNT ay isang pinagsamang pagpapaandar. Ang term na ito ay tumutukoy sa mga pagpapaandar na nagsalin ng mga halaga mula sa maraming mga hilera sa isang solong halaga. Kadalasan ginagamit sila kasabay ng pahayag ng GROUP BY.

Sa halip na bilangin lamang ang bilang ng mga hilera, maaari kaming maglapat ng isang pinagsamang pagpapaandar sa mga nakapangkat na halaga:

SELECT artist_id, SUM(sales)  
FROM albums  
GROUP BY artist_id  
+-----------+------------+  
| artist_id | SUM(sales) |  
+-----------+------------+  
| 1 | 14 |  
| 2 | 30 |  
| 3 | 28 |  
| 4 | 17 |  
| 5 | 8 |  
| 6 | 47 |  
| 7 | 28 |  
+-----------+------------+

Ang kabuuang benta na ipinakita sa itaas para sa mga artista 2 at 6 ay pinagsama ang mga benta ng maraming album:

SELECT artist_id, sales  
FROM albums  
WHERE artist_id IN (2, 6)  
+-----------+-------+  
| artist_id | sales |  
+-----------+-------+  
| 2 | 24 |  
| 2 | 6 |  
| 6 | 25 |  
| 6 | 22 |  
+-----------+-------+

Pagpapangkat ayon sa Maramihang Mga Hanay

Maaari kang magpangkat sa pamamagitan ng higit sa isang haligi. Magsama lamang ng maraming mga haligi o expression, na pinaghihiwalay ng mga kuwit. Ang mga resulta ay magpapangkat ayon sa pagsasama ng mga haligi na ito.

SELECT release_year, sales, count(*)  
FROM albums  
GROUP BY release_year, sales

Karaniwan itong makakagawa ng mas maraming mga resulta kaysa sa pagpapangkat ng isang solong haligi:

+--------------+-------+----------+  
| release_year | sales | count(*) |  
+--------------+-------+----------+  
| 1969 | 14 | 1 |  
| 1973 | 24 | 1 |  
| 1977 | 28 | 2 |  
| 1991 | 17 | 1 |  
| 1977 | 6 | 1 |  
| 1973 | 8 | 1 |  
| 2011 | 25 | 1 |  
| 2015 | 22 | 1 |  
+--------------+-------+----------+

Tandaan na, sa aming maliit na halimbawa, dalawang album lamang ang may parehong taon ng paglabas at bilang ng mga benta (28 noong 1977).

Mga Kapaki-pakinabang na Pinagsamang Pag-andar

Bukod sa COUNT, maraming mga function ang gumagana nang maayos sa GROUP. Ang bawat pagpapaandar ay nagbabalik ng isang halaga batay sa mga talaang kabilang sa bawat pangkat ng resulta.

COUNT () ang nagbabalik ng kabuuang bilang ng mga tumutugmang talaan.
Ibinabalik ng SUM () ang kabuuan ng lahat ng mga halaga sa naibigay na haligi na naidagdag.
Ibinabalik ng MIN () ang pinakamaliit na halaga sa isang naibigay na haligi.
Ibinabalik ng MAX () ang pinakamalaking halaga sa isang naibigay na haligi.
Ibinabalik ng AVG () ang average average. Katumbas ito ng SUM () / COUNT ().

Maaari mo ring gamitin ang mga pagpapaandar na ito nang walang sugnay na GROUP:

mga website upang magpatuloy kapag ang iyong nababato

SELECT AVG(sales) FROM albums  
+------------+  
| AVG(sales) |  
+------------+  
| 19.1111 |  
+------------+

Paggamit ng GROUP NG PAMAMARAAN

Tulad din ng isang normal na PUMILI, maaari mo pa ring gamitin KUNG SAAN upang i-filter ang itinakdang resulta:

SELECT artist_id, COUNT(*)  
FROM albums  
WHERE release_year > 1990  
GROUP BY artist_id

+-----------+----------+  
| artist_id | COUNT(*) |  
+-----------+----------+  
| 4 | 1 |  
| 6 | 2 |  
+-----------+----------+

Ngayon mayroon ka lamang mga album na inilabas pagkatapos ng 1990, na nakapangkat ng artist. Maaari mo ring gamitin ang isang sumali sa WHERE cluse, nang nakapag-iisa mula sa GROUP BY:

SELECT r.name, COUNT(*) AS albums  
FROM albums l, artists r  
WHERE artist_id=r.id  
AND release_year > 1990  
GROUP BY artist_id

+---------+--------+  
| name | albums |  
+---------+--------+  
| Nirvana | 1 |  
| Adele | 2 |  
+---------+--------+

Gayunpaman, tandaan na kung susubukan mong mag-filter batay sa isang pinagsamang haligi:

SELECT r.name, COUNT(*) AS albums  
FROM albums l, artists r  
WHERE artist_id=r.id  
AND albums > 2  
GROUP BY artist_id;

Makakatanggap ka ng isang error:

ERROR 1054 (42S22): Unknown column 'albums' in 'where clause'

Ang mga haligi batay sa pinagsama-samang data ay hindi magagamit sa WHERE cluse.

Gamit ang pagkakaroon ng sugnay

Kaya, paano mo mai-filter ang itinakdang resulta matapos maganap ang isang pagpapangkat? Ang MAYROON nakikipag-usap ang sugnay sa pangangailangang ito:

SELECT r.name, COUNT(*) AS albums  
FROM albums l, artists r  
WHERE artist_id=r.id  
GROUP BY artist_id  
HAVING albums > 1;

Tandaan na ang pagkakaroon ng sugnay ay dumating pagkatapos ng GROUP BY. Kung hindi man, mahalagang ito ay isang simpleng kapalit ng WHERE with HAVING. Ang mga resulta ay:

+------------+--------+  
| name | albums |  
+------------+--------+  
| Pink Floyd | 2 |  
| Adele | 2 |  
+------------+--------+

Maaari mo pa ring gamitin ang isang KUNGANONG kondisyon upang salain ang mga resulta bago ang pagpapangkat. Ito ay gagana kasama ang isang pagkakaroon ng sugnay para sa pag-filter pagkatapos ng pagpapangkat:

SELECT r.name, COUNT(*) AS albums  
FROM albums l, artists r  
WHERE artist_id=r.id  
AND release_year > 1990  
GROUP BY artist_id  
HAVING albums > 1;

Isang artista lamang sa aming database ang naglabas ng higit sa isang album pagkatapos ng 1990:

+-------+--------+  
| name | albums |  
+-------+--------+  
| Adele | 2 |  
+-------+--------+

Pagsasama-sama ng Mga Resulta Sa GROUP NI

Ang pahayag ng GROUP BY ay isang hindi kapani-paniwalang kapaki-pakinabang na bahagi ng wikang SQL. Maaari itong magbigay ng impormasyon ng buod ng data, halimbawa, para sa isang pahina ng nilalaman. Ito ay isang mahusay na kahalili sa pagkuha ng maraming dami ng data. Mahusay na hinahawakan ng database ang sobrang dami ng gawaing ito dahil ang disenyo nito ay ginagawang pinakamainam para sa trabaho.

Kapag naintindihan mo ang pagpapangkat at kung paano sumali sa maraming mga talahanayan, magagamit mo ang halos lahat ng lakas ng isang pamanggit na database.

Magbahagi Magbahagi Mag-tweet Email Paano Magtanong ng Maramihang Mga Tables ng Database nang sabay-sabay Sa SQL Sali

Alamin kung paano gamitin ang SQL ay sumali upang i-streamline ang mga query, makatipid ng oras, at iparamdam sa iyo na tulad ng isang gumagamit ng kapangyarihan ng SQL.

mga laro para sa kapag ikaw ay nababato

Basahin Susunod Mga Kaugnay na Paksa

Programming
SQL

Tungkol sa May-akda Bobby Jack(58 Mga Artikulo Na-publish)

Si Bobby ay isang mahilig sa teknolohiya na nagtrabaho bilang isang developer ng software sa loob ng halos dalawang dekada. Masigasig siya sa paglalaro, nagtatrabaho bilang Review Editor sa Switch Player Magazine, at nahuhulog sa lahat ng aspeto ng online na pag-publish at pag-unlad sa web.

Higit pa Mula kay Bobby Jack

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe