20 Kesalahan Umum dalam SQL Query yang Bikin Ngedrop Performa

20 Kesalaham Umum dalam SQL Query yang Bikin Ngedrop Performa

Menulis query SQL yang berfungsi itu satu hal, tapi menulis query yang efisien dan scalable itu hal lain. Jika query ditulis dengan buruk, hasilnya bisa membuat aplikasi lambat, membuat pengguna frustrasi, bahkan bisa menyebabkan crash pada sistem produksi.

Berikut adalah 20 kesalahan umum yang sering dilakukan dan cara menghindarinya:

Kesalahan 1

**Menggunakan SELECT * (Si Pemalas)**

Masalah: Mengambil semua kolom tanpa pertimbangan.
Kenapa buruk: Meningkatkan I/O, penggunaan memori, dan memperlambat JOIN.
Solusi: Pilih hanya kolom yang diperlukan.

SELECT name, email FROM users;

SELECT name, email FROM users;

Kesalahan 2

Tidak Membuat Index

Masalah: Tidak ada indeks pada kolom yang sering digunakan.
Dampak: Query jadi lambat karena melakukan full table scan.
Solusi: Tambahkan indeks pada kolom yang digunakan di WHERE, JOIN, atau ORDER BY.

CREATE INDEX idx_users_email ON users(email);

CREATE INDEX idx_users_email ON users(email);

Kesalahan 3

Terlalu Banyak Index

Masalah: Menambahkan indeks berlebihan.
Dampak: Memperlambat proses INSERT/UPDATE dan memperbesar ukuran database.
Solusi: Tambahkan indeks hanya pada query penting. Gunakan EXPLAIN untuk analisis.

Kesalahan 4

Menggunakan Fungsi di Kolom yang Diindeks

Masalah: Memakai fungsi seperti UPPER() di kolom indexed dalam WHERE.
Dampak: Index tidak digunakan.
Solusi: Hindari fungsi di kolom indexed.

-- Hindari
WHERE UPPER(email) = 'USER@EXAMPLE.COM'

-- Lebih baik
WHERE email = LOWER('user@example.com')

-- Hindari
WHERE UPPER(email) = 'USER@EXAMPLE.COM'

-- Lebih baik
WHERE email = LOWER('user@example.com')

Kesalahan 5

JOIN Tanpa Filter

Masalah: JOIN tabel besar tanpa kondisi filter.
Dampak: Memperlambat query secara drastis.
Solusi: Filter data sebelum JOIN.

SELECT ...
FROM large_table lt
JOIN small_table st ON lt.id = st.id
WHERE st.status = 'active';

SELECT ...
FROM large_table lt
JOIN small_table st ON lt.id = st.id
WHERE st.status = 'active';

Kesalahan 6

Menggunakan IN daripada EXISTS

Masalah: Subquery dengan IN bisa lambat.
Solusi: Gunakan EXISTS untuk subquery korelatif.

-- Hindari
SELECT name FROM users WHERE id IN (SELECT user_id FROM logins);

-- Lebih baik
SELECT name FROM users u WHERE EXISTS (
  SELECT 1 FROM logins l WHERE l.user_id = u.id
);

-- Hindari
SELECT name FROM users WHERE id IN (SELECT user_id FROM logins);

-- Lebih baik
SELECT name FROM users u WHERE EXISTS (
  SELECT 1 FROM logins l WHERE l.user_id = u.id
);

Kesalahan 7

Tidak Menggunakan LIMIT pada Hasil Besar

Masalah: Mengambil jutaan baris sekaligus.
Dampak: Membebani jaringan dan memori.
Solusi: Gunakan pagination dengan LIMIT dan OFFSET.

SELECT ...
FROM large_table lt
LIMIT 100

SELECT ...
FROM large_table lt
LIMIT 100

Kesalahan 8

Salah Tipe Data

Masalah: Menyimpan angka sebagai VARCHAR atau tanggal sebagai string.
Dampak: Perbandingan lambat dan boros ruang.
Solusi: Gunakan tipe data yang tepat: INT, DATE, DATETIME.

Kesalahan 9

Subquery di SELECT

Masalah: Subquery yang dijalankan per baris.
Dampak: Eksekusi sangat lambat.
Solusi: Gunakan JOIN atau WITH (CTE).

WITH order_counts AS (
  SELECT user_id, COUNT(*) AS count FROM orders GROUP BY user_id
)
SELECT u.name, oc.count
FROM users u
LEFT JOIN order_counts oc ON u.id = oc.user_id;

WITH order_counts AS (
  SELECT user_id, COUNT(*) AS count FROM orders GROUP BY user_id
)
SELECT u.name, oc.count
FROM users u
LEFT JOIN order_counts oc ON u.id = oc.user_id;

Kesalahan 10

Menggunakan DISTINCT untuk Menyembunyikan Duplikat

Masalah: DISTINCT sering digunakan untuk menutupi kesalahan JOIN.
Solusi: Perbaiki logika JOIN, bukan tambal sulam.

Kesalahan 11

Tidak Menggunakan Caching

Masalah: Query berat dijalankan berulang kali.
Solusi: Gunakan materialized view atau caching di level aplikasi.

Kesalahan 12

Terlalu Banyak Kondisi OR

Masalah: Banyak OR menghambat penggunaan index.
Solusi: Gunakan UNION atau pecah query.

Kesalahan 13

Overuse CTE atau Temporary Table

Masalah: Terlalu banyak CTE membuat query lambat.
Solusi: Inline logic atau pecah query.

Kesalahan 14

Tidak Menggunakan EXPLAIN

Masalah: Query dijalankan tanpa analisis.
Solusi: Selalu gunakan EXPLAIN untuk melihat rencana eksekusi.

Kesalahan 15

Tidak Filter Kolom Partisi

Masalah: Tidak memanfaatkan kolom partisi di WHERE.
Dampak: Membaca semua partisi.

Kesalahan 16

JOIN Cartesian (Tanpa Kondisi)

Masalah: JOIN tanpa kondisi, hasil miliaran baris.
Solusi: Pastikan semua JOIN punya kondisi yang benar.

Kesalahan 17

Terlalu Banyak JOIN

Masalah: JOIN lebih dari 10 tabel.
Solusi: Pecah query atau buat view.

Kesalahan 18

ORDER BY Tanpa Index

Masalah: Sorting pada tabel besar tanpa index.
Solusi: Buat index pada kolom yang sering diurutkan.

Kesalahan 19

Triggers Berat

Masalah: Trigger yang melakukan proses besar.
Solusi: Pindahkan ke proses asynchronous atau job queue.

Kesalahan 20

Tidak Mengarsipkan Data Lama

Masalah: Query tabel besar dengan data yang sudah tidak relevan.
Solusi: Arsipkan atau hapus data lama secara rutin.

Bonus Tips

Hindari konversi tipe data implicit (misal: INT vs VARCHAR)
Gunakan IS NULL (bukan = NULL)
Gunakan connection pooling untuk mengurangi overhead koneksi

Kesimpulan

Mengoptimalkan SQL bukan hanya soal query yang berjalan, tapi query yang skalabel. Selalu pikirkan dari sudut pandang database engine: seberapa banyak data yang harus dibaca, diurutkan, atau digabung?
Gunakan EXPLAIN, monitor query lambat, dan lakukan profiling secara berkala. Perubahan kecil = peningkatan besar!