Query dengan JOIN
Untuk apa kita perlu query join? Query join berfungsi untuk menggabungkan beberapa tabel menjadi sebuah tabel gabungan. Teknik menggabung tersebut adalah keunggulan dari basis data relasional (RDBMS: Relational Database Management System), dimana data dapat disimpan dalam beberapa tabel kecil yang terpisah, bukannya satu tabel besar dengan banyak kolom. Pada dunia nyata pemrograman, query join sangat banyak dan hampir selalu digunakan, karena dengan itu sebenarnya kunci pengolahan data dengan SQL dan dari situ dapat dihasilkan informasi-informasi yang lebih bermakna dibandingkan dengan query satu tabel saja.
Cara kerja join ialah dengan mencari kecocokan kolom tertentu pada sebuah tabel dengan kolom tertentu pada tabel lain, kemudian menampilkan hasilnya sebagai satu set data gabungan. Secara garis besar, terdapat 3 macam join, yaitu INNER JOIN, LEFT JOIN dan RIGHT JOIN. Namun, selain dari 3 macam tersebut, terdapat tambahan beberapa varian tergantung dari RDBMS yang digunakan.
Sebagai contoh, kita akan men-join tabel pasien yang menyimpan informasi biodata pasien-pasien, dengan tabel symptom yang menyimpan data-data symptom yang diderita oleh pasien. Kedua tabel tersebut akan di-join berdasarkan kolom yang berisi nomor identitas pasien (id) yang terdapat pada kedua tabel.
CREATE TABLE pasien (id int(10), nama char(30));
INSERT INTO pasien (id,nama) VALUES ('1','John');
INSERT INTO pasien (id,nama) VALUES ('2','Jane');
INSERT INTO pasien (id,nama) VALUES ('3','Mike');
INSERT INTO pasien (id,nama) VALUES ('4','Doel');
CREATE TABLE symptom (id int(10), symptom char(30));
INSERT INTO symptom (id,symptom) VALUES ('1','Demam');
INSERT INTO symptom (id,symptom) VALUES ('2','Pusing');
INSERT INTO symptom (id,symptom) VALUES ('3','Mual');
INNER JOIN
Dengan INNER JOIN hanya akan ditampilkan baris-baris yang satu sama lain memiliki kecocokan.
Contoh:
SELECT a.nama, b.symptom
FROM pasien a
INNER JOIN symptom b
ON b.id = a.id;
+------+---------+
| nama | symptom |
+------+---------+
| John | Demam |
| Jane | Pusing |
| Mike | Mual |
+------+---------+
LEFT JOIN
Sebuah query dengan LEFT JOIN akan menampilkan semua baris dari tabel sebelah kiri (pertama/utama atau pasien) dengan gabungan dari tabel sebelah kanan (kedua atau symptom).
Contoh:
SELECT a.nama, b.symptomPerbedaannya dengan INNER JOIN ialah, pada LEFT JOIN - seluruh baris dari tabel pertama akan ditampilkan meskipun tidak ada kecocokan baris pada tabel kedua. Lihat contoh diatas, pasien Doel tidak memiliki data symptom sehingga tertampil NULL (NULL disini menyatakan bahwa tidak ada data pada kolom tersebut). Selain itu, posisi tabel jadi mempunyai makna, yaitu tabel kiri atau pertama (ialah tabel sebelum 'LEFT JOIN') akan menjadi tabel utama yang diquery terlebih dahulu, baru kemudian dicarikan kecocokannya dengan tabel kanan atau kedua (ialah tabel setelah 'LEFT JOIN').
FROM pasien a
LEFT JOIN symptom b
ON b.id = a.id;
+------+---------+
| nama | symptom |
+------+---------+
| John | Demam |
| Jane | Pusing |
| Mike | Mual |
| Doel | NULL |
+------+---------+
RIGHT JOIN
Query RIGHT JOIN hampir sama dengan LEFT JOIN, hanya saja posisinya terbalik, yaitu akan menampilkan semua baris dari tabel kanan (kedua) meskipun tidak ada kecocokan pada tabel kiri (pertama).
Contoh:
SELECT a.nama, b.symptom
FROM pasien a
RIGHT JOIN symptom b
ON b.id = a.id;
+------+---------+
| nama | symptom |
+------+---------+
| John | Demam |
| Jane | Pusing |
| Mike | Mual |
+------+---------+
Jika ada yang bertanya dengan sebuah kasus, harus menggunakan join yang mana? Maka kita perlu melihat keperluan terlebih dahulu, selain itu optimasi juga perlu menjadi pertimbangan, intinya ialah ketiga macam join dapat digunakan. Namun, saya pribadi paling sering menggunakan LEFT JOIN dibanding jenis JOIN yang lain. Alasan saya ialah, query LEFT JOIN lebih fleksibel dan lebih mudah dioptimasi. Mari kita ambil contoh query dengan INNER JOIN diatas, dapat juga dihasilkan dengan query LEFT JOIN, dengan menambahkan klausa WHERE:
SELECT a.nama, b.symptomAtau pun query RIGHT JOIN diatas dihasilkan dengan model LEFT JOIN, hanya dengan membalik urutan tabel:
FROM pasien a
LEFT JOIN symptom b
ON b.id = a.id
WHERE b.symptom IS NOT NULL;
SELECT a.nama, b.symptomKemudian salah satu pertimbangan kecenderungan saya menggunakan LEFT JOIN ialah untuk optimasi. Contoh, misalnya kita dihadapkan pada tabel pasien dan tabel symptom, jika ada pertanyaan untuk menampilkan pasien dengan sebuah symptom tertentu, misalnya demam, maka saya akan menempatkan tabel symptom sebagai tabel utama, baru kemudian tabel pasien sebagai tabel kedua:
FROM symptom b
LEFT JOIN pasien a
ON b.id = a.id;
SELECT a.id,b.namaBagaimana query tersebut lebih optimal? Penjelasannya begini: query tersebut akan mencari record-record dari tabel symptom yang memenuhi kriteria symptom = 'Demam', hal ini akan menghindari full table scan (dengan catatan jika ada indeks berdasarkan symptom), selanjutnya akan dicari padanan id di tabel pasien. Sebagai catatan: full tabel scan akan memakan sumber daya memori dan tenaga proses di CPU, membuat query menjadi sangat lambat terutama jika tabel memiliki jutaan record. Mengenai indeks pada tabel akan saya jelaskan pada kesempatan lain.
FROM symptom a
LEFT JOIN pasien b
ON b.id = a.id
WHERE a.symptom = 'Demam';
Lalu bagaimana dengan RIGHT JOIN? Sebenarnya RIGHT JOIN dapat pula didayagunakan seperti LEFT JOIN, hanya masalah kebiasaan saja. Kadang-kadang saya juga menggunakan RIGHT JOIN untuk kasus tertentu demi alasan code readability atau simplicity.
