Gabungkan Tabel Seperti Pro: Panduan Lengkap MySQL JOINs untuk Data Relasional (Part 9)

Rifqi An Rifqi An
•
Maret 04, 2026


Gabungkan Tabel Seperti Pro: Panduan Lengkap MySQL JOINs untuk Data Relasional (Part 9)

Pernah merasa pusing tujuh keliling waktu mau ngambil data dari berbagai tabel yang saling berhubungan? Udah kayak nyari jarum di tumpukan jerami digital, padahal data-datanya cuma beda meja aja. Apalagi kalau data yang dicari itu adalah orderan kopi teman sekantor yang lagi lembur, biar bisa di-tagih pas gajian. Nah, di tutorial Belajar Database MySQL kita kali ini, kita akan bongkar tuntas gimana caranya "nyatuin" tabel-tabel terpisah jadi satu kesatuan yang rapi pakai MySQL JOINs. Ini bukan cuma sekadar nyambung-nyambungin, tapi ini seni! Siap-siap level ngoding kamu naik satu tingkat!

Daftar Isi

Apa Itu JOINs dan Kenapa Penting?

Bayangin database kamu itu kayak perpustakaan gede. Setiap buku (tabel) punya informasinya sendiri, tapi seringkali kamu butuh informasi dari beberapa buku sekaligus buat nyusun satu cerita lengkap. Misalnya, kamu mau tahu siapa aja pelanggan yang udah pernah order produk apa aja. Informasi pelanggan ada di tabel `Customers`, informasi order ada di tabel `Orders`, dan informasi produk ada di tabel `Products`. Nah, gimana caranya nyambungin tiga buku ini jadi satu laporan yang utuh? Jawabannya ada di JOINs! JOINs adalah operasi SQL yang memungkinkan kita menggabungkan baris dari dua atau lebih tabel berdasarkan kolom yang berhubungan di antara mereka. Kerennya, ini dasar banget buat database relasional. Tanpa JOINs, database relasional cuma kumpulan tabel yang nggak bisa ngobrol satu sama lain. Sama kayak programmer tanpa kopi, nggak bisa berfungsi optimal!

Persiapan Data Kita: Siap-Siap Ngoding!

Sebelum kita masuk ke jenis-jenis JOIN, yuk kita bikin dulu beberapa tabel dan isi datanya. Ini biar kita punya "bahan percobaan" yang seru. Kita akan bikin tabel `Pelanggan` dan `Pesanan`. 

-- Buat Tabel Pelanggan
CREATE TABLE Pelanggan (
    id_pelanggan INT PRIMARY KEY AUTO_INCREMENT,
    nama_pelanggan VARCHAR(100),
    email VARCHAR(100) UNIQUE
);

-- Isi Data Pelanggan
INSERT INTO Pelanggan (nama_pelanggan, email) VALUES
('Budi Santoso', 'budi@example.com'),
('Siti Aminah', 'siti@example.com'),
('Joko Susilo', 'joko@example.com'),
('Ani Rahayu', 'ani@example.com'),
('Udin', NULL); -- Udin ini mystery customer

-- Buat Tabel Pesanan
CREATE TABLE Pesanan (
    id_pesanan INT PRIMARY KEY AUTO_INCREMENT,
    id_pelanggan INT,
    tanggal_pesanan DATE,
    total_pesanan DECIMAL(10, 2),
    FOREIGN KEY (id_pelanggan) REFERENCES Pelanggan(id_pelanggan)
);

-- Isi Data Pesanan
INSERT INTO Pesanan (id_pelanggan, tanggal_pesanan, total_pesanan) VALUES
(1, '2023-10-26', 150000.00), -- Budi
(2, '2023-10-25', 200000.00), -- Siti
(1, '2023-10-27', 50000.00),  -- Budi lagi
(4, '2023-10-24', 300000.00), -- Ani
(99, '2023-10-28', 100000.00); -- Pesanan ini misterius, pelanggan ID 99 tidak ada!
Perhatikan baik-baik! Kita sengaja bikin `id_pelanggan` 99 di tabel `Pesanan` yang nggak ada di tabel `Pelanggan`. Ini buat nunjukkin "keajaiban" JOINs nanti. Juga ada pelanggan 'Udin' yang belum pernah pesen apa-apa (atau data pesenannya belum masuk).

INNER JOIN: Cuma yang Cocok Aja

INNER JOIN itu ibarat kamu lagi nyari teman untuk main game, tapi cuma mau main sama yang punya gamenya juga. Jadi, kalau nggak ada kecocokan di kedua belah pihak (tabel), ya nggak akan ikutan. Gampangannya, ini kayak nyari irisan dari dua set data. Kita mau lihat daftar pelanggan yang *benar-benar* punya pesanan. 

