Semua yang Perlu Anda Ketahui Tentang Pernyataan SQL GROUP BY

Semua yang Perlu Anda Ketahui Tentang Pernyataan SQL GROUP BY

Sebagian besar kekuatan database relasional berasal dari pemfilteran data dan menggabungkan tabel. Inilah sebabnya mengapa kami mewakili hubungan tersebut di tempat pertama. Tetapi sistem database modern menyediakan teknik lain yang berharga: pengelompokan.





Pengelompokan memungkinkan Anda untuk mengekstrak informasi ringkasan dari database. Ini memungkinkan Anda menggabungkan hasil untuk membuat data statistik yang berguna. Pengelompokan menyelamatkan Anda dari menulis kode untuk kasus umum seperti daftar rata-rata angka. Dan itu dapat membuat sistem menjadi lebih efisien.



Apa yang Dilakukan Klausa GROUP BY?

GROUP BY, seperti namanya, mengelompokkan hasil ke dalam set yang lebih kecil. Hasilnya terdiri dari satu baris untuk setiap nilai yang berbeda dari kolom yang dikelompokkan. Kita dapat menunjukkan penggunaannya dengan melihat beberapa contoh data dengan baris yang berbagi beberapa nilai umum.





tidak ada suara di laptop saya windows 10

Berikut ini adalah database yang sangat sederhana dengan dua tabel yang mewakili album rekaman. Anda dapat mengatur database seperti itu dengan menulis skema dasar untuk sistem database pilihan Anda. NS album tabel memiliki sembilan baris dengan kunci utama Indo kolom dan kolom untuk nama, artis, tahun rilis, dan penjualan:

+----+---------------------------+-----------+--------------+-------+
| 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 |
+----+---------------------------+-----------+--------------+-------+

NS artis tabel menjadi lebih sederhana. Ini memiliki tujuh baris dengan kolom id dan nama:



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

Anda dapat memahami berbagai aspek GROUP BY hanya dengan kumpulan data sederhana seperti ini. Tentu saja, kumpulan data kehidupan nyata akan memiliki lebih banyak baris, tetapi prinsipnya tetap sama.

Pengelompokan berdasarkan Satu Kolom

Katakanlah kita ingin mengetahui berapa banyak album yang kita miliki untuk setiap artis. Mulailah dengan tipikal PILIH kueri untuk mengambil kolom artist_id:



SELECT artist_id FROM albums

Ini mengembalikan semua sembilan baris, seperti yang diharapkan:

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

Untuk mengelompokkan hasil ini menurut artis, tambahkan frasa KELOMPOK MENURUT artis_id :



SELECT artist_id FROM albums GROUP BY artist_id

Yang memberikan hasil berikut:

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

Ada tujuh baris di set hasil, dikurangi dari total sembilan di album meja. Masing-masing unik artis_id memiliki satu baris. Akhirnya, untuk mendapatkan jumlah sebenarnya, tambahkan MENGHITUNG(*) ke kolom yang dipilih:

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 |
+-----------+----------+

Hasil mengelompokkan dua pasang baris untuk artis dengan id 2 dan 6 . Masing-masing memiliki dua album di database kami.

Terkait: Lembar Cheat Perintah SQL Esensial untuk Pemula

Cara Mengakses Data yang Dikelompokkan Dengan Fungsi Agregat

Anda mungkin pernah menggunakan MENGHITUNG fungsi sebelumnya, terutama di MENGHITUNG(*) bentuk seperti yang terlihat di atas. Ini mengambil jumlah hasil dalam satu set. Anda dapat menggunakannya untuk mendapatkan jumlah total catatan dalam tabel:

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

COUNT adalah fungsi agregat. Istilah ini mengacu pada fungsi yang menerjemahkan nilai dari beberapa baris menjadi satu nilai. Mereka sering digunakan bersama dengan pernyataan GROUP BY.

Daripada hanya menghitung jumlah baris, kita dapat menerapkan fungsi agregat ke nilai yang dikelompokkan:

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 |
+-----------+------------+

Total penjualan yang ditampilkan di atas untuk artis 2 dan 6 adalah gabungan penjualan beberapa album mereka:

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

Pengelompokan berdasarkan Beberapa Kolom

Anda dapat mengelompokkan menurut lebih dari satu kolom. Cukup sertakan beberapa kolom atau ekspresi, dipisahkan dengan koma. Hasilnya akan dikelompokkan menurut kombinasi kolom-kolom tersebut.

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

Ini biasanya akan menghasilkan lebih banyak hasil daripada pengelompokan berdasarkan satu kolom:

+--------------+-------+----------+
| 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 |
+--------------+-------+----------+

Perhatikan bahwa, dalam contoh kecil kami, hanya dua album yang memiliki tahun rilis dan jumlah penjualan yang sama (28 tahun 1977).

Fungsi Agregat yang Berguna

Selain COUNT, beberapa fungsi bekerja dengan baik dengan GROUP. Setiap fungsi mengembalikan nilai berdasarkan catatan milik setiap grup hasil.

  • COUNT() mengembalikan jumlah total catatan yang cocok.
  • SUM() mengembalikan total semua nilai dalam kolom yang diberikan ditambahkan.
  • MIN() mengembalikan nilai terkecil dalam kolom tertentu.
  • MAX() mengembalikan nilai terbesar dalam kolom tertentu.
  • AVG() mengembalikan rata-rata rata-rata. Ini setara dengan SUM() / COUNT().

Anda juga dapat menggunakan fungsi-fungsi ini tanpa klausa GROUP:

apa yang harus dihapus di pembersihan disk windows 10
SELECT AVG(sales) FROM albums
+------------+
| AVG(sales) |
+------------+
| 19.1111 |
+------------+

Menggunakan GROUP BY Dengan Klausa WHERE

Sama seperti SELECT normal, Anda masih dapat menggunakan WHERE untuk memfilter kumpulan hasil:

SELECT artist_id, COUNT(*)
FROM albums
WHERE release_year > 1990
GROUP BY artist_id +-----------+----------+
| artist_id | COUNT(*) |
+-----------+----------+
| 4 | 1 |
| 6 | 2 |
+-----------+----------+

Sekarang Anda hanya memiliki album-album yang dirilis setelah tahun 1990, yang dikelompokkan berdasarkan artis. Anda juga dapat menggunakan join dengan klausa WHERE, terlepas dari 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 |
+---------+--------+

Namun, perhatikan bahwa jika Anda mencoba memfilter berdasarkan kolom gabungan:

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

Anda akan mendapatkan kesalahan:

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

Kolom berdasarkan data agregat tidak tersedia untuk klausa WHERE.

Menggunakan Klausa HAVING

Jadi, bagaimana Anda memfilter hasil yang ditetapkan setelah pengelompokan dilakukan? NS MEMILIKI klausul berkaitan dengan kebutuhan ini:

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

Perhatikan bahwa klausa HAVING muncul setelah GROUP BY. Jika tidak, ini pada dasarnya adalah penggantian sederhana dari WHERE dengan HAVING. Hasilnya adalah:

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

Anda masih dapat menggunakan kondisi WHERE untuk memfilter hasil sebelum pengelompokan. Ini akan bekerja sama dengan klausa HAVING untuk memfilter setelah pengelompokan:

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;

Hanya satu artis dalam database kami yang merilis lebih dari satu album setelah tahun 1990:

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

Menggabungkan Hasil Dengan GROUP BY

Pernyataan GROUP BY adalah bagian yang sangat berguna dari bahasa SQL. Ini dapat memberikan informasi ringkasan data, untuk halaman konten, misalnya. Ini adalah alternatif yang sangat baik untuk mengambil data dalam jumlah besar. Basis data menangani beban kerja ekstra ini dengan baik karena desainnya membuatnya optimal untuk pekerjaan itu.

Setelah Anda memahami pengelompokan dan cara menggabungkan beberapa tabel, Anda akan dapat memanfaatkan sebagian besar kekuatan database relasional.

Membagikan Membagikan Menciak Surel Cara Query Beberapa Tabel Database Sekaligus Dengan SQL Joins

Pelajari cara menggunakan gabungan SQL untuk menyederhanakan kueri, menghemat waktu, dan membuat Anda merasa seperti pengguna hebat SQL.

instal windows media player windows 10
Baca Selanjutnya Topik-topik yang berkaitan
  • Pemrograman
  • SQL
Tentang Penulis Bobby Jack(58 Artikel Diterbitkan)

Bobby adalah penggemar teknologi yang bekerja sebagai pengembang perangkat lunak selama hampir dua dekade. Dia bersemangat tentang game, bekerja sebagai Editor Ulasan di Majalah Switch Player, dan mendalami semua aspek penerbitan online & pengembangan web.

More From Bobby Jack

Berlangganan newsletter kami

Bergabunglah dengan buletin kami untuk kiat teknologi, ulasan, ebook gratis, dan penawaran eksklusif!

Klik di sini untuk berlangganan