# Belajar Analisis Data – Hari 12: GROUP BY dan HAVING

- Link: https://legawa.com/teknologi/belajar-analisis-data-hari-12-group-by-dan-having/
- Published: 2026-11-22T09:00:00+07:00
- Author: Cahya

Ringkasan: GROUP BY mengelompokkan baris yang memiliki nilai sama, lalu fungsi agregat
seperti COUNT dan SUM meringkas setiap kelompok, dan HAVING menyaring kelompok itu
setelah angkanya dihitung. Bagi data analyst pemula, perbedaan antara WHERE dan 
HAVING sering menjadi sumber hasil yang meleset, jadi saya mencatatnya dengan contoh
yang bisa dijalankan ulang.

## Tujuan belajar

 * Menulis query GROUP BY dengan fungsi agregat COUNT dan SUM.
 * Membedakan WHERE yang menyaring baris dari HAVING yang menyaring kelompok.
 * Menuliskan logika yang sama di pandas dan tidyverse, lalu memeriksa apakah hasilnya
   cocok.

## Konsep inti

Saat pertama kali membaca query GROUP BY, saya mengira klausa itu hanya mengurutkan
data. Ternyata ia membuat kelompok baru. Setiap baris dengan nilai kolom yang sama
masuk ke kelompok yang sama, lalu fungsi agregat dihitung untuk tiap kelompok. PostgreSQL
menggambarkan WHERE, GROUP BY, dan HAVING sebagai rangkaian transformasi berurutan
terhadap tabel hasil FROM, dan hasil akhirnya baru diteruskan ke daftar SELECT (
PostgreSQL Global Development Group, n.d.).

![Diagram alur: lima baris data diringkas menjadi tiga kelompok kota oleh GROUP 
BY, lalu HAVING menyaring kelompok dengan total di atas 100 sehingga Kudus tersisih](
https://i0.wp.com/legawa.com/wp-content/uploads/2026/11/ilustrasi-hari-12-alur-where-
group-by-having.png?resize=1000%2C560&ssl=1)

Ilustrasi konseptual dengan data sintetis: lima baris dikelompokkan per kota, lalu
HAVING menyisihkan kelompok Kudus.

Pembedaan yang paling penting ada di sini. WHERE bekerja pada baris sebelum pengelompokan,
sedangkan HAVING bekerja pada kelompok setelah fungsi agregat dihitung. DataCamp
merangkumnya dengan cara serupa: WHERE menyaring baris sebelum agregasi, dan HAVING
menerapkan kondisi setelah agregasi (DataCamp, n.d.). Karena itu, kondisi yang memakai
SUM(total) atau COUNT(*) harus ditulis di HAVING. Hasil agregat belum ada ketika
WHERE dijalankan.

Pandas punya padanan konsep ini lewat groupby. Dokumentasi pandas menyebut bahwa
groupby menyerupai GROUP BY di SQL, dan parameter as_index=False menghasilkan keluaran
yang bergaya SQL, dengan kolom kelompok tetap menjadi kolom biasa (pandas development
team, n.d.). Bawaan parameter dropna adalah True, sehingga baris dengan kunci kelompok
kosong dibuang dari hasil. Hal ini perlu diingat ketika total gabungan tidak cocok
dengan tabel sumber.

## Contoh kode

Contoh berikut memakai data pesanan sintetis yang sama dengan Hari 11, berisi lima
baris dari tiga kota. Setiap contoh menghitung jumlah pesanan selesai dan total 
penjualannya per kota, lalu hanya menampilkan kota dengan total di atas 220000.

    ```wp-block-code
    -- SQL (PostgreSQL): total pesanan selesai per kota, hanya kota di atas 220000
    SELECT
      kota,
      COUNT(*)   AS jumlah_pesanan,
      SUM(total) AS total_penjualan
    FROM pesanan
    WHERE status = 'selesai'            -- menyaring baris sebelum dikelompokkan
    GROUP BY kota                       -- satu kelompok per kota
    HAVING SUM(total) > 220000          -- menyaring kelompok setelah dijumlahkan
    ORDER BY total_penjualan DESC;
    -- hasil: Sragen, 2 pesanan, total 245000
    ```

    ```wp-block-code
    # Python (pandas)
    import pandas as pd

    pesanan = pd.DataFrame({
        "id_pesanan": [1, 2, 3, 4, 5],
        "pelanggan": ["Andi", "Rina", "Budi", "Sari", "Dedi"],
        "kota": ["Sragen", "Solo", "Sragen", "Yogyakarta", "Solo"],
        "total": [150000, 80000, 95000, 210000, 45000],
        "status": ["selesai", "batal", "selesai", "selesai", "proses"],
    })

    # WHERE: saring baris
    selesai = pesanan[pesanan["status"] == "selesai"]

    # GROUP BY dan agregat; as_index=False agar hasil bergaya SQL
    per_kota = (
        selesai.groupby("kota", as_index=False)
        .agg(jumlah_pesanan=("id_pesanan", "count"),
             total_penjualan=("total", "sum"))
    )

    # HAVING: saring kelompok, lalu urutkan (ORDER BY)
    hasil = (per_kota[per_kota["total_penjualan"] > 220000]
             .sort_values("total_penjualan", ascending=False))
    print(hasil)   # Sragen, 2, 245000
    ```

    ```wp-block-code
    # R (tidyverse)
    library(tidyverse)

    pesanan <- tibble(
      id_pesanan = 1:5,
      pelanggan = c("Andi", "Rina", "Budi", "Sari", "Dedi"),
      kota = c("Sragen", "Solo", "Sragen", "Yogyakarta", "Solo"),
      total = c(150000, 80000, 95000, 210000, 45000),
      status = c("selesai", "batal", "selesai", "selesai", "proses")
    )

    pesanan |>
      filter(status == "selesai") |>            # WHERE
      group_by(kota) |>                         # GROUP BY
      summarise(
        jumlah_pesanan  = n(),
        total_penjualan = sum(total),
        .groups = "drop"
      ) |>
      filter(total_penjualan > 220000) |>     # HAVING
      arrange(desc(total_penjualan))            # ORDER BY
    ```