SELECT
    P.nama_pelanggan,
    P.email,
    S.tanggal_pesanan,
    S.total_pesanan
FROM
    Pelanggan AS P
INNER JOIN
    Pesanan AS S ON P.id_pelanggan = S.id_pelanggan;
Hasilnya: Kita akan dapat daftar pesanan lengkap dengan nama dan email pelanggan yang *valid* dan *sudah melakukan pesanan*. Pelanggan 'Udin' tidak akan muncul, dan pesanan dengan `id_pelanggan` 99 juga tidak akan muncul. Kenapa? Karena 'Udin' tidak punya pesanan, dan `id_pelanggan` 99 tidak ada di tabel `Pelanggan`. Ini cuma mengambil data yang cocok *di kedua tabel*.

LEFT JOIN: Prioritaskan yang Kiri

LEFT JOIN (atau kadang disebut `LEFT OUTER JOIN`, tapi `OUTER` opsional di MySQL) ini kayak kamu lagi arisan. Semua anggota arisan (tabel kiri) pasti dipanggil, mau dia dapet giliran atau nggak. Kalau dia dapet giliran (ada kecocokan di tabel kanan), datanya muncul. Kalau nggak dapet, ya tetep muncul namanya, tapi nilai untuk kolom dari tabel kanan jadi `NULL`. Kita mau lihat semua pelanggan, dan kalau mereka punya pesanan, tampilkan pesanannya. Kalau belum ada pesanan, ya biarin aja kosong data pesanannya. 

SELECT
    P.nama_pelanggan,
    P.email,
    S.tanggal_pesanan,
    S.total_pesanan
FROM
    Pelanggan AS P
LEFT JOIN
    Pesanan AS S ON P.id_pelanggan = S.id_pelanggan;
Hasilnya: Semua pelanggan akan muncul, termasuk 'Udin'. Untuk 'Udin', kolom `tanggal_pesanan` dan `total_pesanan` akan berisi `NULL` karena dia belum punya pesanan. Sedangkan pesanan dengan `id_pelanggan` 99 tidak akan muncul karena tabel `Pelanggan` (tabel kiri) tidak memiliki `id_pelanggan` 99.

RIGHT JOIN: Prioritaskan yang Kanan

RIGHT JOIN (atau `RIGHT OUTER JOIN`) adalah kebalikan dari LEFT JOIN. Dia akan mengambil semua baris dari tabel kanan, dan kalau ada kecocokan di tabel kiri, datanya akan digabung. Kalau nggak ada, kolom dari tabel kiri akan berisi `NULL`. Kita mau lihat semua pesanan, dan kalau ada data pelanggannya, tampilkan. Kalau ada pesanan yang `id_pelanggan`-nya nggak valid (misal: 99), ya tetep tampilkan pesanannya, tapi nama pelanggannya jadi `NULL`. 

SELECT
    P.nama_pelanggan,
    P.email,
    S.tanggal_pesanan,
    S.total_pesanan
FROM
    Pelanggan AS P
RIGHT JOIN
    Pesanan AS S ON P.id_pelanggan = S.id_pelanggan;
Hasilnya: Semua pesanan akan muncul, termasuk pesanan dengan `id_pelanggan` 99. Untuk pesanan misterius ini, kolom `nama_pelanggan` dan `email` akan berisi `NULL`. Pelanggan 'Udin' tidak akan muncul dalam hasil ini karena dia tidak memiliki pesanan (tidak ada di tabel kanan).

FULL JOIN (Simulasi): Gabungan Kiri dan Kanan

Nah, ini dia yang agak beda di MySQL. Secara native, MySQL tidak punya syntax `FULL OUTER JOIN`. Tapi, jangan sedih! Kita programmer itu tukang akal-akalan, kan? Kita bisa simulasikan `FULL OUTER JOIN` dengan menggabungkan `LEFT JOIN` dan `RIGHT JOIN` menggunakan operator `UNION ALL`. `UNION ALL` akan menggabungkan hasil dari dua atau lebih query menjadi satu set hasil. `ALL` di sini penting, karena dia akan menyertakan semua baris, termasuk duplikasi. Kita mau lihat semua pelanggan dan semua pesanan, mau ada kecocokan atau nggak. 

-- FULL OUTER JOIN (Simulasi di MySQL)
SELECT
    P.nama_pelanggan,
    P.email,
    S.tanggal_pesanan,
    S.total_pesanan
FROM
    Pelanggan AS P
LEFT JOIN
    Pesanan AS S ON P.id_pelanggan = S.id_pelanggan

UNION ALL

SELECT
    P.nama_pelanggan,
    P.email,
    S.tanggal_pesanan,
    S.total_pesanan
FROM
    Pelanggan AS P
RIGHT JOIN
    Pesanan AS S ON P.id_pelanggan = S.id_pelanggan
WHERE P.id_pelanggan IS NULL; -- Ini penting! Filter untuk menghindari duplikasi data yang sudah terambil di LEFT JOIN
Penting: `WHERE P.id_pelanggan IS NULL` di bagian `RIGHT JOIN` itu kuncinya! Kita cuma mau mengambil baris dari `RIGHT JOIN` yang *tidak* memiliki kecocokan di tabel `Pelanggan` (tabel kiri). Baris yang punya kecocokan sudah diambil oleh `LEFT JOIN`. Tanpa `WHERE` itu, kita akan dapat banyak data duplikat! Hasilnya: Kita akan mendapatkan daftar yang mencakup:
  • Semua pelanggan yang punya pesanan (data dari `INNER JOIN` akan muncul sekali).
  • Pelanggan 'Udin' yang tidak punya pesanan (dari `LEFT JOIN`).
  • Pesanan dengan `id_pelanggan` 99 yang tidak punya pelanggan valid (dari `RIGHT JOIN` dengan filter `WHERE`).
Ini adalah gambaran paling lengkap tentang kedua tabel kita.

Kapan Pake JOIN Apa? Biar Nggak Salah Pilih!

Milih JOIN yang tepat itu penting banget biar query kamu efisien dan hasilnya sesuai ekspektasi. Ini panduan singkatnya:
  • INNER JOIN: Saat kamu hanya ingin melihat data yang *ada di kedua tabel*. Contoh: Daftar pelanggan yang sudah melakukan pembelian.
  • LEFT JOIN: Saat kamu ingin melihat semua data dari tabel "utama" (tabel kiri), dan kalau ada data yang cocok di tabel kanan, ikut sertakan. Kalau tidak ada, ya biarkan `NULL`. Contoh: Daftar semua produk, termasuk produk yang belum pernah terjual.
  • RIGHT JOIN: Kebalikan dari LEFT JOIN. Kamu ingin melihat semua data dari tabel kanan, dan kalau ada yang cocok di tabel kiri, ikut sertakan. Contoh: Daftar semua karyawan, termasuk yang belum punya departemen.
  • FULL JOIN (simulasi): Saat kamu ingin melihat semua data dari kedua tabel, tidak peduli apakah ada kecocokan atau tidak. Contoh: Daftar semua user dan semua postingan, termasuk user yang belum posting dan postingan anonim.
Pilih sesuai kebutuhanmu, jangan sampai salah pilih terus datanya jadi `bug` alias salah! Programmer sejati tahu kapan harus pakai JOIN yang mana.

Latihan: Studi Kasus Programmer Ngantuk

Bayangkan kamu adalah admin database di sebuah perusahaan startup yang baru saja mengeluarkan produk aplikasi pembantu tidur untuk programmer. Nama aplikasinya "DreamCode". Para programmer kantor kamu lagi sering lembur dan sering ngopi. Kamu mau memantau siapa saja programmer yang sudah instal aplikasi DreamCode, dan juga berapa banyak kopi yang sudah mereka pesan via aplikasi kafe kantor. Kamu punya dua tabel: * `Programmer`: `id_programmer` (PK), `nama`, `divisi`, `instal_dreamcode` (BOOLEAN: TRUE jika sudah instal). * `PesananKopi`: `id_pesanan`, `id_programmer` (FK), `jenis_kopi`, `jumlah`, `tanggal_pesan`.

Tugas kamu:

  1. Buat query yang menampilkan semua programmer, dan di sampingnya, tampilkan jenis kopi dan jumlah kopi yang mereka pesan. Jika ada programmer yang belum pernah pesan kopi, tetap tampilkan namanya dengan data kopi yang `NULL`.
  2. Buat query yang menampilkan hanya programmer yang sudah menginstal aplikasi DreamCode dan juga sudah pernah memesan kopi.
  3. Buat query yang menampilkan semua pesanan kopi, dan di sampingnya, tampilkan nama programmer yang memesan. Jika ada pesanan kopi dari `id_programmer` yang tidak valid (misalnya karena programmernya sudah resign dan datanya dihapus), tetap tampilkan pesanan kopinya dengan nama programmer yang `NULL`.

Tips: Jangan lupa pakai alias untuk nama tabel biar query-nya lebih rapi dan gampang dibaca. Selamat ngoding, jangan sampai ngantuk!

Seri "Belajar Database MySQL" ini akan terus berlanjut. Setelah ini, kita akan masuk ke materi yang lebih advanced seperti `GROUP BY`, `HAVING`, hingga menjelajahi dunia `Stored Procedure` dan `Trigger` yang bisa bikin database kamu makin pintar! Jadi, jangan sampai ketinggalan, ya!

Bagikan Artikel Ini