### Contoh kecil

Bandingkan dua query pada data yang sama. Jika kondisi total > 100000 ditaruh di
WHERE, yang disaring adalah pesanan satu per satu. Hasilnya hanya Sragen dengan 
150000 dan Yogyakarta dengan 210000, sedangkan Solo hilang sepenuhnya. Jika kondisi
SUM(total) > 100000 ditaruh di HAVING, total setiap kota dihitung dulu: Sragen 245000,
Solo 125000, dan Yogyakarta 210000, sehingga ketiganya lolos.

## Kesalahan yang sering terjadi

Waspadai tiga hal ini:

 * Menaruh kondisi agregat di WHERE, misalnya WHERE SUM(total) > 100000. Kondisi
   seperti ini harus pindah ke HAVING, karena WHERE diproses sebelum pengelompokan.
 * Memakai alias dari SELECT di WHERE atau HAVING. Alias baru dibuat setelah HAVING
   diproses, sehingga belum dikenal di sana. Tulis ulang ekspresi aslinya.
 * Di pandas, mengandalkan groupby tanpa memeriksa dropna. Dengan bawaan dropna=
   True, kelompok berkunci kosong dibuang, sehingga total gabungan bisa berbeda 
   dari tabel sumber. Gunakan dropna=False bila kelompok kosong harus ikut dihitung.

## Latihan

 1. Dari tabel pesanan dengan semua status (tanpa WHERE), tulis query yang menampilkan
    kota dengan total penjualan di atas 150000 beserta jumlah pesanannya.
 2. Query berikut gagal: SELECT kota, SUM(total) AS t FROM pesanan GROUP BY kota HAVING
    t > 150000; Apa masalahnya, dan bagaimana memperbaikinya?
 3. Apa perbedaan hasil groupby(“kota”) dan groupby(“kota”, as_index=False) di pandas?

Kunci jawaban singkat: (1) SELECT kota, COUNT(*) AS jumlah_pesanan, SUM(total) AS
total_penjualan FROM pesanan GROUP BY kota HAVING SUM(total) > 150000; menghasilkan
Sragen dengan 2 pesanan dan total 245000, serta Yogyakarta dengan 1 pesanan dan 
total 210000. Solo tersisih karena totalnya 125000. (2) Alias t dibuat di SELECT,
yang diproses setelah HAVING, sehingga belum dikenal. Tulis ulang menjadi HAVING
SUM(total) > 150000. (3) Pada bentuk default, kota menjadi index DataFrame. Dengan
as_index=False, kota tetap menjadi kolom biasa, seperti pada hasil SQL (pandas development
team, n.d.).

## Ringkasan

GROUP BY mengubah baris menjadi kelompok, fungsi agregat meringkas tiap kelompok,
dan HAVING menyaring kelompok itu setelah angkanya dihitung. Pegang satu aturan 
sederhana: kondisi pada baris masuk ke WHERE, kondisi pada hasil agregat masuk ke
HAVING. Besok, pada Hari 13, saya lanjut ke JOIN, cara menggabungkan dua tabel dengan
jenis inner, left, right, dan full, yang dijadwalkan terbit 23 November 2026 pukul
09.00 WIB.

### Sumber bacaan

DataCamp. (n.d.). PostgreSQL HAVING. [https://www.datacamp.com/doc/postgresql/having](https://www.datacamp.com/doc/postgresql/having)

PostgreSQL Global Development Group. (n.d.). 7.2. Table expressions. PostgreSQL 
documentation. [https://www.postgresql.org/docs/9/queries-table-expressions.html](https://www.postgresql.org/docs/9/queries-table-expressions.html)

pandas development team. (n.d.). pandas.DataFrame.groupby. pandas documentation.
[https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.groupby.html](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.groupby.html)

Catatan data: seluruh angka pada tulisan ini berasal dari data sintetis yang saya
buat sendiri. Tidak ada data pasien atau data pribadi nyata di dalamnya.

**Navigasi seri Belajar Analisis Data**

 * Berikutnya: Hari 13, SQL: JOIN (inner, left, right, full) (terbit 23 November
   2026 pukul 09.00 WIB)
 * [Semua tulisan seri Belajar Analisis Data](https://legawa.com/tag/data-analyst/)
 * Sebelumnya: [Hari 11, SQL Dasar: SELECT, WHERE, ORDER BY, dan LIMIT](https://legawa.com/teknologi/belajar-analisis-data-hari-11-sql-dasar-select-where-order-by-dan-limit/)
